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