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