gcc/config/elfos.h

   1 /* elfos.h  --  operating system specific defines to be used when
   2    targeting GCC for some generic ELF system
   3    Copyright (C) 1991, 1994, 1995, 1999, 2000 Free Software Foundation, Inc.
   4    Based on svr4.h contributed by Ron Guilmette (rfg@netcom.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 /* The prefix to add to user-visible assembler symbols.
  24
  25    For ELF systems the convention is *not* to prepend a leading
  26    underscore onto user-level symbol names.  */
  27
  28 #undef  USER_LABEL_PREFIX
  29 #define USER_LABEL_PREFIX ""
  30
  31 /* Biggest alignment supported by the object file format of this
  32    machine.  Use this macro to limit the alignment which can be
  33    specified using the `__attribute__ ((aligned (N)))' construct.  If
  34    not defined, the default value is `BIGGEST_ALIGNMENT'.  */
  35 #ifndef MAX_OFILE_ALIGNMENT
  36 #define MAX_OFILE_ALIGNMENT (32768 * 8)
  37 #endif
  38
  39 #undef  ENDFILE_SPEC
  40 #define ENDFILE_SPEC "crtend.o%s"
  41
  42 #undef  STARTFILE_SPEC
  43 #define STARTFILE_SPEC "%{!shared: \
  44                          %{!symbolic: \
  45                           %{pg:gcrt0.o%s}%{!pg:%{p:mcrt0.o%s}%{!p:crt0.o%s}}}}\
  46                         crtbegin.o%s"
  47
  48 /* Use periods rather than dollar signs in special g++ assembler names.  */
  49
  50 #define NO_DOLLAR_IN_LABEL
  51
  52 /* Writing `int' for a bitfield forces int alignment for the structure.  */
  53
  54 #define PCC_BITFIELD_TYPE_MATTERS 1
  55
  56 /* Implicit library calls should use memcpy, not bcopy, etc.  */
  57
  58 #define TARGET_MEM_FUNCTIONS
  59
  60 /* Handle #pragma weak and #pragma pack.  */
  61
  62 #define HANDLE_SYSV_PRAGMA
  63
  64 /* System V Release 4 uses DWARF debugging info.  */
  65
  66 #ifndef DWARF_DEBUGGING_INFO
  67 #define DWARF_DEBUGGING_INFO 1
  68 #endif
  69
  70 /* All ELF targets can support DWARF-2.  */
  71
  72 #ifndef DWARF2_DEBUGGING_INFO
  73 #define DWARF2_DEBUGGING_INFO 1
  74 #endif
  75
  76 /* Also allow them to support STABS debugging.  */
  77
  78 #include "dbxelf.h"
  79
  80 /* The GNU tools operate better with stabs.  Since we don't have
  81    any native tools to be compatible with, default to stabs.  */
  82
  83 #ifndef PREFERRED_DEBUGGING_TYPE
  84 #define PREFERRED_DEBUGGING_TYPE DBX_DEBUG
  85 #endif
  86
  87 /* All SVR4 targets use the ELF object file format.  */
  88 #define OBJECT_FORMAT_ELF
  89
  90
  91 /* Output #ident as a .ident.  */
  92
  93 #define ASM_OUTPUT_IDENT(FILE, NAME) \
  94   fprintf (FILE, "%s\"%s\"\n", IDENT_ASM_OP, NAME);
  95
  96 /* Attach a special .ident directive to the end of the file to identify
  97    the version of GCC which compiled this code.  The format of the
  98    .ident string is patterned after the ones produced by native svr4
  99    C compilers.  */
 100
 101 #define IDENT_ASM_OP "\t.ident\t"
 102
 103 #define ASM_FILE_END(FILE)                              \
 104   do                                                    \
 105     {                                                   \
 106       if (!flag_no_ident)                               \
 107         fprintf ((FILE), "%s\"GCC: (GNU) %s\"\n",       \
 108                  IDENT_ASM_OP, version_string);         \
 109     }                                                   \
 110   while (0)
 111
 112 #undef  ASM_BYTE_OP
 113 #define ASM_BYTE_OP     "\t.byte\t"
 114
 115 #undef  SET_ASM_OP
 116 #define SET_ASM_OP      "\t.set\t"
 117
 118 /* This is how to begin an assembly language file.  Most svr4 assemblers want
 119    at least a .file directive to come first, and some want to see a .version
 120    directive come right after that.  Here we just establish a default
 121    which generates only the .file directive.  If you need a .version
 122    directive for any specific target, you should override this definition
 123    in the target-specific file which includes this one.  */
 124
 125 #undef ASM_FILE_START
 126 #define ASM_FILE_START(FILE)                            \
 127   output_file_directive ((FILE), main_input_filename)
 128
 129 /* This is how to allocate empty space in some section.  The .zero
 130    pseudo-op is used for this on most svr4 assemblers.  */
 131
 132 #define SKIP_ASM_OP     "\t.zero\t"
 133
 134 #undef  ASM_OUTPUT_SKIP
 135 #define ASM_OUTPUT_SKIP(FILE, SIZE) \
 136   fprintf (FILE, "%s%u\n", SKIP_ASM_OP, (SIZE))
 137
 138 /* This is how to output an internal numbered label where
 139    PREFIX is the class of label and NUM is the number within the class.
 140
 141    For most svr4 systems, the convention is that any symbol which begins
 142    with a period is not put into the linker symbol table by the assembler.  */
 143
 144 #undef  ASM_OUTPUT_INTERNAL_LABEL
 145 #define ASM_OUTPUT_INTERNAL_LABEL(FILE, PREFIX, NUM)    \
 146   do                                                    \
 147     {                                                   \
 148       fprintf (FILE, ".%s%d:\n", PREFIX, NUM);          \
 149     }                                                   \
 150   while (0)
 151
 152 /* This is how to store into the string LABEL
 153    the symbol_ref name of an internal numbered label where
 154    PREFIX is the class of label and NUM is the number within the class.
 155    This is suitable for output with `assemble_name'.
 156
 157    For most svr4 systems, the convention is that any symbol which begins
 158    with a period is not put into the linker symbol table by the assembler.  */
 159
 160 #undef  ASM_GENERATE_INTERNAL_LABEL
 161 #define ASM_GENERATE_INTERNAL_LABEL(LABEL, PREFIX, NUM)         \
 162   do                                                            \
 163     {                                                           \
 164       sprintf (LABEL, "*.%s%u", PREFIX, (unsigned) (NUM));      \
 165     }                                                           \
 166   while (0)
 167
 168 /* Output the label which precedes a jumptable.  Note that for all svr4
 169    systems where we actually generate jumptables (which is to say every
 170    svr4 target except i386, where we use casesi instead) we put the jump-
 171    tables into the .rodata section and since other stuff could have been
 172    put into the .rodata section prior to any given jumptable, we have to
 173    make sure that the location counter for the .rodata section gets pro-
 174    perly re-aligned prior to the actual beginning of the jump table.  */
 175
 176 #define ALIGN_ASM_OP "\t.align\t"
 177
 178 #ifndef ASM_OUTPUT_BEFORE_CASE_LABEL
 179 #define ASM_OUTPUT_BEFORE_CASE_LABEL(FILE, PREFIX, NUM, TABLE) \
 180   ASM_OUTPUT_ALIGN ((FILE), 2);
 181 #endif
 182
 183 #undef  ASM_OUTPUT_CASE_LABEL
 184 #define ASM_OUTPUT_CASE_LABEL(FILE, PREFIX, NUM, JUMPTABLE)             \
 185   do                                                                    \
 186     {                                                                   \
 187       ASM_OUTPUT_BEFORE_CASE_LABEL (FILE, PREFIX, NUM, JUMPTABLE)       \
 188         ASM_OUTPUT_INTERNAL_LABEL (FILE, PREFIX, NUM);                  \
 189     }                                                                   \
 190   while (0)
 191
 192 /* The standard SVR4 assembler seems to require that certain builtin
 193    library routines (e.g. .udiv) be explicitly declared as .globl
 194    in each assembly file where they are referenced.  */
 195
 196 #define ASM_OUTPUT_EXTERNAL_LIBCALL(FILE, FUN)  \
 197   ASM_GLOBALIZE_LABEL (FILE, XSTR (FUN, 0))
 198
 199 /* This says how to output assembler code to declare an
 200    uninitialized external linkage data object.  Under SVR4,
 201    the linker seems to want the alignment of data objects
 202    to depend on their types.  We do exactly that here.  */
 203
 204 #define COMMON_ASM_OP   "\t.comm\t"
 205
 206 #undef  ASM_OUTPUT_ALIGNED_COMMON
 207 #define ASM_OUTPUT_ALIGNED_COMMON(FILE, NAME, SIZE, ALIGN)              \
 208   do                                                                    \
 209     {                                                                   \
 210       fprintf ((FILE), "%s", COMMON_ASM_OP);                            \
 211       assemble_name ((FILE), (NAME));                                   \
 212       fprintf ((FILE), ",%u,%u\n", (SIZE), (ALIGN) / BITS_PER_UNIT);    \
 213     }                                                                   \
 214   while (0)
 215
 216 /* This says how to output assembler code to declare an
 217    uninitialized internal linkage data object.  Under SVR4,
 218    the linker seems to want the alignment of data objects
 219    to depend on their types.  We do exactly that here.  */
 220
 221 #define LOCAL_ASM_OP    "\t.local\t"
 222
 223 #undef  ASM_OUTPUT_ALIGNED_LOCAL
 224 #define ASM_OUTPUT_ALIGNED_LOCAL(FILE, NAME, SIZE, ALIGN)       \
 225   do                                                            \
 226     {                                                           \
 227       fprintf ((FILE), "%s", LOCAL_ASM_OP);                     \
 228       assemble_name ((FILE), (NAME));                           \
 229       fprintf ((FILE), "\n");                                   \
 230       ASM_OUTPUT_ALIGNED_COMMON (FILE, NAME, SIZE, ALIGN);      \
 231     }                                                           \
 232   while (0)
 233
 234 /* This is the pseudo-op used to generate a 32-bit word of data with a
 235    specific value in some section.  This is the same for all known svr4
 236    assemblers.  */
 237
 238 #define INT_ASM_OP              "\t.long\t"
 239
 240 /* This is the pseudo-op used to generate a contiguous sequence of byte
 241    values from a double-quoted string WITHOUT HAVING A TERMINATING NUL
 242    AUTOMATICALLY APPENDED.  This is the same for most svr4 assemblers.  */
 243
 244 #undef  ASCII_DATA_ASM_OP
 245 #define ASCII_DATA_ASM_OP       "\t.ascii\t"
 246
 247 /* Support const sections and the ctors and dtors sections for g++.
 248    Note that there appears to be two different ways to support const
 249    sections at the moment.  You can either #define the symbol
 250    READONLY_DATA_SECTION (giving it some code which switches to the
 251    readonly data section) or else you can #define the symbols
 252    EXTRA_SECTIONS, EXTRA_SECTION_FUNCTIONS, SELECT_SECTION, and
 253    SELECT_RTX_SECTION.  We do both here just to be on the safe side.  */
 254
 255 #define USE_CONST_SECTION       1
 256
 257 #define CONST_SECTION_ASM_OP    "\t.section\t.rodata"
 258
 259 /* Define the pseudo-ops used to switch to the .ctors and .dtors sections.
 260
 261    Note that we want to give these sections the SHF_WRITE attribute
 262    because these sections will actually contain data (i.e. tables of
 263    addresses of functions in the current root executable or shared library
 264    file) and, in the case of a shared library, the relocatable addresses
 265    will have to be properly resolved/relocated (and then written into) by
 266    the dynamic linker when it actually attaches the given shared library
 267    to the executing process.  (Note that on SVR4, you may wish to use the
 268    `-z text' option to the ELF linker, when building a shared library, as
 269    an additional check that you are doing everything right.  But if you do
 270    use the `-z text' option when building a shared library, you will get
 271    errors unless the .ctors and .dtors sections are marked as writable
 272    via the SHF_WRITE attribute.)  */
 273
 274 #define CTORS_SECTION_ASM_OP    "\t.section\t.ctors,\"aw\""
 275 #define DTORS_SECTION_ASM_OP    "\t.section\t.dtors,\"aw\""
 276
 277 /* On svr4, we *do* have support for the .init and .fini sections, and we
 278    can put stuff in there to be executed before and after `main'.  We let
 279    crtstuff.c and other files know this by defining the following symbols.
 280    The definitions say how to change sections to the .init and .fini
 281    sections.  This is the same for all known svr4 assemblers.  */
 282
 283 #define INIT_SECTION_ASM_OP     "\t.section\t.init"
 284 #define FINI_SECTION_ASM_OP     "\t.section\t.fini"
 285
 286 /* A default list of other sections which we might be "in" at any given
 287    time.  For targets that use additional sections (e.g. .tdesc) you
 288    should override this definition in the target-specific file which
 289    includes this file.  */
 290
 291 #undef  EXTRA_SECTIONS
 292 #define EXTRA_SECTIONS in_const, in_ctors, in_dtors
 293
 294 /* A default list of extra section function definitions.  For targets
 295    that use additional sections (e.g. .tdesc) you should override this
 296    definition in the target-specific file which includes this file.  */
 297
 298 #undef  EXTRA_SECTION_FUNCTIONS
 299 #define EXTRA_SECTION_FUNCTIONS         \
 300   CONST_SECTION_FUNCTION                \
 301   CTORS_SECTION_FUNCTION                \
 302   DTORS_SECTION_FUNCTION
 303
 304 #define READONLY_DATA_SECTION() const_section ()
 305
 306 #define CONST_SECTION_FUNCTION                                  \
 307 void                                                            \
 308 const_section ()                                                \
 309 {                                                               \
 310   if (!USE_CONST_SECTION)                                       \
 311     text_section ();                                            \
 312   else if (in_section != in_const)                              \
 313     {                                                           \
 314       fprintf (asm_out_file, "%s\n", CONST_SECTION_ASM_OP);     \
 315       in_section = in_const;                                    \
 316     }                                                           \
 317 }
 318
 319 #define CTORS_SECTION_FUNCTION                                  \
 320 void                                                            \
 321 ctors_section ()                                                \
 322 {                                                               \
 323   if (in_section != in_ctors)                                   \
 324     {                                                           \
 325       fprintf (asm_out_file, "%s\n", CTORS_SECTION_ASM_OP);     \
 326       in_section = in_ctors;                                    \
 327     }                                                           \
 328 }
 329
 330 #define DTORS_SECTION_FUNCTION                                  \
 331 void                                                            \
 332 dtors_section ()                                                \
 333 {                                                               \
 334   if (in_section != in_dtors)                                   \
 335     {                                                           \
 336       fprintf (asm_out_file, "%s\n", DTORS_SECTION_ASM_OP);     \
 337       in_section = in_dtors;                                    \
 338     }                                                           \
 339 }
 340
 341 #define MAKE_DECL_ONE_ONLY(DECL) (DECL_WEAK (DECL) = 1)
 342
 343 #define UNIQUE_SECTION_P(DECL)   (DECL_ONE_ONLY (DECL))
 344
 345 #define UNIQUE_SECTION(DECL, RELOC)                             \
 346   do                                                            \
 347     {                                                           \
 348       int len;                                                  \
 349       int sec;                                                  \
 350       const char *name;                                         \
 351       char *string;                                             \
 352       const char *prefix;                                       \
 353       static const char *prefixes[/*4*/3][2] =                  \
 354       {                                                         \
 355         { ".text.",   ".gnu.linkonce.t." },                     \
 356         { ".rodata.", ".gnu.linkonce.r." },                     \
 357         { ".data.",   ".gnu.linkonce.d." }                      \
 358         /* Do not generate unique sections for uninitialised    \
 359            data since we do not have support for this in the    \
 360            linker scripts yet...                                \
 361         ,{ ".bss.",    ".gnu.linkonce.b." }  */                 \
 362       };                                                        \
 363                                                                 \
 364       if (TREE_CODE (DECL) == FUNCTION_DECL)                    \
 365         sec = 0;                                                \
 366   /*  else if (DECL_INITIAL (DECL) == 0                         \
 367                || DECL_INITIAL (DECL) == error_mark_node)       \
 368         sec =  3; */                                            \
 369       else if (DECL_READONLY_SECTION (DECL, RELOC))             \
 370         sec = 1;                                                \
 371       else                                                      \
 372         sec = 2;                                                \
 373                                                                 \
 374       name   = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (DECL)); \
 375       /* Strip off any encoding in name.  */                    \
 376       STRIP_NAME_ENCODING (name, name);                         \
 377       prefix = prefixes[sec][DECL_ONE_ONLY(DECL)];              \
 378       len    = strlen (name) + strlen (prefix);                 \
 379       string = alloca (len + 1);                                \
 380                                                                 \
 381       sprintf (string, "%s%s", prefix, name);                   \
 382                                                                 \
 383       DECL_SECTION_NAME (DECL) = build_string (len, string);    \
 384     }                                                           \
 385   while (0)
 386
 387 /* A C statement (sans semicolon) to output an
 388    element in the table of global constructors.  */
 389 #define ASM_OUTPUT_CONSTRUCTOR(FILE, NAME)                      \
 390   do                                                            \
 391     {                                                           \
 392       ctors_section ();                                         \
 393       fprintf (FILE, "%s", INT_ASM_OP);                         \
 394       assemble_name (FILE, NAME);                               \
 395       fprintf (FILE, "\n");                                     \
 396     }                                                           \
 397   while (0)
 398
 399 /* A C statement (sans semicolon) to output an
 400    element in the table of global destructors.  */
 401 #define ASM_OUTPUT_DESTRUCTOR(FILE,NAME)                        \
 402   do                                                            \
 403     {                                                           \
 404       dtors_section ();                                         \
 405       fprintf (FILE, "%s", INT_ASM_OP);                         \
 406       assemble_name (FILE, NAME);                               \
 407       fprintf (FILE, "\n");                                     \
 408     }                                                           \
 409   while (0)
 410
 411 /* Switch into a generic section.
 412
 413    We make the section read-only and executable for a function decl,
 414    read-only for a const data decl, and writable for a non-const data decl.
 415
 416    If the section has already been defined, we must not
 417    emit the attributes here. The SVR4 assembler does not
 418    recognize section redefinitions.
 419    If DECL is NULL, no attributes are emitted.  */
 420
 421 #define ASM_OUTPUT_SECTION_NAME(FILE, DECL, NAME, RELOC)                \
 422   do                                                                    \
 423     {                                                                   \
 424       static struct section_info                                        \
 425       {                                                                 \
 426         struct section_info *next;                                      \
 427         char *name;                                                     \
 428         enum sect_enum {SECT_RW, SECT_RO, SECT_EXEC} type;              \
 429       } *sections;                                                      \
 430       struct section_info *s;                                           \
 431       const char *mode;                                                 \
 432       enum sect_enum type;                                              \
 433                                                                         \
 434       for (s = sections; s; s = s->next)                                \
 435         if (!strcmp (NAME, s->name))                                    \
 436           break;                                                        \
 437                                                                         \
 438       if (DECL && TREE_CODE (DECL) == FUNCTION_DECL)                    \
 439         type = SECT_EXEC, mode = "ax";                                  \
 440       else if (DECL && DECL_READONLY_SECTION (DECL, RELOC))             \
 441         type = SECT_RO, mode = "a";                                     \
 442       else                                                              \
 443         type = SECT_RW, mode = "aw";                                    \
 444                                                                         \
 445       if (s == 0)                                                       \
 446         {                                                               \
 447           s = (struct section_info *) xmalloc (sizeof (* s));           \
 448           s->name = xmalloc ((strlen (NAME) + 1) * sizeof (* NAME));    \
 449           strcpy (s->name, NAME);                                       \
 450           s->type = type;                                               \
 451           s->next = sections;                                           \
 452           sections = s;                                                 \
 453           fprintf (FILE, "\t.section\t%s,\"%s\",@progbits\n",           \
 454                    NAME, mode);                                         \
 455         }                                                               \
 456       else                                                              \
 457         {                                                               \
 458           if (DECL && s->type != type)                                  \
 459             error_with_decl (DECL, "%s causes a section type conflict");\
 460                                                                         \
 461           fprintf (FILE, "\t.section\t%s\n", NAME);                     \
 462         }                                                               \
 463     }                                                                   \
 464   while (0)
 465
 466 /* A C statement or statements to switch to the appropriate
 467    section for output of RTX in mode MODE.  RTX is some kind
 468    of constant in RTL.  The argument MODE is redundant except
 469    in the case of a `const_int' rtx.  Currently, these always
 470    go into the const section.  */
 471
 472 #undef  SELECT_RTX_SECTION
 473 #define SELECT_RTX_SECTION(MODE, RTX) const_section ()
 474
 475 /* A C statement or statements to switch to the appropriate
 476    section for output of DECL.  DECL is either a `VAR_DECL' node
 477    or a constant of some sort.  RELOC indicates whether forming
 478    the initial value of DECL requires link-time relocations.  */
 479
 480 #define SELECT_SECTION(DECL, RELOC)                             \
 481 {                                                               \
 482   if (TREE_CODE (DECL) == STRING_CST)                           \
 483     {                                                           \
 484       if (! flag_writable_strings)                              \
 485         const_section ();                                       \
 486       else                                                      \
 487         data_section ();                                        \
 488     }                                                           \
 489   else if (TREE_CODE (DECL) == VAR_DECL)                        \
 490     {                                                           \
 491       if ((flag_pic && RELOC)                                   \
 492           || !TREE_READONLY (DECL) || TREE_SIDE_EFFECTS (DECL)  \
 493           || !DECL_INITIAL (DECL)                               \
 494           || (DECL_INITIAL (DECL) != error_mark_node            \
 495               && !TREE_CONSTANT (DECL_INITIAL (DECL))))         \
 496         data_section ();                                        \
 497       else                                                      \
 498         const_section ();                                       \
 499     }                                                           \
 500   else if (TREE_CODE (DECL) == CONSTRUCTOR)                     \
 501     {                                                           \
 502       if ((flag_pic && RELOC)                                   \
 503           || !TREE_READONLY (DECL) || TREE_SIDE_EFFECTS (DECL)  \
 504           || ! TREE_CONSTANT (DECL))                            \
 505         data_section ();                                        \
 506       else                                                      \
 507         const_section ();                                       \
 508     }                                                           \
 509   else                                                          \
 510     const_section ();                                           \
 511 }
 512
 513 /* Define the strings used for the special svr4 .type and .size directives.
 514    These strings generally do not vary from one system running svr4 to
 515    another, but if a given system (e.g. m88k running svr) needs to use
 516    different pseudo-op names for these, they may be overridden in the
 517    file which includes this one.  */
 518
 519 #define TYPE_ASM_OP     "\t.type\t"
 520 #define SIZE_ASM_OP     "\t.size\t"
 521
 522 /* This is how we tell the assembler that a symbol is weak.  */
 523
 524 #define ASM_WEAKEN_LABEL(FILE, NAME)    \
 525   do                                    \
 526     {                                   \
 527       fputs ("\t.weak\t", (FILE));      \
 528       assemble_name ((FILE), (NAME));   \
 529       fputc ('\n', (FILE));             \
 530     }                                   \
 531   while (0)
 532
 533 /* The following macro defines the format used to output the second
 534    operand of the .type assembler directive.  Different svr4 assemblers
 535    expect various different forms for this operand.  The one given here
 536    is just a default.  You may need to override it in your machine-
 537    specific tm.h file (depending upon the particulars of your assembler).  */
 538
 539 #define TYPE_OPERAND_FMT        "@%s"
 540
 541 /* Write the extra assembler code needed to declare a function's result.
 542    Most svr4 assemblers don't require any special declaration of the
 543    result value, but there are exceptions.  */
 544
 545 #ifndef ASM_DECLARE_RESULT
 546 #define ASM_DECLARE_RESULT(FILE, RESULT)
 547 #endif
 548
 549 /* These macros generate the special .type and .size directives which
 550    are used to set the corresponding fields of the linker symbol table
 551    entries in an ELF object file under SVR4.  These macros also output
 552    the starting labels for the relevant functions/objects.  */
 553
 554 /* Write the extra assembler code needed to declare a function properly.
 555    Some svr4 assemblers need to also have something extra said about the
 556    function's return value.  We allow for that here.  */
 557
 558 #ifndef ASM_DECLARE_FUNCTION_NAME
 559 #define ASM_DECLARE_FUNCTION_NAME(FILE, NAME, DECL)     \
 560   do                                                    \
 561     {                                                   \
 562       fprintf (FILE, "%s", TYPE_ASM_OP);                \
 563       assemble_name (FILE, NAME);                       \
 564       putc (',', FILE);                                 \
 565       fprintf (FILE, TYPE_OPERAND_FMT, "function");     \
 566       putc ('\n', FILE);                                \
 567                                                         \
 568       ASM_DECLARE_RESULT (FILE, DECL_RESULT (DECL));    \
 569       ASM_OUTPUT_LABEL(FILE, NAME);                     \
 570     }                                                   \
 571   while (0)
 572 #endif
 573
 574 /* Write the extra assembler code needed to declare an object properly.  */
 575
 576 #define ASM_DECLARE_OBJECT_NAME(FILE, NAME, DECL)               \
 577   do                                                            \
 578     {                                                           \
 579       fprintf (FILE, "%s", TYPE_ASM_OP);                        \
 580       assemble_name (FILE, NAME);                               \
 581       putc (',', FILE);                                         \
 582       fprintf (FILE, TYPE_OPERAND_FMT, "object");               \
 583       putc ('\n', FILE);                                        \
 584                                                                 \
 585       size_directive_output = 0;                                \
 586                                                                 \
 587       if (!flag_inhibit_size_directive                          \
 588           && (DECL) && DECL_SIZE (DECL))                        \
 589         {                                                       \
 590           size_directive_output = 1;                            \
 591           fprintf (FILE, "%s", SIZE_ASM_OP);                    \
 592           assemble_name (FILE, NAME);                           \
 593           putc (',', FILE);                                     \
 594           fprintf (FILE, HOST_WIDE_INT_PRINT_DEC,               \
 595                    int_size_in_bytes (TREE_TYPE (DECL)));       \
 596           fputc ('\n', FILE);                                   \
 597         }                                                       \
 598                                                                 \
 599       ASM_OUTPUT_LABEL (FILE, NAME);                            \
 600     }                                                           \
 601   while (0)
 602
 603 /* Output the size directive for a decl in rest_of_decl_compilation
 604    in the case where we did not do so before the initializer.
 605    Once we find the error_mark_node, we know that the value of
 606    size_directive_output was set
 607    by ASM_DECLARE_OBJECT_NAME when it was run for the same decl.  */
 608
 609 #define ASM_FINISH_DECLARE_OBJECT(FILE, DECL, TOP_LEVEL, AT_END)\
 610   do                                                            \
 611     {                                                           \
 612       const char *name = XSTR (XEXP (DECL_RTL (DECL), 0), 0);   \
 613                                                                 \
 614       if (!flag_inhibit_size_directive                          \
 615           && DECL_SIZE (DECL)                                   \
 616           && ! AT_END && TOP_LEVEL                              \
 617           && DECL_INITIAL (DECL) == error_mark_node             \
 618           && !size_directive_output)                            \
 619         {                                                       \
 620           size_directive_output = 1;                            \
 621           fprintf (FILE, "%s", SIZE_ASM_OP);                    \
 622           assemble_name (FILE, name);                           \
 623           putc (',', FILE);                                     \
 624           fprintf (FILE, HOST_WIDE_INT_PRINT_DEC,               \
 625                    int_size_in_bytes (TREE_TYPE (DECL)));       \
 626           fputc ('\n', FILE);                                   \
 627         }                                                       \
 628     }                                                           \
 629   while (0)
 630
 631 /* This is how to declare the size of a function.  */
 632 #ifndef ASM_DECLARE_FUNCTION_SIZE
 633 #define ASM_DECLARE_FUNCTION_SIZE(FILE, FNAME, DECL)            \
 634   do                                                            \
 635     {                                                           \
 636       if (!flag_inhibit_size_directive)                         \
 637         {                                                       \
 638           char label[256];                                      \
 639           static int labelno;                                   \
 640                                                                 \
 641           labelno++;                                            \
 642                                                                 \
 643           ASM_GENERATE_INTERNAL_LABEL (label, "Lfe", labelno);  \
 644           ASM_OUTPUT_INTERNAL_LABEL (FILE, "Lfe", labelno);     \
 645                                                                 \
 646           fprintf (FILE, "%s", SIZE_ASM_OP);                    \
 647           assemble_name (FILE, (FNAME));                        \
 648           fprintf (FILE, ",");                                  \
 649           assemble_name (FILE, label);                          \
 650           fprintf (FILE, "-");                                  \
 651           assemble_name (FILE, (FNAME));                        \
 652           putc ('\n', FILE);                                    \
 653         }                                                       \
 654     }                                                           \
 655   while (0)
 656 #endif
 657
 658 /* A table of bytes codes used by the ASM_OUTPUT_ASCII and
 659    ASM_OUTPUT_LIMITED_STRING macros.  Each byte in the table
 660    corresponds to a particular byte value [0..255].  For any
 661    given byte value, if the value in the corresponding table
 662    position is zero, the given character can be output directly.
 663    If the table value is 1, the byte must be output as a \ooo
 664    octal escape.  If the tables value is anything else, then the
 665    byte value should be output as a \ followed by the value
 666    in the table.  Note that we can use standard UN*X escape
 667    sequences for many control characters, but we don't use
 668    \a to represent BEL because some svr4 assemblers (e.g. on
 669    the i386) don't know about that.  Also, we don't use \v
 670    since some versions of gas, such as 2.2 did not accept it.  */
 671
 672 #define ESCAPES \
 673 "\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\
 674 \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\
 675 \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\
 676 \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\
 677 \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\
 678 \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\
 679 \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\
 680 \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"
 681
 682 /* Some svr4 assemblers have a limit on the number of characters which
 683    can appear in the operand of a .string directive.  If your assembler
 684    has such a limitation, you should define STRING_LIMIT to reflect that
 685    limit.  Note that at least some svr4 assemblers have a limit on the
 686    actual number of bytes in the double-quoted string, and that they
 687    count each character in an escape sequence as one byte.  Thus, an
 688    escape sequence like \377 would count as four bytes.
 689
 690    If your target assembler doesn't support the .string directive, you
 691    should define this to zero.
 692 */
 693
 694 #define STRING_LIMIT    ((unsigned) 256)
 695
 696 #define STRING_ASM_OP   "\t.string\t"
 697
 698 /* The routine used to output NUL terminated strings.  We use a special
 699    version of this for most svr4 targets because doing so makes the
 700    generated assembly code more compact (and thus faster to assemble)
 701    as well as more readable, especially for targets like the i386
 702    (where the only alternative is to output character sequences as
 703    comma separated lists of numbers).   */
 704
 705 #define ASM_OUTPUT_LIMITED_STRING(FILE, STR)            \
 706   do                                                    \
 707     {                                                   \
 708       register const unsigned char *_limited_str =      \
 709         (const unsigned char *) (STR);                  \
 710       register unsigned ch;                             \
 711                                                         \
 712       fprintf ((FILE), "%s\"", STRING_ASM_OP);          \
 713                                                         \
 714       for (; (ch = *_limited_str); _limited_str++)      \
 715         {                                               \
 716           register int escape;                          \
 717                                                         \
 718           switch (escape = ESCAPES[ch])                 \
 719             {                                           \
 720             case 0:                                     \
 721               putc (ch, (FILE));                        \
 722               break;                                    \
 723             case 1:                                     \
 724               fprintf ((FILE), "\\%03o", ch);           \
 725               break;                                    \
 726             default:                                    \
 727               putc ('\\', (FILE));                      \
 728               putc (escape, (FILE));                    \
 729               break;                                    \
 730             }                                           \
 731         }                                               \
 732                                                         \
 733       fprintf ((FILE), "\"\n");                         \
 734     }                                                   \
 735   while (0)
 736
 737 /* The routine used to output sequences of byte values.  We use a special
 738    version of this for most svr4 targets because doing so makes the
 739    generated assembly code more compact (and thus faster to assemble)
 740    as well as more readable.  Note that if we find subparts of the
 741    character sequence which end with NUL (and which are shorter than
 742    STRING_LIMIT) we output those using ASM_OUTPUT_LIMITED_STRING.  */
 743
 744 #undef  ASM_OUTPUT_ASCII
 745 #define ASM_OUTPUT_ASCII(FILE, STR, LENGTH)                             \
 746   do                                                                    \
 747     {                                                                   \
 748       register const unsigned char *_ascii_bytes =                      \
 749         (const unsigned char *) (STR);                                  \
 750       register const unsigned char *limit = _ascii_bytes + (LENGTH);    \
 751       register unsigned bytes_in_chunk = 0;                             \
 752                                                                         \
 753       for (; _ascii_bytes < limit; _ascii_bytes++)                      \
 754         {                                                               \
 755           register const unsigned char *p;                              \
 756                                                                         \
 757           if (bytes_in_chunk >= 60)                                     \
 758             {                                                           \
 759               fprintf ((FILE), "\"\n");                                 \
 760               bytes_in_chunk = 0;                                       \
 761             }                                                           \
 762                                                                         \
 763           for (p = _ascii_bytes; p < limit && *p != '\0'; p++)          \
 764             continue;                                                   \
 765                                                                         \
 766           if (p < limit && (p - _ascii_bytes) <= (long)STRING_LIMIT)    \
 767             {                                                           \
 768               if (bytes_in_chunk > 0)                                   \
 769                 {                                                       \
 770                   fprintf ((FILE), "\"\n");                             \
 771                   bytes_in_chunk = 0;                                   \
 772                 }                                                       \
 773                                                                         \
 774               ASM_OUTPUT_LIMITED_STRING ((FILE), _ascii_bytes);         \
 775               _ascii_bytes = p;                                         \
 776             }                                                           \
 777           else                                                          \
 778             {                                                           \
 779               register int escape;                                      \
 780               register unsigned ch;                                     \
 781                                                                         \
 782               if (bytes_in_chunk == 0)                                  \
 783                 fprintf ((FILE), "%s\"", ASCII_DATA_ASM_OP);            \
 784                                                                         \
 785               switch (escape = ESCAPES[ch = *_ascii_bytes])             \
 786                 {                                                       \
 787                 case 0:                                                 \
 788                   putc (ch, (FILE));                                    \
 789                   bytes_in_chunk++;                                     \
 790                   break;                                                \
 791                 case 1:                                                 \
 792                   fprintf ((FILE), "\\%03o", ch);                       \
 793                   bytes_in_chunk += 4;                                  \
 794                   break;                                                \
 795                 default:                                                \
 796                   putc ('\\', (FILE));                                  \
 797                   putc (escape, (FILE));                                \
 798                   bytes_in_chunk += 2;                                  \
 799                   break;                                                \
 800                 }                                                       \
 801             }                                                           \
 802         }                                                               \
 803                                                                         \
 804       if (bytes_in_chunk > 0)                                           \
 805         fprintf ((FILE), "\"\n");                                       \
 806     }                                                                   \
 807   while (0)