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