gcc/config/svr4.h

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