contrib/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-98, 1999 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      if (!flag_no_ident)                                        \
 216         fprintf ((FILE), "\t%s\t\"GCC: (GNU) %s\"\n",           \
 217                  IDENT_ASM_OP, version_string);                 \
 218    } while (0)
 219
 220 /* Allow #sccs in preprocessor.  */
 221
 222 #define SCCS_DIRECTIVE
 223
 224 /* Output #ident as a .ident.  */
 225
 226 #define ASM_OUTPUT_IDENT(FILE, NAME) \
 227   fprintf (FILE, "\t%s\t\"%s\"\n", IDENT_ASM_OP, NAME);
 228
 229 /* Use periods rather than dollar signs in special g++ assembler names.  */
 230
 231 #define NO_DOLLAR_IN_LABEL
 232
 233 /* Writing `int' for a bitfield forces int alignment for the structure.  */
 234
 235 #define PCC_BITFIELD_TYPE_MATTERS 1
 236
 237 /* Implicit library calls should use memcpy, not bcopy, etc.  */
 238
 239 #define TARGET_MEM_FUNCTIONS
 240
 241 /* Handle #pragma weak and #pragma pack.  */
 242
 243 #define HANDLE_SYSV_PRAGMA
 244
 245 /* System V Release 4 uses DWARF debugging info.  */
 246
 247 #define DWARF_DEBUGGING_INFO
 248
 249 /* All ELF targets can support DWARF-2.  */
 250 #ifndef DWARF2_DEBUGGING_INFO
 251 #define DWARF2_DEBUGGING_INFO
 252 #endif
 253
 254 /* The numbers used to denote specific machine registers in the System V
 255    Release 4 DWARF debugging information are quite likely to be totally
 256    different from the numbers used in BSD stabs debugging information
 257    for the same kind of target machine.  Thus, we undefine the macro
 258    DBX_REGISTER_NUMBER here as an extra inducement to get people to
 259    provide proper machine-specific definitions of DBX_REGISTER_NUMBER
 260    (which is also used to provide DWARF registers numbers in dwarfout.c)
 261    in their tm.h files which include this file.  */
 262
 263 #undef DBX_REGISTER_NUMBER
 264
 265 /* Use DWARF debugging info by default.  */
 266
 267 #ifndef PREFERRED_DEBUGGING_TYPE
 268 #define PREFERRED_DEBUGGING_TYPE DWARF_DEBUG
 269 #endif
 270
 271 /* But allow STABS to be supoorted as well.  */
 272 #include "dbxelf.h"
 273
 274 /* Define the actual types of some ANSI-mandated types.  (These
 275    definitions should work for most SVR4 systems).  */
 276
 277 #undef SIZE_TYPE
 278 #define SIZE_TYPE "unsigned int"
 279
 280 #undef PTRDIFF_TYPE
 281 #define PTRDIFF_TYPE "int"
 282
 283 #undef WCHAR_TYPE
 284 #define WCHAR_TYPE "long int"
 285
 286 #undef WCHAR_TYPE_SIZE
 287 #define WCHAR_TYPE_SIZE BITS_PER_WORD
 288
 289 /* This causes trouble, because it requires the host machine
 290    to support ANSI C.  */
 291 /* #define MULTIBYTE_CHARS */
 292
 293 #undef ASM_BYTE_OP
 294 #define ASM_BYTE_OP     ".byte"
 295
 296 #undef SET_ASM_OP
 297 #define SET_ASM_OP      ".set"
 298
 299 /* This is how to begin an assembly language file.  Most svr4 assemblers want
 300    at least a .file directive to come first, and some want to see a .version
 301    directive come right after that.  Here we just establish a default
 302    which generates only the .file directive.  If you need a .version
 303    directive for any specific target, you should override this definition
 304    in the target-specific file which includes this one.  */
 305
 306 #undef ASM_FILE_START
 307 #define ASM_FILE_START(FILE)                                    \
 308   output_file_directive ((FILE), main_input_filename)
 309
 310 /* This is how to allocate empty space in some section.  The .zero
 311    pseudo-op is used for this on most svr4 assemblers.  */
 312
 313 #define SKIP_ASM_OP     ".zero"
 314
 315 #undef ASM_OUTPUT_SKIP
 316 #define ASM_OUTPUT_SKIP(FILE,SIZE) \
 317   fprintf (FILE, "\t%s\t%u\n", SKIP_ASM_OP, (SIZE))
 318
 319 /* The prefix to add to user-visible assembler symbols.
 320
 321    For System V Release 4 the convention is *not* to prepend a leading
 322    underscore onto user-level symbol names.  */
 323
 324 #undef USER_LABEL_PREFIX
 325 #define USER_LABEL_PREFIX ""
 326
 327 /* This is how to output an internal numbered label where
 328    PREFIX is the class of label and NUM is the number within the class.
 329
 330    For most svr4 systems, the convention is that any symbol which begins
 331    with a period is not put into the linker symbol table by the assembler.  */
 332
 333 #undef ASM_OUTPUT_INTERNAL_LABEL
 334 #define ASM_OUTPUT_INTERNAL_LABEL(FILE, PREFIX, NUM)                    \
 335 do {                                                                    \
 336   fprintf (FILE, ".%s%d:\n", PREFIX, NUM);                              \
 337 } while (0)
 338
 339 /* This is how to store into the string LABEL
 340    the symbol_ref name of an internal numbered label where
 341    PREFIX is the class of label and NUM is the number within the class.
 342    This is suitable for output with `assemble_name'.
 343
 344    For most svr4 systems, the convention is that any symbol which begins
 345    with a period is not put into the linker symbol table by the assembler.  */
 346
 347 #undef ASM_GENERATE_INTERNAL_LABEL
 348 #define ASM_GENERATE_INTERNAL_LABEL(LABEL, PREFIX, NUM)                 \
 349 do {                                                                    \
 350   sprintf (LABEL, "*.%s%d", PREFIX, (unsigned) (NUM));                  \
 351 } while (0)
 352
 353 /* Output the label which precedes a jumptable.  Note that for all svr4
 354    systems where we actually generate jumptables (which is to say every
 355    svr4 target except i386, where we use casesi instead) we put the jump-
 356    tables into the .rodata section and since other stuff could have been
 357    put into the .rodata section prior to any given jumptable, we have to
 358    make sure that the location counter for the .rodata section gets pro-
 359    perly re-aligned prior to the actual beginning of the jump table.  */
 360
 361 #define ALIGN_ASM_OP ".align"
 362
 363 #ifndef ASM_OUTPUT_BEFORE_CASE_LABEL
 364 #define ASM_OUTPUT_BEFORE_CASE_LABEL(FILE,PREFIX,NUM,TABLE) \
 365   ASM_OUTPUT_ALIGN ((FILE), 2);
 366 #endif
 367
 368 #undef ASM_OUTPUT_CASE_LABEL
 369 #define ASM_OUTPUT_CASE_LABEL(FILE,PREFIX,NUM,JUMPTABLE)                \
 370   do {                                                                  \
 371     ASM_OUTPUT_BEFORE_CASE_LABEL (FILE, PREFIX, NUM, JUMPTABLE)         \
 372     ASM_OUTPUT_INTERNAL_LABEL (FILE, PREFIX, NUM);                      \
 373   } while (0)
 374
 375 /* The standard SVR4 assembler seems to require that certain builtin
 376    library routines (e.g. .udiv) be explicitly declared as .globl
 377    in each assembly file where they are referenced.  */
 378
 379 #define ASM_OUTPUT_EXTERNAL_LIBCALL(FILE, FUN)                          \
 380   ASM_GLOBALIZE_LABEL (FILE, XSTR (FUN, 0))
 381
 382 /* This says how to output assembler code to declare an
 383    uninitialized external linkage data object.  Under SVR4,
 384    the linker seems to want the alignment of data objects
 385    to depend on their types.  We do exactly that here.  */
 386
 387 #define COMMON_ASM_OP   ".comm"
 388
 389 #undef ASM_OUTPUT_ALIGNED_COMMON
 390 #define ASM_OUTPUT_ALIGNED_COMMON(FILE, NAME, SIZE, ALIGN)              \
 391 do {                                                                    \
 392   fprintf ((FILE), "\t%s\t", COMMON_ASM_OP);                            \
 393   assemble_name ((FILE), (NAME));                                       \
 394   fprintf ((FILE), ",%u,%u\n", (SIZE), (ALIGN) / BITS_PER_UNIT);        \
 395 } while (0)
 396
 397 /* This says how to output assembler code to declare an
 398    uninitialized internal linkage data object.  Under SVR4,
 399    the linker seems to want the alignment of data objects
 400    to depend on their types.  We do exactly that here.  */
 401
 402 #define LOCAL_ASM_OP    ".local"
 403
 404 #undef ASM_OUTPUT_ALIGNED_LOCAL
 405 #define ASM_OUTPUT_ALIGNED_LOCAL(FILE, NAME, SIZE, ALIGN)               \
 406 do {                                                                    \
 407   fprintf ((FILE), "\t%s\t", LOCAL_ASM_OP);                             \
 408   assemble_name ((FILE), (NAME));                                       \
 409   fprintf ((FILE), "\n");                                               \
 410   ASM_OUTPUT_ALIGNED_COMMON (FILE, NAME, SIZE, ALIGN);                  \
 411 } while (0)
 412
 413 /* Biggest alignment supported by the object file format of this
 414    machine.  Use this macro to limit the alignment which can be
 415    specified using the `__attribute__ ((aligned (N)))' construct.  If
 416    not defined, the default value is `BIGGEST_ALIGNMENT'.  */
 417
 418 #define MAX_OFILE_ALIGNMENT (32768*8)
 419
 420 /* This is the pseudo-op used to generate a 32-bit word of data with a
 421    specific value in some section.  This is the same for all known svr4
 422    assemblers.  */
 423
 424 #define INT_ASM_OP              ".long"
 425
 426 /* This is the pseudo-op used to generate a contiguous sequence of byte
 427    values from a double-quoted string WITHOUT HAVING A TERMINATING NUL
 428    AUTOMATICALLY APPENDED.  This is the same for most svr4 assemblers.  */
 429
 430 #undef ASCII_DATA_ASM_OP
 431 #define ASCII_DATA_ASM_OP       ".ascii"
 432
 433 /* Support const sections and the ctors and dtors sections for g++.
 434    Note that there appears to be two different ways to support const
 435    sections at the moment.  You can either #define the symbol
 436    READONLY_DATA_SECTION (giving it some code which switches to the
 437    readonly data section) or else you can #define the symbols
 438    EXTRA_SECTIONS, EXTRA_SECTION_FUNCTIONS, SELECT_SECTION, and
 439    SELECT_RTX_SECTION.  We do both here just to be on the safe side.  */
 440
 441 #define USE_CONST_SECTION       1
 442
 443 #define CONST_SECTION_ASM_OP    ".section\t.rodata"
 444
 445 /* Define the pseudo-ops used to switch to the .ctors and .dtors sections.
 446
 447    Note that we want to give these sections the SHF_WRITE attribute
 448    because these sections will actually contain data (i.e. tables of
 449    addresses of functions in the current root executable or shared library
 450    file) and, in the case of a shared library, the relocatable addresses
 451    will have to be properly resolved/relocated (and then written into) by
 452    the dynamic linker when it actually attaches the given shared library
 453    to the executing process.  (Note that on SVR4, you may wish to use the
 454    `-z text' option to the ELF linker, when building a shared library, as
 455    an additional check that you are doing everything right.  But if you do
 456    use the `-z text' option when building a shared library, you will get
 457    errors unless the .ctors and .dtors sections are marked as writable
 458    via the SHF_WRITE attribute.)  */
 459
 460 #define CTORS_SECTION_ASM_OP    ".section\t.ctors,\"aw\""
 461 #define DTORS_SECTION_ASM_OP    ".section\t.dtors,\"aw\""
 462
 463 /* On svr4, we *do* have support for the .init and .fini sections, and we
 464    can put stuff in there to be executed before and after `main'.  We let
 465    crtstuff.c and other files know this by defining the following symbols.
 466    The definitions say how to change sections to the .init and .fini
 467    sections.  This is the same for all known svr4 assemblers.  */
 468
 469 #define INIT_SECTION_ASM_OP     ".section\t.init"
 470 #define FINI_SECTION_ASM_OP     ".section\t.fini"
 471
 472 /* A default list of other sections which we might be "in" at any given
 473    time.  For targets that use additional sections (e.g. .tdesc) you
 474    should override this definition in the target-specific file which
 475    includes this file.  */
 476
 477 #undef EXTRA_SECTIONS
 478 #define EXTRA_SECTIONS in_const, in_ctors, in_dtors
 479
 480 /* A default list of extra section function definitions.  For targets
 481    that use additional sections (e.g. .tdesc) you should override this
 482    definition in the target-specific file which includes this file.  */
 483
 484 #undef EXTRA_SECTION_FUNCTIONS
 485 #define EXTRA_SECTION_FUNCTIONS                                         \
 486   CONST_SECTION_FUNCTION                                                \
 487   CTORS_SECTION_FUNCTION                                                \
 488   DTORS_SECTION_FUNCTION
 489
 490 #define READONLY_DATA_SECTION() const_section ()
 491
 492 extern void text_section ();
 493
 494 #define CONST_SECTION_FUNCTION                                          \
 495 void                                                                    \
 496 const_section ()                                                        \
 497 {                                                                       \
 498   if (!USE_CONST_SECTION)                                               \
 499     text_section();                                                     \
 500   else if (in_section != in_const)                                      \
 501     {                                                                   \
 502       fprintf (asm_out_file, "%s\n", CONST_SECTION_ASM_OP);             \
 503       in_section = in_const;                                            \
 504     }                                                                   \
 505 }
 506
 507 #define CTORS_SECTION_FUNCTION                                          \
 508 void                                                                    \
 509 ctors_section ()                                                        \
 510 {                                                                       \
 511   if (in_section != in_ctors)                                           \
 512     {                                                                   \
 513       fprintf (asm_out_file, "%s\n", CTORS_SECTION_ASM_OP);             \
 514       in_section = in_ctors;                                            \
 515     }                                                                   \
 516 }
 517
 518 #define DTORS_SECTION_FUNCTION                                          \
 519 void                                                                    \
 520 dtors_section ()                                                        \
 521 {                                                                       \
 522   if (in_section != in_dtors)                                           \
 523     {                                                                   \
 524       fprintf (asm_out_file, "%s\n", DTORS_SECTION_ASM_OP);             \
 525       in_section = in_dtors;                                            \
 526     }                                                                   \
 527 }
 528
 529 /* Switch into a generic section.
 530
 531    We make the section read-only and executable for a function decl,
 532    read-only for a const data decl, and writable for a non-const data decl.
 533
 534    If the section has already been defined, we must not
 535    emit the attributes here. The SVR4 assembler does not
 536    recognize section redefinitions.
 537    If DECL is NULL, no attributes are emitted.  */
 538
 539 #define ASM_OUTPUT_SECTION_NAME(FILE, DECL, NAME, RELOC)                \
 540 do {                                                                    \
 541   static struct section_info                                            \
 542     {                                                                   \
 543       struct section_info *next;                                        \
 544       char *name;                                                       \
 545       enum sect_enum {SECT_RW, SECT_RO, SECT_EXEC} type;                \
 546     } *sections;                                                        \
 547   struct section_info *s;                                               \
 548   char *mode;                                                           \
 549   enum sect_enum type;                                                  \
 550                                                                         \
 551   for (s = sections; s; s = s->next)                                    \
 552     if (!strcmp (NAME, s->name))                                        \
 553       break;                                                            \
 554                                                                         \
 555   if (DECL && TREE_CODE (DECL) == FUNCTION_DECL)                        \
 556     type = SECT_EXEC, mode = "ax";                                      \
 557   else if (DECL && DECL_READONLY_SECTION (DECL, RELOC))                 \
 558     type = SECT_RO, mode = "a";                                         \
 559   else                                                                  \
 560     type = SECT_RW, mode = "aw";                                        \
 561                                                                         \
 562   if (s == 0)                                                           \
 563     {                                                                   \
 564       s = (struct section_info *) xmalloc (sizeof (struct section_info));  \
 565       s->name = xmalloc ((strlen (NAME) + 1) * sizeof (*NAME));         \
 566       strcpy (s->name, NAME);                                           \
 567       s->type = type;                                                   \
 568       s->next = sections;                                               \
 569       sections = s;                                                     \
 570       fprintf (FILE, ".section\t%s,\"%s\",@progbits\n", NAME, mode);    \
 571     }                                                                   \
 572   else                                                                  \
 573     {                                                                   \
 574       if (DECL && s->type != type)                                      \
 575         error_with_decl (DECL, "%s causes a section type conflict");    \
 576                                                                         \
 577       fprintf (FILE, ".section\t%s\n", NAME);                           \
 578     }                                                                   \
 579 } while (0)
 580
 581 #define MAKE_DECL_ONE_ONLY(DECL) (DECL_WEAK (DECL) = 1)
 582 #define UNIQUE_SECTION_P(DECL) (DECL_ONE_ONLY (DECL))
 583 #define UNIQUE_SECTION(DECL,RELOC)                              \
 584 do {                                                            \
 585   int len;                                                      \
 586   char *name, *string, *prefix;                                 \
 587                                                                 \
 588   name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (DECL));       \
 589                                                                 \
 590   if (! DECL_ONE_ONLY (DECL))                                   \
 591     {                                                           \
 592       prefix = ".";                                             \
 593       if (TREE_CODE (DECL) == FUNCTION_DECL)                    \
 594         prefix = ".text.";                                      \
 595       else if (DECL_READONLY_SECTION (DECL, RELOC))             \
 596         prefix = ".rodata.";                                    \
 597       else                                                      \
 598         prefix = ".data.";                                      \
 599     }                                                           \
 600   else if (TREE_CODE (DECL) == FUNCTION_DECL)                   \
 601     prefix = ".gnu.linkonce.t.";                                \
 602   else if (DECL_READONLY_SECTION (DECL, RELOC))                 \
 603     prefix = ".gnu.linkonce.r.";                                \
 604   else                                                          \
 605     prefix = ".gnu.linkonce.d.";                                \
 606                                                                 \
 607   len = strlen (name) + strlen (prefix);                        \
 608   string = alloca (len + 1);                                    \
 609   sprintf (string, "%s%s", prefix, name);                       \
 610                                                                 \
 611   DECL_SECTION_NAME (DECL) = build_string (len, string);        \
 612 } while (0)
 613 /* A C statement (sans semicolon) to output an element in the table of
 614    global constructors.  */
 615 #define ASM_OUTPUT_CONSTRUCTOR(FILE,NAME)                               \
 616   do {                                                                  \
 617     ctors_section ();                                                   \
 618     fprintf (FILE, "\t%s\t ", INT_ASM_OP);                              \
 619     assemble_name (FILE, NAME);                                         \
 620     fprintf (FILE, "\n");                                               \
 621   } while (0)
 622
 623 /* A C statement (sans semicolon) to output an element in the table of
 624    global destructors.  */
 625 #define ASM_OUTPUT_DESTRUCTOR(FILE,NAME)                                \
 626   do {                                                                  \
 627     dtors_section ();                                                   \
 628     fprintf (FILE, "\t%s\t ", INT_ASM_OP);                              \
 629     assemble_name (FILE, NAME);                                         \
 630     fprintf (FILE, "\n");                                               \
 631   } while (0)
 632
 633 /* A C statement or statements to switch to the appropriate
 634    section for output of DECL.  DECL is either a `VAR_DECL' node
 635    or a constant of some sort.  RELOC indicates whether forming
 636    the initial value of DECL requires link-time relocations.  */
 637
 638 #define SELECT_SECTION(DECL,RELOC)                                      \
 639 {                                                                       \
 640   if (flag_pic && RELOC)                                                \
 641     data_section ();                                                    \
 642   else if (TREE_CODE (DECL) == STRING_CST)                              \
 643     {                                                                   \
 644       if (! flag_writable_strings)                                      \
 645         const_section ();                                               \
 646       else                                                              \
 647         data_section ();                                                \
 648     }                                                                   \
 649   else if (TREE_CODE (DECL) == VAR_DECL)                                \
 650     {                                                                   \
 651       if (! DECL_READONLY_SECTION (DECL, RELOC))                        \
 652         data_section ();                                                \
 653       else                                                              \
 654         const_section ();                                               \
 655     }                                                                   \
 656   else                                                                  \
 657     const_section ();                                                   \
 658 }
 659
 660 /* A C statement or statements to switch to the appropriate
 661    section for output of RTX in mode MODE.  RTX is some kind
 662    of constant in RTL.  The argument MODE is redundant except
 663    in the case of a `const_int' rtx.  Currently, these always
 664    go into the const section.  */
 665
 666 #undef SELECT_RTX_SECTION
 667 #define SELECT_RTX_SECTION(MODE,RTX) const_section()
 668
 669 /* Define the strings used for the special svr4 .type and .size directives.
 670    These strings generally do not vary from one system running svr4 to
 671    another, but if a given system (e.g. m88k running svr) needs to use
 672    different pseudo-op names for these, they may be overridden in the
 673    file which includes this one.  */
 674
 675 #define TYPE_ASM_OP     ".type"
 676 #define SIZE_ASM_OP     ".size"
 677
 678 /* This is how we tell the assembler that a symbol is weak.  */
 679
 680 #define ASM_WEAKEN_LABEL(FILE,NAME) \
 681   do { fputs ("\t.weak\t", FILE); assemble_name (FILE, NAME); \
 682        fputc ('\n', FILE); } while (0)
 683
 684 /* The following macro defines the format used to output the second
 685    operand of the .type assembler directive.  Different svr4 assemblers
 686    expect various different forms for this operand.  The one given here
 687    is just a default.  You may need to override it in your machine-
 688    specific tm.h file (depending upon the particulars of your assembler).  */
 689
 690 #define TYPE_OPERAND_FMT        "@%s"
 691
 692 /* Write the extra assembler code needed to declare a function's result.
 693    Most svr4 assemblers don't require any special declaration of the
 694    result value, but there are exceptions.  */
 695
 696 #ifndef ASM_DECLARE_RESULT
 697 #define ASM_DECLARE_RESULT(FILE, RESULT)
 698 #endif
 699
 700 /* These macros generate the special .type and .size directives which
 701    are used to set the corresponding fields of the linker symbol table
 702    entries in an ELF object file under SVR4.  These macros also output
 703    the starting labels for the relevant functions/objects.  */
 704
 705 /* Write the extra assembler code needed to declare a function properly.
 706    Some svr4 assemblers need to also have something extra said about the
 707    function's return value.  We allow for that here.  */
 708
 709 #define ASM_DECLARE_FUNCTION_NAME(FILE, NAME, DECL)                     \
 710   do {                                                                  \
 711     fprintf (FILE, "\t%s\t ", TYPE_ASM_OP);                             \
 712     assemble_name (FILE, NAME);                                         \
 713     putc (',', FILE);                                                   \
 714     fprintf (FILE, TYPE_OPERAND_FMT, "function");                       \
 715     putc ('\n', FILE);                                                  \
 716     ASM_DECLARE_RESULT (FILE, DECL_RESULT (DECL));                      \
 717     ASM_OUTPUT_LABEL(FILE, NAME);                                       \
 718   } while (0)
 719
 720 /* Write the extra assembler code needed to declare an object properly.  */
 721
 722 #define ASM_DECLARE_OBJECT_NAME(FILE, NAME, DECL)                       \
 723   do {                                                                  \
 724     fprintf (FILE, "\t%s\t ", TYPE_ASM_OP);                             \
 725     assemble_name (FILE, NAME);                                         \
 726     putc (',', FILE);                                                   \
 727     fprintf (FILE, TYPE_OPERAND_FMT, "object");                         \
 728     putc ('\n', FILE);                                                  \
 729     size_directive_output = 0;                                          \
 730     if (!flag_inhibit_size_directive && DECL_SIZE (DECL))               \
 731       {                                                                 \
 732         size_directive_output = 1;                                      \
 733         fprintf (FILE, "\t%s\t ", SIZE_ASM_OP);                         \
 734         assemble_name (FILE, NAME);                                     \
 735         putc (',', FILE);                                               \
 736         fprintf (FILE, HOST_WIDE_INT_PRINT_DEC,                         \
 737                  int_size_in_bytes (TREE_TYPE (DECL)));                 \
 738         fputc ('\n', FILE);                                             \
 739       }                                                                 \
 740     ASM_OUTPUT_LABEL(FILE, NAME);                                       \
 741   } while (0)
 742
 743 /* Output the size directive for a decl in rest_of_decl_compilation
 744    in the case where we did not do so before the initializer.
 745    Once we find the error_mark_node, we know that the value of
 746    size_directive_output was set
 747    by ASM_DECLARE_OBJECT_NAME when it was run for the same decl.  */
 748
 749 #define ASM_FINISH_DECLARE_OBJECT(FILE, DECL, TOP_LEVEL, AT_END)         \
 750 do {                                                                     \
 751      char *name = XSTR (XEXP (DECL_RTL (DECL), 0), 0);                   \
 752      if (!flag_inhibit_size_directive && DECL_SIZE (DECL)                \
 753          && ! AT_END && TOP_LEVEL                                        \
 754          && DECL_INITIAL (DECL) == error_mark_node                       \
 755          && !size_directive_output)                                      \
 756        {                                                                 \
 757          size_directive_output = 1;                                      \
 758          fprintf (FILE, "\t%s\t ", SIZE_ASM_OP);                         \
 759          assemble_name (FILE, name);                                     \
 760          putc (',', FILE);                                               \
 761          fprintf (FILE, HOST_WIDE_INT_PRINT_DEC,                         \
 762                   int_size_in_bytes (TREE_TYPE (DECL)));                 \
 763         fputc ('\n', FILE);                                              \
 764        }                                                                 \
 765    } while (0)
 766
 767 /* This is how to declare the size of a function.  */
 768
 769 #define ASM_DECLARE_FUNCTION_SIZE(FILE, FNAME, DECL)                    \
 770   do {                                                                  \
 771     if (!flag_inhibit_size_directive)                                   \
 772       {                                                                 \
 773         char label[256];                                                \
 774         static int labelno;                                             \
 775         labelno++;                                                      \
 776         ASM_GENERATE_INTERNAL_LABEL (label, "Lfe", labelno);            \
 777         ASM_OUTPUT_INTERNAL_LABEL (FILE, "Lfe", labelno);               \
 778         fprintf (FILE, "\t%s\t ", SIZE_ASM_OP);                         \
 779         assemble_name (FILE, (FNAME));                                  \
 780         fprintf (FILE, ",");                                            \
 781         assemble_name (FILE, label);                                    \
 782         fprintf (FILE, "-");                                            \
 783         assemble_name (FILE, (FNAME));                                  \
 784         putc ('\n', FILE);                                              \
 785       }                                                                 \
 786   } while (0)
 787
 788 /* A table of bytes codes used by the ASM_OUTPUT_ASCII and
 789    ASM_OUTPUT_LIMITED_STRING macros.  Each byte in the table
 790    corresponds to a particular byte value [0..255].  For any
 791    given byte value, if the value in the corresponding table
 792    position is zero, the given character can be output directly.
 793    If the table value is 1, the byte must be output as a \ooo
 794    octal escape.  If the tables value is anything else, then the
 795    byte value should be output as a \ followed by the value
 796    in the table.  Note that we can use standard UN*X escape
 797    sequences for many control characters, but we don't use
 798    \a to represent BEL because some svr4 assemblers (e.g. on
 799    the i386) don't know about that.  Also, we don't use \v
 800    since some versions of gas, such as 2.2 did not accept it.  */
 801
 802 #define ESCAPES \
 803 "\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\
 804 \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\
 805 \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\
 806 \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\
 807 \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\
 808 \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\
 809 \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\
 810 \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"
 811
 812 /* Some svr4 assemblers have a limit on the number of characters which
 813    can appear in the operand of a .string directive.  If your assembler
 814    has such a limitation, you should define STRING_LIMIT to reflect that
 815    limit.  Note that at least some svr4 assemblers have a limit on the
 816    actual number of bytes in the double-quoted string, and that they
 817    count each character in an escape sequence as one byte.  Thus, an
 818    escape sequence like \377 would count as four bytes.
 819
 820    If your target assembler doesn't support the .string directive, you
 821    should define this to zero.
 822 */
 823
 824 #define STRING_LIMIT    ((unsigned) 256)
 825
 826 #define STRING_ASM_OP   ".string"
 827
 828 /* The routine used to output NUL terminated strings.  We use a special
 829    version of this for most svr4 targets because doing so makes the
 830    generated assembly code more compact (and thus faster to assemble)
 831    as well as more readable, especially for targets like the i386
 832    (where the only alternative is to output character sequences as
 833    comma separated lists of numbers).   */
 834
 835 #define ASM_OUTPUT_LIMITED_STRING(FILE, STR)                            \
 836   do                                                                    \
 837     {                                                                   \
 838       register unsigned char *_limited_str = (unsigned char *) (STR);   \
 839       register unsigned ch;                                             \
 840       fprintf ((FILE), "\t%s\t\"", STRING_ASM_OP);                      \
 841       for (; (ch = *_limited_str); _limited_str++)                      \
 842         {                                                               \
 843           register int escape;                                          \
 844           switch (escape = ESCAPES[ch])                                 \
 845             {                                                           \
 846             case 0:                                                     \
 847               putc (ch, (FILE));                                        \
 848               break;                                                    \
 849             case 1:                                                     \
 850               fprintf ((FILE), "\\%03o", ch);                           \
 851               break;                                                    \
 852             default:                                                    \
 853               putc ('\\', (FILE));                                      \
 854               putc (escape, (FILE));                                    \
 855               break;                                                    \
 856             }                                                           \
 857         }                                                               \
 858       fprintf ((FILE), "\"\n");                                         \
 859     }                                                                   \
 860   while (0)
 861
 862 /* The routine used to output sequences of byte values.  We use a special
 863    version of this for most svr4 targets because doing so makes the
 864    generated assembly code more compact (and thus faster to assemble)
 865    as well as more readable.  Note that if we find subparts of the
 866    character sequence which end with NUL (and which are shorter than
 867    STRING_LIMIT) we output those using ASM_OUTPUT_LIMITED_STRING.  */
 868
 869 #undef ASM_OUTPUT_ASCII
 870 #define ASM_OUTPUT_ASCII(FILE, STR, LENGTH)                             \
 871   do                                                                    \
 872     {                                                                   \
 873       register unsigned char *_ascii_bytes = (unsigned char *) (STR);   \
 874       register unsigned char *limit = _ascii_bytes + (LENGTH);          \
 875       register unsigned bytes_in_chunk = 0;                             \
 876       for (; _ascii_bytes < limit; _ascii_bytes++)                      \
 877         {                                                               \
 878           register unsigned char *p;                                    \
 879           if (bytes_in_chunk >= 60)                                     \
 880             {                                                           \
 881               fprintf ((FILE), "\"\n");                                 \
 882               bytes_in_chunk = 0;                                       \
 883             }                                                           \
 884           for (p = _ascii_bytes; p < limit && *p != '\0'; p++)          \
 885             continue;                                                   \
 886           if (p < limit && (p - _ascii_bytes) <= (long)STRING_LIMIT)    \
 887             {                                                           \
 888               if (bytes_in_chunk > 0)                                   \
 889                 {                                                       \
 890                   fprintf ((FILE), "\"\n");                             \
 891                   bytes_in_chunk = 0;                                   \
 892                 }                                                       \
 893               ASM_OUTPUT_LIMITED_STRING ((FILE), _ascii_bytes);         \
 894               _ascii_bytes = p;                                         \
 895             }                                                           \
 896           else                                                          \
 897             {                                                           \
 898               register int escape;                                      \
 899               register unsigned ch;                                     \
 900               if (bytes_in_chunk == 0)                                  \
 901                 fprintf ((FILE), "\t%s\t\"", ASCII_DATA_ASM_OP);        \
 902               switch (escape = ESCAPES[ch = *_ascii_bytes])             \
 903                 {                                                       \
 904                 case 0:                                                 \
 905                   putc (ch, (FILE));                                    \
 906                   bytes_in_chunk++;                                     \
 907                   break;                                                \
 908                 case 1:                                                 \
 909                   fprintf ((FILE), "\\%03o", ch);                       \
 910                   bytes_in_chunk += 4;                                  \
 911                   break;                                                \
 912                 default:                                                \
 913                   putc ('\\', (FILE));                                  \
 914                   putc (escape, (FILE));                                \
 915                   bytes_in_chunk += 2;                                  \
 916                   break;                                                \
 917                 }                                                       \
 918             }                                                           \
 919         }                                                               \
 920       if (bytes_in_chunk > 0)                                           \
 921         fprintf ((FILE), "\"\n");                                       \
 922     }                                                                   \
 923   while (0)
 924
 925 /* All SVR4 targets use the ELF object file format.  */
 926 #define OBJECT_FORMAT_ELF