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       prefix = prefixes[sec][DECL_ONE_ONLY(DECL)];              \
 376       len    = strlen (name) + strlen (prefix);                 \
 377       string = alloca (len + 1);                                \
 378                                                                 \
 379       sprintf (string, "%s%s", prefix, name);                   \
 380                                                                 \
 381       DECL_SECTION_NAME (DECL) = build_string (len, string);    \
 382     }                                                           \
 383   while (0)
 384
 385 /* A C statement (sans semicolon) to output an
 386    element in the table of global constructors.  */
 387 #define ASM_OUTPUT_CONSTRUCTOR(FILE, NAME)                      \
 388   do                                                            \
 389     {                                                           \
 390       ctors_section ();                                         \
 391       fprintf (FILE, "%s", INT_ASM_OP);                         \
 392       assemble_name (FILE, NAME);                               \
 393       fprintf (FILE, "\n");                                     \
 394     }                                                           \
 395   while (0)
 396
 397 /* A C statement (sans semicolon) to output an
 398    element in the table of global destructors.  */
 399 #define ASM_OUTPUT_DESTRUCTOR(FILE,NAME)                        \
 400   do                                                            \
 401     {                                                           \
 402       dtors_section ();                                         \
 403       fprintf (FILE, "%s", INT_ASM_OP);                         \
 404       assemble_name (FILE, NAME);                               \
 405       fprintf (FILE, "\n");                                     \
 406     }                                                           \
 407   while (0)
 408
 409 /* Switch into a generic section.
 410
 411    We make the section read-only and executable for a function decl,
 412    read-only for a const data decl, and writable for a non-const data decl.
 413
 414    If the section has already been defined, we must not
 415    emit the attributes here. The SVR4 assembler does not
 416    recognize section redefinitions.
 417    If DECL is NULL, no attributes are emitted.  */
 418
 419 #define ASM_OUTPUT_SECTION_NAME(FILE, DECL, NAME, RELOC)                \
 420   do                                                                    \
 421     {                                                                   \
 422       static struct section_info                                        \
 423       {                                                                 \
 424         struct section_info *next;                                      \
 425         char *name;                                                     \
 426         enum sect_enum {SECT_RW, SECT_RO, SECT_EXEC} type;              \
 427       } *sections;                                                      \
 428       struct section_info *s;                                           \
 429       const char *mode;                                                 \
 430       enum sect_enum type;                                              \
 431                                                                         \
 432       for (s = sections; s; s = s->next)                                \
 433         if (!strcmp (NAME, s->name))                                    \
 434           break;                                                        \
 435                                                                         \
 436       if (DECL && TREE_CODE (DECL) == FUNCTION_DECL)                    \
 437         type = SECT_EXEC, mode = "ax";                                  \
 438       else if (DECL && DECL_READONLY_SECTION (DECL, RELOC))             \
 439         type = SECT_RO, mode = "a";                                     \
 440       else                                                              \
 441         type = SECT_RW, mode = "aw";                                    \
 442                                                                         \
 443       if (s == 0)                                                       \
 444         {                                                               \
 445           s = (struct section_info *) xmalloc (sizeof (* s));           \
 446           s->name = xmalloc ((strlen (NAME) + 1) * sizeof (* NAME));    \
 447           strcpy (s->name, NAME);                                       \
 448           s->type = type;                                               \
 449           s->next = sections;                                           \
 450           sections = s;                                                 \
 451           fprintf (FILE, "\t.section\t%s,\"%s\",@progbits\n",           \
 452                    NAME, mode);                                         \
 453         }                                                               \
 454       else                                                              \
 455         {                                                               \
 456           if (DECL && s->type != type)                                  \
 457             error_with_decl (DECL, "%s causes a section type conflict");\
 458                                                                         \
 459           fprintf (FILE, "\t.section\t%s\n", NAME);                     \
 460         }                                                               \
 461     }                                                                   \
 462   while (0)
 463
 464 /* A C statement or statements to switch to the appropriate
 465    section for output of RTX in mode MODE.  RTX is some kind
 466    of constant in RTL.  The argument MODE is redundant except
 467    in the case of a `const_int' rtx.  Currently, these always
 468    go into the const section.  */
 469
 470 #undef  SELECT_RTX_SECTION
 471 #define SELECT_RTX_SECTION(MODE, RTX) const_section ()
 472
 473 /* A C statement or statements to switch to the appropriate
 474    section for output of DECL.  DECL is either a `VAR_DECL' node
 475    or a constant of some sort.  RELOC indicates whether forming
 476    the initial value of DECL requires link-time relocations.  */
 477
 478 #define SELECT_SECTION(DECL, RELOC)                             \
 479 {                                                               \
 480   if (TREE_CODE (DECL) == STRING_CST)                           \
 481     {                                                           \
 482       if (! flag_writable_strings)                              \
 483         const_section ();                                       \
 484       else                                                      \
 485         data_section ();                                        \
 486     }                                                           \
 487   else if (TREE_CODE (DECL) == VAR_DECL)                        \
 488     {                                                           \
 489       if ((flag_pic && RELOC)                                   \
 490           || !TREE_READONLY (DECL) || TREE_SIDE_EFFECTS (DECL)  \
 491           || !DECL_INITIAL (DECL)                               \
 492           || (DECL_INITIAL (DECL) != error_mark_node            \
 493               && !TREE_CONSTANT (DECL_INITIAL (DECL))))         \
 494         data_section ();                                        \
 495       else                                                      \
 496         const_section ();                                       \
 497     }                                                           \
 498   else if (TREE_CODE (DECL) == CONSTRUCTOR)                     \
 499     {                                                           \
 500       if ((flag_pic && RELOC)                                   \
 501           || !TREE_READONLY (DECL) || TREE_SIDE_EFFECTS (DECL)  \
 502           || ! TREE_CONSTANT (DECL))                            \
 503         data_section ();                                        \
 504       else                                                      \
 505         const_section ();                                       \
 506     }                                                           \
 507   else                                                          \
 508     const_section ();                                           \
 509 }
 510
 511 /* Define the strings used for the special svr4 .type and .size directives.
 512    These strings generally do not vary from one system running svr4 to
 513    another, but if a given system (e.g. m88k running svr) needs to use
 514    different pseudo-op names for these, they may be overridden in the
 515    file which includes this one.  */
 516
 517 #define TYPE_ASM_OP     "\t.type\t"
 518 #define SIZE_ASM_OP     "\t.size\t"
 519
 520 /* This is how we tell the assembler that a symbol is weak.  */
 521
 522 #define ASM_WEAKEN_LABEL(FILE, NAME)    \
 523   do                                    \
 524     {                                   \
 525       fputs ("\t.weak\t", (FILE));      \
 526       assemble_name ((FILE), (NAME));   \
 527       fputc ('\n', (FILE));             \
 528     }                                   \
 529   while (0)
 530
 531 /* The following macro defines the format used to output the second
 532    operand of the .type assembler directive.  Different svr4 assemblers
 533    expect various different forms for this operand.  The one given here
 534    is just a default.  You may need to override it in your machine-
 535    specific tm.h file (depending upon the particulars of your assembler).  */
 536
 537 #define TYPE_OPERAND_FMT        "@%s"
 538
 539 /* Write the extra assembler code needed to declare a function's result.
 540    Most svr4 assemblers don't require any special declaration of the
 541    result value, but there are exceptions.  */
 542
 543 #ifndef ASM_DECLARE_RESULT
 544 #define ASM_DECLARE_RESULT(FILE, RESULT)
 545 #endif
 546
 547 /* These macros generate the special .type and .size directives which
 548    are used to set the corresponding fields of the linker symbol table
 549    entries in an ELF object file under SVR4.  These macros also output
 550    the starting labels for the relevant functions/objects.  */
 551
 552 /* Write the extra assembler code needed to declare a function properly.
 553    Some svr4 assemblers need to also have something extra said about the
 554    function's return value.  We allow for that here.  */
 555
 556 #ifndef ASM_DECLARE_FUNCTION_NAME
 557 #define ASM_DECLARE_FUNCTION_NAME(FILE, NAME, DECL)     \
 558   do                                                    \
 559     {                                                   \
 560       fprintf (FILE, "%s", TYPE_ASM_OP);                \
 561       assemble_name (FILE, NAME);                       \
 562       putc (',', FILE);                                 \
 563       fprintf (FILE, TYPE_OPERAND_FMT, "function");     \
 564       putc ('\n', FILE);                                \
 565                                                         \
 566       ASM_DECLARE_RESULT (FILE, DECL_RESULT (DECL));    \
 567       ASM_OUTPUT_LABEL(FILE, NAME);                     \
 568     }                                                   \
 569   while (0)
 570 #endif
 571
 572 /* Write the extra assembler code needed to declare an object properly.  */
 573
 574 #define ASM_DECLARE_OBJECT_NAME(FILE, NAME, DECL)               \
 575   do                                                            \
 576     {                                                           \
 577       fprintf (FILE, "%s", TYPE_ASM_OP);                        \
 578       assemble_name (FILE, NAME);                               \
 579       putc (',', FILE);                                         \
 580       fprintf (FILE, TYPE_OPERAND_FMT, "object");               \
 581       putc ('\n', FILE);                                        \
 582                                                                 \
 583       size_directive_output = 0;                                \
 584                                                                 \
 585       if (!flag_inhibit_size_directive                          \
 586           && (DECL) && DECL_SIZE (DECL))                        \
 587         {                                                       \
 588           size_directive_output = 1;                            \
 589           fprintf (FILE, "%s", SIZE_ASM_OP);                    \
 590           assemble_name (FILE, NAME);                           \
 591           putc (',', FILE);                                     \
 592           fprintf (FILE, HOST_WIDE_INT_PRINT_DEC,               \
 593                    int_size_in_bytes (TREE_TYPE (DECL)));       \
 594           fputc ('\n', FILE);                                   \
 595         }                                                       \
 596                                                                 \
 597       ASM_OUTPUT_LABEL (FILE, NAME);                            \
 598     }                                                           \
 599   while (0)
 600
 601 /* Output the size directive for a decl in rest_of_decl_compilation
 602    in the case where we did not do so before the initializer.
 603    Once we find the error_mark_node, we know that the value of
 604    size_directive_output was set
 605    by ASM_DECLARE_OBJECT_NAME when it was run for the same decl.  */
 606
 607 #define ASM_FINISH_DECLARE_OBJECT(FILE, DECL, TOP_LEVEL, AT_END)\
 608   do                                                            \
 609     {                                                           \
 610       const char *name = XSTR (XEXP (DECL_RTL (DECL), 0), 0);   \
 611                                                                 \
 612       if (!flag_inhibit_size_directive                          \
 613           && DECL_SIZE (DECL)                                   \
 614           && ! AT_END && TOP_LEVEL                              \
 615           && DECL_INITIAL (DECL) == error_mark_node             \
 616           && !size_directive_output)                            \
 617         {                                                       \
 618           size_directive_output = 1;                            \
 619           fprintf (FILE, "%s", SIZE_ASM_OP);                    \
 620           assemble_name (FILE, name);                           \
 621           putc (',', FILE);                                     \
 622           fprintf (FILE, HOST_WIDE_INT_PRINT_DEC,               \
 623                    int_size_in_bytes (TREE_TYPE (DECL)));       \
 624           fputc ('\n', FILE);                                   \
 625         }                                                       \
 626     }                                                           \
 627   while (0)
 628
 629 /* This is how to declare the size of a function.  */
 630 #ifndef ASM_DECLARE_FUNCTION_SIZE
 631 #define ASM_DECLARE_FUNCTION_SIZE(FILE, FNAME, DECL)            \
 632   do                                                            \
 633     {                                                           \
 634       if (!flag_inhibit_size_directive)                         \
 635         {                                                       \
 636           char label[256];                                      \
 637           static int labelno;                                   \
 638                                                                 \
 639           labelno++;                                            \
 640                                                                 \
 641           ASM_GENERATE_INTERNAL_LABEL (label, "Lfe", labelno);  \
 642           ASM_OUTPUT_INTERNAL_LABEL (FILE, "Lfe", labelno);     \
 643                                                                 \
 644           fprintf (FILE, "%s", SIZE_ASM_OP);                    \
 645           assemble_name (FILE, (FNAME));                        \
 646           fprintf (FILE, ",");                                  \
 647           assemble_name (FILE, label);                          \
 648           fprintf (FILE, "-");                                  \
 649           assemble_name (FILE, (FNAME));                        \
 650           putc ('\n', FILE);                                    \
 651         }                                                       \
 652     }                                                           \
 653   while (0)
 654 #endif
 655
 656 /* A table of bytes codes used by the ASM_OUTPUT_ASCII and
 657    ASM_OUTPUT_LIMITED_STRING macros.  Each byte in the table
 658    corresponds to a particular byte value [0..255].  For any
 659    given byte value, if the value in the corresponding table
 660    position is zero, the given character can be output directly.
 661    If the table value is 1, the byte must be output as a \ooo
 662    octal escape.  If the tables value is anything else, then the
 663    byte value should be output as a \ followed by the value
 664    in the table.  Note that we can use standard UN*X escape
 665    sequences for many control characters, but we don't use
 666    \a to represent BEL because some svr4 assemblers (e.g. on
 667    the i386) don't know about that.  Also, we don't use \v
 668    since some versions of gas, such as 2.2 did not accept it.  */
 669
 670 #define ESCAPES \
 671 "\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\
 672 \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\
 673 \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\
 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\1\
 675 \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\
 676 \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\
 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
 680 /* Some svr4 assemblers have a limit on the number of characters which
 681    can appear in the operand of a .string directive.  If your assembler
 682    has such a limitation, you should define STRING_LIMIT to reflect that
 683    limit.  Note that at least some svr4 assemblers have a limit on the
 684    actual number of bytes in the double-quoted string, and that they
 685    count each character in an escape sequence as one byte.  Thus, an
 686    escape sequence like \377 would count as four bytes.
 687
 688    If your target assembler doesn't support the .string directive, you
 689    should define this to zero.
 690 */
 691
 692 #define STRING_LIMIT    ((unsigned) 256)
 693
 694 #define STRING_ASM_OP   "\t.string\t"
 695
 696 /* The routine used to output NUL terminated strings.  We use a special
 697    version of this for most svr4 targets because doing so makes the
 698    generated assembly code more compact (and thus faster to assemble)
 699    as well as more readable, especially for targets like the i386
 700    (where the only alternative is to output character sequences as
 701    comma separated lists of numbers).   */
 702
 703 #define ASM_OUTPUT_LIMITED_STRING(FILE, STR)            \
 704   do                                                    \
 705     {                                                   \
 706       register const unsigned char *_limited_str =      \
 707         (const unsigned char *) (STR);                  \
 708       register unsigned ch;                             \
 709                                                         \
 710       fprintf ((FILE), "%s\"", STRING_ASM_OP);          \
 711                                                         \
 712       for (; (ch = *_limited_str); _limited_str++)      \
 713         {                                               \
 714           register int escape;                          \
 715                                                         \
 716           switch (escape = ESCAPES[ch])                 \
 717             {                                           \
 718             case 0:                                     \
 719               putc (ch, (FILE));                        \
 720               break;                                    \
 721             case 1:                                     \
 722               fprintf ((FILE), "\\%03o", ch);           \
 723               break;                                    \
 724             default:                                    \
 725               putc ('\\', (FILE));                      \
 726               putc (escape, (FILE));                    \
 727               break;                                    \
 728             }                                           \
 729         }                                               \
 730                                                         \
 731       fprintf ((FILE), "\"\n");                         \
 732     }                                                   \
 733   while (0)
 734
 735 /* The routine used to output sequences of byte values.  We use a special
 736    version of this for most svr4 targets because doing so makes the
 737    generated assembly code more compact (and thus faster to assemble)
 738    as well as more readable.  Note that if we find subparts of the
 739    character sequence which end with NUL (and which are shorter than
 740    STRING_LIMIT) we output those using ASM_OUTPUT_LIMITED_STRING.  */
 741
 742 #undef  ASM_OUTPUT_ASCII
 743 #define ASM_OUTPUT_ASCII(FILE, STR, LENGTH)                             \
 744   do                                                                    \
 745     {                                                                   \
 746       register const unsigned char *_ascii_bytes =                      \
 747         (const unsigned char *) (STR);                                  \
 748       register const unsigned char *limit = _ascii_bytes + (LENGTH);    \
 749       register unsigned bytes_in_chunk = 0;                             \
 750                                                                         \
 751       for (; _ascii_bytes < limit; _ascii_bytes++)                      \
 752         {                                                               \
 753           register const unsigned char *p;                              \
 754                                                                         \
 755           if (bytes_in_chunk >= 60)                                     \
 756             {                                                           \
 757               fprintf ((FILE), "\"\n");                                 \
 758               bytes_in_chunk = 0;                                       \
 759             }                                                           \
 760                                                                         \
 761           for (p = _ascii_bytes; p < limit && *p != '\0'; p++)          \
 762             continue;                                                   \
 763                                                                         \
 764           if (p < limit && (p - _ascii_bytes) <= (long)STRING_LIMIT)    \
 765             {                                                           \
 766               if (bytes_in_chunk > 0)                                   \
 767                 {                                                       \
 768                   fprintf ((FILE), "\"\n");                             \
 769                   bytes_in_chunk = 0;                                   \
 770                 }                                                       \
 771                                                                         \
 772               ASM_OUTPUT_LIMITED_STRING ((FILE), _ascii_bytes);         \
 773               _ascii_bytes = p;                                         \
 774             }                                                           \
 775           else                                                          \
 776             {                                                           \
 777               register int escape;                                      \
 778               register unsigned ch;                                     \
 779                                                                         \
 780               if (bytes_in_chunk == 0)                                  \
 781                 fprintf ((FILE), "%s\"", ASCII_DATA_ASM_OP);            \
 782                                                                         \
 783               switch (escape = ESCAPES[ch = *_ascii_bytes])             \
 784                 {                                                       \
 785                 case 0:                                                 \
 786                   putc (ch, (FILE));                                    \
 787                   bytes_in_chunk++;                                     \
 788                   break;                                                \
 789                 case 1:                                                 \
 790                   fprintf ((FILE), "\\%03o", ch);                       \
 791                   bytes_in_chunk += 4;                                  \
 792                   break;                                                \
 793                 default:                                                \
 794                   putc ('\\', (FILE));                                  \
 795                   putc (escape, (FILE));                                \
 796                   bytes_in_chunk += 2;                                  \
 797                   break;                                                \
 798                 }                                                       \
 799             }                                                           \
 800         }                                                               \
 801                                                                         \
 802       if (bytes_in_chunk > 0)                                           \
 803         fprintf ((FILE), "\"\n");                                       \
 804     }                                                                   \
 805   while (0)