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