gcc/config/ptx4.h

   1 /* Operating system specific defines to be used when targeting GCC for some
   2    generic System V Release 4 system.
   3    Copyright (C) 1996 Free Software Foundation, Inc.
   4    Contributed by Ron Guilmette (rfg@monkeys.com).
   5    Renamed and changed to suit Dynix/ptx v4 and later.
   6    Modified by Tim Wright (timw@sequent.com).
   7
   8 This file is part of GNU CC.
   9
  10 GNU CC is free software; you can redistribute it and/or modify
  11 it under the terms of the GNU General Public License as published by
  12 the Free Software Foundation; either version 2, or (at your option)
  13 any later version.
  14
  15 GNU CC is distributed in the hope that it will be useful,
  16 but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 GNU General Public License for more details.
  19
  20 You should have received a copy of the GNU General Public License
  21 along with GNU CC; see the file COPYING.  If not, write to
  22 the Free Software Foundation, 59 Temple Place - Suite 330,
  23 Boston, MA 02111-1307, USA.
  24
  25 */
  26
  27 /* Define a symbol indicating that we are using svr4.h.  */
  28 #define USING_SVR4_H
  29
  30 /* For the sake of libgcc2.c, indicate target supports atexit.  */
  31 #define HAVE_ATEXIT
  32
  33 /* Cpp, assembler, linker, library, and startfile spec's.  */
  34
  35 /* This defines which switch letters take arguments.  On svr4, most of
  36    the normal cases (defined in gcc.c) apply, and we also have -h* and
  37    -z* options (for the linker).  Note however that there is no such
  38    thing as a -T option for svr4.  */
  39
  40 #define SWITCH_TAKES_ARG(CHAR) \
  41   (   (CHAR) == 'D' \
  42    || (CHAR) == 'U' \
  43    || (CHAR) == 'o' \
  44    || (CHAR) == 'e' \
  45    || (CHAR) == 'u' \
  46    || (CHAR) == 'I' \
  47    || (CHAR) == 'm' \
  48    || (CHAR) == 'L' \
  49    || (CHAR) == 'A' \
  50    || (CHAR) == 'h' \
  51    || (CHAR) == 'z')
  52
  53 /* This defines which multi-letter switches take arguments.  On svr4,
  54    there are no such switches except those implemented by GCC itself.  */
  55
  56 #define WORD_SWITCH_TAKES_ARG(STR)                      \
  57  (DEFAULT_WORD_SWITCH_TAKES_ARG (STR)                   \
  58   && strcmp (STR, "Tdata") && strcmp (STR, "Ttext")     \
  59   && strcmp (STR, "Tbss"))
  60
  61 /* You should redefine CPP_PREDEFINES in any file which includes this one.
  62    The definition should be appropriate for the type of target system
  63    involved, and it should include any -A (assertion) options which are
  64    appropriate for the given target system.  */
  65 #undef CPP_PREDEFINES
  66
  67 /* Provide an ASM_SPEC appropriate for svr4.  Here we try to support as
  68    many of the specialized svr4 assembler options as seems reasonable,
  69    given that there are certain options which we can't (or shouldn't)
  70    support directly due to the fact that they conflict with other options
  71    for other svr4 tools (e.g. ld) or with other options for GCC itself.
  72    For example, we don't support the -o (output file) or -R (remove
  73    input file) options because GCC already handles these things.  We
  74    also don't support the -m (run m4) option for the assembler because
  75    that conflicts with the -m (produce load map) option of the svr4
  76    linker.  We do however allow passing arbitrary options to the svr4
  77    assembler via the -Wa, option.
  78
  79    Note that gcc doesn't allow a space to follow -Y in a -Ym,* or -Yd,*
  80    option.
  81 */
  82
  83 #undef ASM_SPEC
  84 #define ASM_SPEC \
  85   "-no_0f_fix %{v:-V} %{Qy:} %{!Qn:-Qy} %{n} %{T} %{Ym,*} %{Yd,*} %{Wa,*:%*}"
  86
  87 /* svr4 assemblers need the `-' (indicating input from stdin) to come after
  88    the -o option (and its argument) for some reason.  If we try to put it
  89    before the -o option, the assembler will try to read the file named as
  90    the output file in the -o option as an input file (after it has already
  91    written some stuff to it) and the binary stuff contained therein will
  92    cause totally confuse the assembler, resulting in many spurious error
  93    messages.  */
  94
  95 #undef ASM_FINAL_SPEC
  96 #define ASM_FINAL_SPEC "%{pipe:-}"
  97
  98 /* Provide a LIB_SPEC appropriate for svr4.  Here we tack on the default
  99    standard C library (unless we are building a shared library).  */
 100
 101 #undef  LIB_SPEC
 102 #define LIB_SPEC "%{!shared:%{!symbolic:-lc}}"
 103
 104 /* Provide a LIBGCC_SPEC appropriate for svr4.  We also want to exclude
 105    libgcc when -symbolic.  */
 106
 107 #undef  LIBGCC_SPEC
 108 #define LIBGCC_SPEC "%{!shared:%{!symbolic:-lgcc}}"
 109
 110 /* Provide an ENDFILE_SPEC appropriate for svr4.  Here we tack on our own
 111    magical crtend.o file (see crtstuff.c) which provides part of the
 112    support for getting C++ file-scope static object constructed before
 113    entering `main', followed by the normal svr3/svr4 "finalizer" file,
 114    which is either `gcrtn.o' or `crtn.o'.  */
 115
 116 #undef  ENDFILE_SPEC
 117 #define ENDFILE_SPEC "crtend.o%s %{pg:gcrtn.o}%{!pg:crtn.o%s}"
 118
 119 /* Provide a LINK_SPEC appropriate for svr4.  Here we provide support
 120    for the special GCC options -static, -shared, and -symbolic which
 121    allow us to link things in one of these three modes by applying the
 122    appropriate combinations of options at link-time.  We also provide
 123    support here for as many of the other svr4 linker options as seems
 124    reasonable, given that some of them conflict with options for other
 125    svr4 tools (e.g. the assembler).  In particular, we do support the
 126    -h*, -z*, -V, -b, -t, -Qy, -Qn, and -YP* options here, and the -e*,
 127    -l*, -o*, -r, -s, -u*, and -L* options are directly supported
 128    by gcc.c itself.  We don't directly support the -m (generate load
 129    map) option because that conflicts with the -m (run m4) option of
 130    the svr4 assembler.  We also don't directly support the svr4 linker's
 131    -I* or -M* options because these conflict with existing GCC options.
 132    We do however allow passing arbitrary options to the svr4 linker
 133    via the -Wl, option.  We don't support the svr4 linker's -a option
 134    at all because it is totally useless and because it conflicts with
 135    GCC's own -a option.
 136
 137    Note that gcc doesn't allow a space to follow -Y in a -YP,* option.
 138
 139    When the -G link option is used (-shared and -symbolic) a final link is
 140    not being done.  */
 141
 142 #undef  LINK_SPEC
 143 #define LINK_SPEC "%{h*} %{v:-V} \
 144                    %{b} %{Wl,*:%*} \
 145                    %{static:-dn -Bstatic} \
 146                    %{shared:-G -dy -z text %{!h*:%{o*:-h %*}}} \
 147                    %{symbolic:-Bsymbolic -G -dy -z text %{!h*:%{o*:-h %*}}} \
 148                    %{G:-G} \
 149                    %{YP,*} \
 150                    %{!YP,*:%{p:-Y P,/lib/libp:/usr/lib/libp:/lib:/usr/lib} \
 151                     %{!p:-Y P,/lib:/usr/lib}} \
 152                    %{Qy:} %{!Qn:-Qy}"
 153
 154 /* Gcc automatically adds in one of the files /lib/values-Xc.o,
 155    /lib/values-Xa.o, or /lib/values-Xt.o for each final link
 156    step (depending upon the other gcc options selected, such as
 157    -traditional and -ansi).  These files each contain one (initialized)
 158    copy of a special variable called `_lib_version'.  Each one of these
 159    files has `_lib_version' initialized to a different (enum) value.
 160    The SVR4 library routines query the value of `_lib_version' at run
 161    to decide how they should behave.  Specifically, they decide (based
 162    upon the value of `_lib_version') if they will act in a strictly ANSI
 163    conforming manner or not.
 164 */
 165
 166 #undef  STARTFILE_SPEC
 167 #define STARTFILE_SPEC "%{!shared: \
 168                          %{!symbolic: \
 169                           %{pg:gcrt1.o%s}%{!pg:%{p:mcrt1.o%s}%{!p:crt1.o%s}}}}\
 170                         %{pg:gcrti.o%s}%{!pg:crti.o%s} \
 171                         %{ansi:values-Xc.o%s} \
 172                         %{!ansi: \
 173                          %{traditional:values-Xt.o%s} \
 174                          %{!traditional:values-Xa.o%s}} \
 175                         crtbegin.o%s"
 176
 177 /* Attach a special .ident directive to the end of the file to identify
 178    the version of GCC which compiled this code.  The format of the
 179    .ident string is patterned after the ones produced by native svr4
 180    C compilers.  */
 181
 182 #define IDENT_ASM_OP ".ident"
 183
 184 #define ASM_FILE_END(FILE)                                      \
 185 do {                                                            \
 186      fprintf ((FILE), "\t%s\t\"GCC: (GNU) %s\"\n",              \
 187               IDENT_ASM_OP, version_string);                    \
 188    } while (0)
 189
 190 /* Allow #sccs in preprocessor.  */
 191
 192 #define SCCS_DIRECTIVE
 193
 194 /* Output #ident as a .ident.  */
 195
 196 #define ASM_OUTPUT_IDENT(FILE, NAME) \
 197   fprintf (FILE, "\t%s\t\"%s\"\n", IDENT_ASM_OP, NAME);
 198
 199 /* Use periods rather than dollar signs in special g++ assembler names.  */
 200
 201 #define NO_DOLLAR_IN_LABEL
 202
 203 /* Writing `int' for a bitfield forces int alignment for the structure.  */
 204
 205 #define PCC_BITFIELD_TYPE_MATTERS 1
 206
 207 /* Implicit library calls should use memcpy, not bcopy, etc.  */
 208
 209 #define TARGET_MEM_FUNCTIONS
 210
 211 /* Handle #pragma weak and #pragma pack.  */
 212
 213 #define HANDLE_SYSV_PRAGMA
 214
 215 /* System V Release 4 uses DWARF debugging info.  */
 216
 217 #define DWARF_DEBUGGING_INFO
 218
 219 /* The numbers used to denote specific machine registers in the System V
 220    Release 4 DWARF debugging information are quite likely to be totally
 221    different from the numbers used in BSD stabs debugging information
 222    for the same kind of target machine.  Thus, we undefine the macro
 223    DBX_REGISTER_NUMBER here as an extra inducement to get people to
 224    provide proper machine-specific definitions of DBX_REGISTER_NUMBER
 225    (which is also used to provide DWARF registers numbers in dwarfout.c)
 226    in their tm.h files which include this file.  */
 227
 228 #undef DBX_REGISTER_NUMBER
 229
 230 /* gas on SVR4 supports the use of .stabs.  Permit -gstabs to be used
 231    in general, although it will only work when using gas.  */
 232
 233 #define DBX_DEBUGGING_INFO
 234
 235 /* Use DWARF debugging info by default.  */
 236
 237 #ifndef PREFERRED_DEBUGGING_TYPE
 238 #define PREFERRED_DEBUGGING_TYPE DWARF_DEBUG
 239 #endif
 240
 241 /* Make LBRAC and RBRAC addresses relative to the start of the
 242    function.  The native Solaris stabs debugging format works this
 243    way, gdb expects it, and it reduces the number of relocation
 244    entries.  */
 245
 246 #define DBX_BLOCKS_FUNCTION_RELATIVE 1
 247
 248 /* When using stabs, gcc2_compiled must be a stabs entry, not an
 249    ordinary symbol, or gdb won't see it.  The stabs entry must be
 250    before the N_SO in order for gdb to find it.  */
 251
 252 #define ASM_IDENTIFY_GCC(FILE)                                          \
 253 do                                                                      \
 254   {                                                                     \
 255     if (write_symbols != DBX_DEBUG)                                     \
 256       fputs ("gcc2_compiled.:\n", FILE);                                \
 257     else                                                                \
 258       fputs ("\t.stabs\t\"gcc2_compiled.\", 0x3c, 0, 0, 0\n", FILE);    \
 259   }                                                                     \
 260 while (0)
 261
 262 /* Like block addresses, stabs line numbers are relative to the
 263    current function.  */
 264
 265 #define ASM_OUTPUT_SOURCE_LINE(file, line)                              \
 266 do                                                                      \
 267   {                                                                     \
 268     static int sym_lineno = 1;                                          \
 269     fprintf (file, ".stabn 68,0,%d,.LM%d-",                             \
 270              line, sym_lineno);                                         \
 271     assemble_name (file,                                                \
 272                    XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0));\
 273     fprintf (file, "\n.LM%d:\n", sym_lineno);                           \
 274     sym_lineno += 1;                                                    \
 275   }                                                                     \
 276 while (0)
 277
 278 /* In order for relative line numbers to work, we must output the
 279    stabs entry for the function name first.  */
 280
 281 #define DBX_FUNCTION_FIRST
 282
 283 /* Generate a blank trailing N_SO to mark the end of the .o file, since
 284    we can't depend upon the linker to mark .o file boundaries with
 285    embedded stabs.  */
 286
 287 #define DBX_OUTPUT_MAIN_SOURCE_FILE_END(FILE, FILENAME)                 \
 288   fprintf (FILE,                                                        \
 289            "\t.text\n\t.stabs \"\",%d,0,0,.Letext\n.Letext:\n", N_SO)
 290
 291 /* Define the actual types of some ANSI-mandated types.  (These
 292    definitions should work for most SVR4 systems).  */
 293
 294 #undef SIZE_TYPE
 295 #define SIZE_TYPE "unsigned int"
 296
 297 #undef PTRDIFF_TYPE
 298 #define PTRDIFF_TYPE "int"
 299
 300 #undef WCHAR_TYPE
 301 #define WCHAR_TYPE "long int"
 302
 303 #undef WCHAR_TYPE_SIZE
 304 #define WCHAR_TYPE_SIZE BITS_PER_WORD
 305
 306 /* This causes trouble, because it requires the host machine
 307    to support ANSI C.  */
 308 /* #define MULTIBYTE_CHARS */
 309
 310 #undef ASM_BYTE_OP
 311 #define ASM_BYTE_OP     ".byte"
 312
 313 #undef SET_ASM_OP
 314 #define SET_ASM_OP      ".set"
 315
 316 /* This is how to begin an assembly language file.  Most svr4 assemblers want
 317    at least a .file directive to come first, and some want to see a .version
 318    directive come right after that.  Here we just establish a default
 319    which generates only the .file directive.  If you need a .version
 320    directive for any specific target, you should override this definition
 321    in the target-specific file which includes this one.  */
 322
 323 #undef ASM_FILE_START
 324 #define ASM_FILE_START(FILE)                                    \
 325   output_file_directive ((FILE), main_input_filename)
 326
 327 /* This is how to allocate empty space in some section.  The .zero
 328    pseudo-op is used for this on most svr4 assemblers.  */
 329
 330 #define SKIP_ASM_OP     ".zero"
 331
 332 #undef ASM_OUTPUT_SKIP
 333 #define ASM_OUTPUT_SKIP(FILE,SIZE) \
 334   fprintf (FILE, "\t%s\t%u\n", SKIP_ASM_OP, (SIZE))
 335
 336 /* The prefix to add to user-visible assembler symbols. */
 337
 338    For System V Release 4 the convention is *not* to prepend a leading
 339    underscore onto user-level symbol names.  */
 340
 341 #undef USER_LABEL_PREFIX
 342 #define USER_LABEL_PREFIX ""
 343
 344 /* This is how to output an internal numbered label where
 345    PREFIX is the class of label and NUM is the number within the class.
 346
 347    For most svr4 systems, the convention is that any symbol which begins
 348    with a period is not put into the linker symbol table by the assembler. */
 349
 350 #undef ASM_OUTPUT_INTERNAL_LABEL
 351 #define ASM_OUTPUT_INTERNAL_LABEL(FILE, PREFIX, NUM)                    \
 352 do {                                                                    \
 353   fprintf (FILE, ".%s%d:\n", PREFIX, NUM);                              \
 354 } while (0)
 355
 356 /* This is how to store into the string LABEL
 357    the symbol_ref name of an internal numbered label where
 358    PREFIX is the class of label and NUM is the number within the class.
 359    This is suitable for output with `assemble_name'.
 360
 361    For most svr4 systems, the convention is that any symbol which begins
 362    with a period is not put into the linker symbol table by the assembler. */
 363
 364 #undef ASM_GENERATE_INTERNAL_LABEL
 365 #define ASM_GENERATE_INTERNAL_LABEL(LABEL, PREFIX, NUM)                 \
 366 do {                                                                    \
 367   sprintf (LABEL, "*.%s%d", PREFIX, NUM);                               \
 368 } while (0)
 369
 370 /* Output the label which precedes a jumptable.  Note that for all svr4
 371    systems where we actually generate jumptables (which is to say every
 372    svr4 target except i386, where we use casesi instead) we put the jump-
 373    tables into the .rodata section and since other stuff could have been
 374    put into the .rodata section prior to any given jumptable, we have to
 375    make sure that the location counter for the .rodata section gets pro-
 376    perly re-aligned prior to the actual beginning of the jump table.  */
 377
 378 #define ALIGN_ASM_OP ".align"
 379
 380 #ifndef ASM_OUTPUT_BEFORE_CASE_LABEL
 381 #define ASM_OUTPUT_BEFORE_CASE_LABEL(FILE,PREFIX,NUM,TABLE) \
 382   ASM_OUTPUT_ALIGN ((FILE), 2);
 383 #endif
 384
 385 #undef ASM_OUTPUT_CASE_LABEL
 386 #define ASM_OUTPUT_CASE_LABEL(FILE,PREFIX,NUM,JUMPTABLE)                \
 387   do {                                                                  \
 388     ASM_OUTPUT_BEFORE_CASE_LABEL (FILE, PREFIX, NUM, JUMPTABLE)         \
 389     ASM_OUTPUT_INTERNAL_LABEL (FILE, PREFIX, NUM);                      \
 390   } while (0)
 391
 392 /* The standard SVR4 assembler seems to require that certain builtin
 393    library routines (e.g. .udiv) be explicitly declared as .globl
 394    in each assembly file where they are referenced.  */
 395
 396 #define ASM_OUTPUT_EXTERNAL_LIBCALL(FILE, FUN)                          \
 397   ASM_GLOBALIZE_LABEL (FILE, XSTR (FUN, 0))
 398
 399 /* This says how to output assembler code to declare an
 400    uninitialized external linkage data object.  Under SVR4,
 401    the linker seems to want the alignment of data objects
 402    to depend on their types.  We do exactly that here.  */
 403
 404 #define COMMON_ASM_OP   ".comm"
 405
 406 #undef ASM_OUTPUT_ALIGNED_COMMON
 407 #define ASM_OUTPUT_ALIGNED_COMMON(FILE, NAME, SIZE, ALIGN)              \
 408 do {                                                                    \
 409   fprintf ((FILE), "\t%s\t", COMMON_ASM_OP);                            \
 410   assemble_name ((FILE), (NAME));                                       \
 411   fprintf ((FILE), ",%u,%u\n", (SIZE), (ALIGN) / BITS_PER_UNIT);        \
 412 } while (0)
 413
 414 /* This says how to output assembler code to declare an
 415    uninitialized internal linkage data object.  Under SVR4,
 416    the linker seems to want the alignment of data objects
 417    to depend on their types.  We do exactly that here.  */
 418
 419 #define LOCAL_ASM_OP    ".local"
 420
 421 #undef ASM_OUTPUT_ALIGNED_LOCAL
 422 #define ASM_OUTPUT_ALIGNED_LOCAL(FILE, NAME, SIZE, ALIGN)               \
 423 do {                                                                    \
 424   fprintf ((FILE), "\t%s\t", LOCAL_ASM_OP);                             \
 425   assemble_name ((FILE), (NAME));                                       \
 426   fprintf ((FILE), "\n");                                               \
 427   ASM_OUTPUT_ALIGNED_COMMON (FILE, NAME, SIZE, ALIGN);                  \
 428 } while (0)
 429
 430 /* This is the pseudo-op used to generate a 32-bit word of data with a
 431    specific value in some section.  This is the same for all known svr4
 432    assemblers.  */
 433
 434 #define INT_ASM_OP              ".long"
 435
 436 /* This is the pseudo-op used to generate a contiguous sequence of byte
 437    values from a double-quoted string WITHOUT HAVING A TERMINATING NUL
 438    AUTOMATICALLY APPENDED.  This is the same for most svr4 assemblers.  */
 439
 440 #undef ASCII_DATA_ASM_OP
 441 #define ASCII_DATA_ASM_OP       ".ascii"
 442
 443 /* Support const sections and the ctors and dtors sections for g++.
 444    Note that there appears to be two different ways to support const
 445    sections at the moment.  You can either #define the symbol
 446    READONLY_DATA_SECTION (giving it some code which switches to the
 447    readonly data section) or else you can #define the symbols
 448    EXTRA_SECTIONS, EXTRA_SECTION_FUNCTIONS, SELECT_SECTION, and
 449    SELECT_RTX_SECTION.  We do both here just to be on the safe side.  */
 450
 451 #define USE_CONST_SECTION       1
 452
 453 #define CONST_SECTION_ASM_OP    ".section\t.rodata"
 454
 455 /* Define the pseudo-ops used to switch to the .ctors and .dtors sections.
 456
 457    Note that we want to give these sections the SHF_WRITE attribute
 458    because these sections will actually contain data (i.e. tables of
 459    addresses of functions in the current root executable or shared library
 460    file) and, in the case of a shared library, the relocatable addresses
 461    will have to be properly resolved/relocated (and then written into) by
 462    the dynamic linker when it actually attaches the given shared library
 463    to the executing process.  (Note that on SVR4, you may wish to use the
 464    `-z text' option to the ELF linker, when building a shared library, as
 465    an additional check that you are doing everything right.  But if you do
 466    use the `-z text' option when building a shared library, you will get
 467    errors unless the .ctors and .dtors sections are marked as writable
 468    via the SHF_WRITE attribute.)  */
 469
 470 #define CTORS_SECTION_ASM_OP    ".section\t.ctors,\"aw\""
 471 #define DTORS_SECTION_ASM_OP    ".section\t.dtors,\"aw\""
 472
 473 /* On svr4, we *do* have support for the .init and .fini sections, and we
 474    can put stuff in there to be executed before and after `main'.  We let
 475    crtstuff.c and other files know this by defining the following symbols.
 476    The definitions say how to change sections to the .init and .fini
 477    sections.  This is the same for all known svr4 assemblers.  */
 478
 479 #define INIT_SECTION_ASM_OP     ".section\t.init"
 480 #define FINI_SECTION_ASM_OP     ".section\t.fini"
 481
 482 /* A default list of other sections which we might be "in" at any given
 483    time.  For targets that use additional sections (e.g. .tdesc) you
 484    should override this definition in the target-specific file which
 485    includes this file.  */
 486
 487 #undef EXTRA_SECTIONS
 488 #define EXTRA_SECTIONS in_const, in_ctors, in_dtors
 489
 490 /* A default list of extra section function definitions.  For targets
 491    that use additional sections (e.g. .tdesc) you should override this
 492    definition in the target-specific file which includes this file.  */
 493
 494 #undef EXTRA_SECTION_FUNCTIONS
 495 #define EXTRA_SECTION_FUNCTIONS                                         \
 496   CONST_SECTION_FUNCTION                                                \
 497   CTORS_SECTION_FUNCTION                                                \
 498   DTORS_SECTION_FUNCTION
 499
 500 #define READONLY_DATA_SECTION() const_section ()
 501
 502 extern void text_section ();
 503
 504 #define CONST_SECTION_FUNCTION                                          \
 505 void                                                                    \
 506 const_section ()                                                        \
 507 {                                                                       \
 508   if (!USE_CONST_SECTION)                                               \
 509     text_section();                                                     \
 510   else if (in_section != in_const)                                      \
 511     {                                                                   \
 512       fprintf (asm_out_file, "%s\n", CONST_SECTION_ASM_OP);             \
 513       in_section = in_const;                                            \
 514     }                                                                   \
 515 }
 516
 517 #define CTORS_SECTION_FUNCTION                                          \
 518 void                                                                    \
 519 ctors_section ()                                                        \
 520 {                                                                       \
 521   if (in_section != in_ctors)                                           \
 522     {                                                                   \
 523       fprintf (asm_out_file, "%s\n", CTORS_SECTION_ASM_OP);             \
 524       in_section = in_ctors;                                            \
 525     }                                                                   \
 526 }
 527
 528 #define DTORS_SECTION_FUNCTION                                          \
 529 void                                                                    \
 530 dtors_section ()                                                        \
 531 {                                                                       \
 532   if (in_section != in_dtors)                                           \
 533     {                                                                   \
 534       fprintf (asm_out_file, "%s\n", DTORS_SECTION_ASM_OP);             \
 535       in_section = in_dtors;                                            \
 536     }                                                                   \
 537 }
 538
 539 /* Switch into a generic section.
 540    This is currently only used to support section attributes.
 541
 542    We make the section read-only and executable for a function decl,
 543    read-only for a const data decl, and writable for a non-const data decl. */
 544 #define ASM_OUTPUT_SECTION_NAME(FILE, DECL, NAME) \
 545   fprintf (FILE, ".section\t%s,\"%s\",@progbits\n", NAME, \
 546            (DECL) && TREE_CODE (DECL) == FUNCTION_DECL ? "ax" : \
 547            (DECL) && TREE_READONLY (DECL) ? "a" : "aw")
 548
 549
 550 /* A C statement (sans semicolon) to output an element in the table of
 551    global constructors.  */
 552 #define ASM_OUTPUT_CONSTRUCTOR(FILE,NAME)                               \
 553   do {                                                                  \
 554     ctors_section ();                                                   \
 555     fprintf (FILE, "\t%s\t ", INT_ASM_OP);                              \
 556     assemble_name (FILE, NAME);                                         \
 557     fprintf (FILE, "\n");                                               \
 558   } while (0)
 559
 560 /* A C statement (sans semicolon) to output an element in the table of
 561    global destructors.  */
 562 #define ASM_OUTPUT_DESTRUCTOR(FILE,NAME)                                \
 563   do {                                                                  \
 564     dtors_section ();                                                   \
 565     fprintf (FILE, "\t%s\t ", INT_ASM_OP);                              \
 566     assemble_name (FILE, NAME);                                         \
 567     fprintf (FILE, "\n");                                               \
 568   } while (0)
 569
 570 /* A C statement or statements to switch to the appropriate
 571    section for output of DECL.  DECL is either a `VAR_DECL' node
 572    or a constant of some sort.  RELOC indicates whether forming
 573    the initial value of DECL requires link-time relocations.  */
 574
 575 #define SELECT_SECTION(DECL,RELOC)                                      \
 576 {                                                                       \
 577   if (TREE_CODE (DECL) == STRING_CST)                                   \
 578     {                                                                   \
 579       if (! flag_writable_strings)                                      \
 580         const_section ();                                               \
 581       else                                                              \
 582         data_section ();                                                \
 583     }                                                                   \
 584   else if (TREE_CODE (DECL) == VAR_DECL)                                \
 585     {                                                                   \
 586       if ((flag_pic && RELOC)                                           \
 587           || !TREE_READONLY (DECL) || TREE_SIDE_EFFECTS (DECL)          \
 588           || !DECL_INITIAL (DECL)                                       \
 589           || (DECL_INITIAL (DECL) != error_mark_node                    \
 590               && !TREE_CONSTANT (DECL_INITIAL (DECL))))                 \
 591         data_section ();                                                \
 592       else                                                              \
 593         const_section ();                                               \
 594     }                                                                   \
 595   else                                                                  \
 596     const_section ();                                                   \
 597 }
 598
 599 /* A C statement or statements to switch to the appropriate
 600    section for output of RTX in mode MODE.  RTX is some kind
 601    of constant in RTL.  The argument MODE is redundant except
 602    in the case of a `const_int' rtx.  Currently, these always
 603    go into the const section.  */
 604
 605 #undef SELECT_RTX_SECTION
 606 #define SELECT_RTX_SECTION(MODE,RTX) const_section()
 607
 608 /* Define the strings used for the special svr4 .type and .size directives.
 609    These strings generally do not vary from one system running svr4 to
 610    another, but if a given system (e.g. m88k running svr) needs to use
 611    different pseudo-op names for these, they may be overridden in the
 612    file which includes this one.  */
 613
 614 #define TYPE_ASM_OP     ".type"
 615 #define SIZE_ASM_OP     ".size"
 616
 617 /* This is how we tell the assembler that a symbol is weak.  */
 618
 619 #define ASM_WEAKEN_LABEL(FILE,NAME) \
 620   do { fputs ("\t.weak\t", FILE); assemble_name (FILE, NAME); \
 621        fputc ('\n', FILE); } while (0)
 622
 623 /* The following macro defines the format used to output the second
 624    operand of the .type assembler directive.  Different svr4 assemblers
 625    expect various different forms for this operand.  The one given here
 626    is just a default.  You may need to override it in your machine-
 627    specific tm.h file (depending upon the particulars of your assembler).  */
 628
 629 #define TYPE_OPERAND_FMT        "@%s"
 630
 631 /* Write the extra assembler code needed to declare a function's result.
 632    Most svr4 assemblers don't require any special declaration of the
 633    result value, but there are exceptions.  */
 634
 635 #ifndef ASM_DECLARE_RESULT
 636 #define ASM_DECLARE_RESULT(FILE, RESULT)
 637 #endif
 638
 639 /* These macros generate the special .type and .size directives which
 640    are used to set the corresponding fields of the linker symbol table
 641    entries in an ELF object file under SVR4.  These macros also output
 642    the starting labels for the relevant functions/objects.  */
 643
 644 /* Write the extra assembler code needed to declare a function properly.
 645    Some svr4 assemblers need to also have something extra said about the
 646    function's return value.  We allow for that here.  */
 647
 648 #define ASM_DECLARE_FUNCTION_NAME(FILE, NAME, DECL)                     \
 649   do {                                                                  \
 650     fprintf (FILE, "\t%s\t ", TYPE_ASM_OP);                             \
 651     assemble_name (FILE, NAME);                                         \
 652     putc (',', FILE);                                                   \
 653     fprintf (FILE, TYPE_OPERAND_FMT, "function");                       \
 654     putc ('\n', FILE);                                                  \
 655     ASM_DECLARE_RESULT (FILE, DECL_RESULT (DECL));                      \
 656     ASM_OUTPUT_LABEL(FILE, NAME);                                       \
 657   } while (0)
 658
 659 /* Write the extra assembler code needed to declare an object properly.  */
 660
 661 #define ASM_DECLARE_OBJECT_NAME(FILE, NAME, DECL)                       \
 662   do {                                                                  \
 663     fprintf (FILE, "\t%s\t ", TYPE_ASM_OP);                             \
 664     assemble_name (FILE, NAME);                                         \
 665     putc (',', FILE);                                                   \
 666     fprintf (FILE, TYPE_OPERAND_FMT, "object");                         \
 667     putc ('\n', FILE);                                                  \
 668     size_directive_output = 0;                                          \
 669     if (!flag_inhibit_size_directive && DECL_SIZE (DECL))               \
 670       {                                                                 \
 671         size_directive_output = 1;                                      \
 672         fprintf (FILE, "\t%s\t ", SIZE_ASM_OP);                         \
 673         assemble_name (FILE, NAME);                                     \
 674         fprintf (FILE, ",%d\n",  int_size_in_bytes (TREE_TYPE (DECL))); \
 675       }                                                                 \
 676     ASM_OUTPUT_LABEL(FILE, NAME);                                       \
 677   } while (0)
 678
 679 /* Output the size directive for a decl in rest_of_decl_compilation
 680    in the case where we did not do so before the initializer.
 681    Once we find the error_mark_node, we know that the value of
 682    size_directive_output was set
 683    by ASM_DECLARE_OBJECT_NAME when it was run for the same decl.  */
 684
 685 #define ASM_FINISH_DECLARE_OBJECT(FILE, DECL, TOP_LEVEL, AT_END)         \
 686 do {                                                                     \
 687      char *name = XSTR (XEXP (DECL_RTL (DECL), 0), 0);                   \
 688      if (!flag_inhibit_size_directive && DECL_SIZE (DECL)                \
 689          && ! AT_END && TOP_LEVEL                                        \
 690          && DECL_INITIAL (DECL) == error_mark_node                       \
 691          && !size_directive_output)                                      \
 692        {                                                                 \
 693          size_directive_output = 1;                                      \
 694          fprintf (FILE, "\t%s\t ", SIZE_ASM_OP);                         \
 695          assemble_name (FILE, name);                                     \
 696          fprintf (FILE, ",%d\n",  int_size_in_bytes (TREE_TYPE (DECL))); \
 697        }                                                                 \
 698    } while (0)
 699
 700 /* This is how to declare the size of a function.  */
 701
 702 #define ASM_DECLARE_FUNCTION_SIZE(FILE, FNAME, DECL)                    \
 703   do {                                                                  \
 704     if (!flag_inhibit_size_directive)                                   \
 705       {                                                                 \
 706         char label[256];                                                \
 707         static int labelno;                                             \
 708         labelno++;                                                      \
 709         ASM_GENERATE_INTERNAL_LABEL (label, "Lfe", labelno);            \
 710         ASM_OUTPUT_INTERNAL_LABEL (FILE, "Lfe", labelno);               \
 711         fprintf (FILE, "\t%s\t ", SIZE_ASM_OP);                         \
 712         assemble_name (FILE, (FNAME));                                  \
 713         fprintf (FILE, ",");                                            \
 714         assemble_name (FILE, label);                                    \
 715         fprintf (FILE, "-");                                            \
 716         assemble_name (FILE, (FNAME));                                  \
 717         putc ('\n', FILE);                                              \
 718       }                                                                 \
 719   } while (0)
 720
 721 /* A table of bytes codes used by the ASM_OUTPUT_ASCII and
 722    ASM_OUTPUT_LIMITED_STRING macros.  Each byte in the table
 723    corresponds to a particular byte value [0..255].  For any
 724    given byte value, if the value in the corresponding table
 725    position is zero, the given character can be output directly.
 726    If the table value is 1, the byte must be output as a \ooo
 727    octal escape.  If the tables value is anything else, then the
 728    byte value should be output as a \ followed by the value
 729    in the table.  Note that we can use standard UN*X escape
 730    sequences for many control characters, but we don't use
 731    \a to represent BEL because some svr4 assemblers (e.g. on
 732    the i386) don't know about that.  Also, we don't use \v
 733    since some versions of gas, such as 2.2 did not accept it.  */
 734
 735 #define ESCAPES \
 736 "\1\1\1\1\1\1\1\1btn\1fr\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\
 737 \0\0\"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\
 738 \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\\\0\0\0\
 739 \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\1\
 740 \1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\
 741 \1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\
 742 \1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\
 743 \1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1"
 744
 745 /* Some svr4 assemblers have a limit on the number of characters which
 746    can appear in the operand of a .string directive.  If your assembler
 747    has such a limitation, you should define STRING_LIMIT to reflect that
 748    limit.  Note that at least some svr4 assemblers have a limit on the
 749    actual number of bytes in the double-quoted string, and that they
 750    count each character in an escape sequence as one byte.  Thus, an
 751    escape sequence like \377 would count as four bytes.
 752
 753    If your target assembler doesn't support the .string directive, you
 754    should define this to zero.
 755 */
 756
 757 #define STRING_LIMIT    ((unsigned) 256)
 758
 759 #define STRING_ASM_OP   ".string"
 760
 761 /* The routine used to output NUL terminated strings.  We use a special
 762    version of this for most svr4 targets because doing so makes the
 763    generated assembly code more compact (and thus faster to assemble)
 764    as well as more readable, especially for targets like the i386
 765    (where the only alternative is to output character sequences as
 766    comma separated lists of numbers).   */
 767
 768 #define ASM_OUTPUT_LIMITED_STRING(FILE, STR)                            \
 769   do                                                                    \
 770     {                                                                   \
 771       register unsigned char *_limited_str = (unsigned char *) (STR);   \
 772       register unsigned ch;                                             \
 773       fprintf ((FILE), "\t%s\t\"", STRING_ASM_OP);                      \
 774       for (; ch = *_limited_str; _limited_str++)                        \
 775         {                                                               \
 776           register int escape;                                          \
 777           switch (escape = ESCAPES[ch])                                 \
 778             {                                                           \
 779             case 0:                                                     \
 780               putc (ch, (FILE));                                        \
 781               break;                                                    \
 782             case 1:                                                     \
 783               fprintf ((FILE), "\\%03o", ch);                           \
 784               break;                                                    \
 785             default:                                                    \
 786               putc ('\\', (FILE));                                      \
 787               putc (escape, (FILE));                                    \
 788               break;                                                    \
 789             }                                                           \
 790         }                                                               \
 791       fprintf ((FILE), "\"\n");                                         \
 792     }                                                                   \
 793   while (0)
 794
 795 /* The routine used to output sequences of byte values.  We use a special
 796    version of this for most svr4 targets because doing so makes the
 797    generated assembly code more compact (and thus faster to assemble)
 798    as well as more readable.  Note that if we find subparts of the
 799    character sequence which end with NUL (and which are shorter than
 800    STRING_LIMIT) we output those using ASM_OUTPUT_LIMITED_STRING.  */
 801
 802 #undef ASM_OUTPUT_ASCII
 803 #define ASM_OUTPUT_ASCII(FILE, STR, LENGTH)                             \
 804   do                                                                    \
 805     {                                                                   \
 806       register unsigned char *_ascii_bytes = (unsigned char *) (STR);   \
 807       register unsigned char *limit = _ascii_bytes + (LENGTH);          \
 808       register unsigned bytes_in_chunk = 0;                             \
 809       for (; _ascii_bytes < limit; _ascii_bytes++)                      \
 810         {                                                               \
 811           register unsigned char *p;                                    \
 812           if (bytes_in_chunk >= 60)                                     \
 813             {                                                           \
 814               fprintf ((FILE), "\"\n");                                 \
 815               bytes_in_chunk = 0;                                       \
 816             }                                                           \
 817           for (p = _ascii_bytes; p < limit && *p != '\0'; p++)          \
 818             continue;                                                   \
 819           if (p < limit && (p - _ascii_bytes) <= STRING_LIMIT)          \
 820             {                                                           \
 821               if (bytes_in_chunk > 0)                                   \
 822                 {                                                       \
 823                   fprintf ((FILE), "\"\n");                             \
 824                   bytes_in_chunk = 0;                                   \
 825                 }                                                       \
 826               ASM_OUTPUT_LIMITED_STRING ((FILE), _ascii_bytes);         \
 827               _ascii_bytes = p;                                         \
 828             }                                                           \
 829           else                                                          \
 830             {                                                           \
 831               register int escape;                                      \
 832               register unsigned ch;                                     \
 833               if (bytes_in_chunk == 0)                                  \
 834                 fprintf ((FILE), "\t%s\t\"", ASCII_DATA_ASM_OP);        \
 835               switch (escape = ESCAPES[ch = *_ascii_bytes])             \
 836                 {                                                       \
 837                 case 0:                                                 \
 838                   putc (ch, (FILE));                                    \
 839                   bytes_in_chunk++;                                     \
 840                   break;                                                \
 841                 case 1:                                                 \
 842                   fprintf ((FILE), "\\%03o", ch);                       \
 843                   bytes_in_chunk += 4;                                  \
 844                   break;                                                \
 845                 default:                                                \
 846                   putc ('\\', (FILE));                                  \
 847                   putc (escape, (FILE));                                \
 848                   bytes_in_chunk += 2;                                  \
 849                   break;                                                \
 850                 }                                                       \
 851             }                                                           \
 852         }                                                               \
 853       if (bytes_in_chunk > 0)                                           \
 854         fprintf ((FILE), "\"\n");                                       \
 855     }                                                                   \
 856   while (0)
 857
 858 /* All SVR4 targets use the ELF object file format.  */
 859 #define OBJECT_FORMAT_ELF