gcc/varasm.c

   1 /* Output variables, constants and external declarations, for GNU compiler.
   2    Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997,
   3    1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING.  If not, write to the Free
  19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA.  */
  21
  22
  23 /* This file handles generation of all the assembler code
  24    *except* the instructions of a function.
  25    This includes declarations of variables and their initial values.
  26
  27    We also output the assembler code for constants stored in memory
  28    and are responsible for combining constants with the same value.  */
  29
  30 #include "config.h"
  31 #include "system.h"
  32 #include "coretypes.h"
  33 #include "tm.h"
  34 #include "rtl.h"
  35 #include "tree.h"
  36 #include "flags.h"
  37 #include "function.h"
  38 #include "expr.h"
  39 #include "hard-reg-set.h"
  40 #include "regs.h"
  41 #include "real.h"
  42 #include "output.h"
  43 #include "toplev.h"
  44 #include "hashtab.h"
  45 #include "c-pragma.h"
  46 #include "ggc.h"
  47 #include "langhooks.h"
  48 #include "tm_p.h"
  49 #include "debug.h"
  50 #include "target.h"
  51 #include "tree-mudflap.h"
  52 #include "cgraph.h"
  53 #include "cfglayout.h"
  54
  55 #ifdef XCOFF_DEBUGGING_INFO
  56 #include "xcoffout.h"           /* Needed for external data
  57                                    declarations for e.g. AIX 4.x.  */
  58 #endif
  59
  60 /* The (assembler) name of the first globally-visible object output.  */
  61 const char *first_global_object_name;
  62 const char *weak_global_object_name;
  63
  64 struct addr_const;
  65 struct constant_descriptor_rtx;
  66 struct rtx_constant_pool;
  67
  68 struct varasm_status GTY(())
  69 {
  70   /* If we're using a per-function constant pool, this is it.  */
  71   struct rtx_constant_pool *pool;
  72
  73   /* Number of tree-constants deferred during the expansion of this
  74      function.  */
  75   unsigned int deferred_constants;
  76 };
  77
  78 #define n_deferred_constants (cfun->varasm->deferred_constants)
  79
  80 /* Number for making the label on the next
  81    constant that is stored in memory.  */
  82
  83 static GTY(()) int const_labelno;
  84
  85 /* Carry information from ASM_DECLARE_OBJECT_NAME
  86    to ASM_FINISH_DECLARE_OBJECT.  */
  87
  88 int size_directive_output;
  89
  90 /* The last decl for which assemble_variable was called,
  91    if it did ASM_DECLARE_OBJECT_NAME.
  92    If the last call to assemble_variable didn't do that,
  93    this holds 0.  */
  94
  95 tree last_assemble_variable_decl;
  96
  97 /* The following global variable indicates if the section label for the
  98    "cold" section of code has been output yet to the assembler.  The
  99    label is useful when running gdb.  This is part of the optimization that
 100    partitions hot and cold basic blocks into separate sections of the .o
 101    file.  */
 102
 103 static bool unlikely_section_label_printed = false;
 104
 105 /* The following global variable indicates the label name to be put at
 106    the start of the first cold section within each function, when
 107    partitioning basic blocks into hot and cold sections.  */
 108
 109 static char *unlikely_section_label = NULL;
 110
 111 /* The following global variable indicates the section name to be used
 112    for the current cold section, when partitioning hot and cold basic
 113    blocks into separate sections.  */
 114
 115 static char *unlikely_text_section_name = NULL;
 116
 117 /* We give all constants their own alias set.  Perhaps redundant with
 118    MEM_READONLY_P, but pre-dates it.  */
 119
 120 static HOST_WIDE_INT const_alias_set;
 121
 122 static const char *strip_reg_name (const char *);
 123 static int contains_pointers_p (tree);
 124 #ifdef ASM_OUTPUT_EXTERNAL
 125 static bool incorporeal_function_p (tree);
 126 #endif
 127 static void decode_addr_const (tree, struct addr_const *);
 128 static hashval_t const_desc_hash (const void *);
 129 static int const_desc_eq (const void *, const void *);
 130 static hashval_t const_hash_1 (const tree);
 131 static int compare_constant (const tree, const tree);
 132 static tree copy_constant (tree);
 133 static void output_constant_def_contents (rtx);
 134 static void output_addressed_constants (tree);
 135 static unsigned HOST_WIDE_INT array_size_for_constructor (tree);
 136 static unsigned min_align (unsigned, unsigned);
 137 static void output_constructor (tree, unsigned HOST_WIDE_INT, unsigned int);
 138 static void globalize_decl (tree);
 139 static void maybe_assemble_visibility (tree);
 140 static int in_named_entry_eq (const void *, const void *);
 141 static hashval_t in_named_entry_hash (const void *);
 142 #ifdef BSS_SECTION_ASM_OP
 143 #ifdef ASM_OUTPUT_BSS
 144 static void asm_output_bss (FILE *, tree, const char *,
 145                             unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT);
 146 #endif
 147 #ifdef ASM_OUTPUT_ALIGNED_BSS
 148 static void asm_output_aligned_bss (FILE *, tree, const char *,
 149                                     unsigned HOST_WIDE_INT, int)
 150      ATTRIBUTE_UNUSED;
 151 #endif
 152 #endif /* BSS_SECTION_ASM_OP */
 153 static bool asm_emit_uninitialised (tree, const char*,
 154                                     unsigned HOST_WIDE_INT,
 155                                     unsigned HOST_WIDE_INT);
 156 static void mark_weak (tree);
 157 \f
 158 enum in_section { no_section, in_text, in_unlikely_executed_text, in_data,
 159                   in_named
 160 #ifdef BSS_SECTION_ASM_OP
 161   , in_bss
 162 #endif
 163 #ifdef CTORS_SECTION_ASM_OP
 164   , in_ctors
 165 #endif
 166 #ifdef DTORS_SECTION_ASM_OP
 167   , in_dtors
 168 #endif
 169 #ifdef READONLY_DATA_SECTION_ASM_OP
 170   , in_readonly_data
 171 #endif
 172 #ifdef EXTRA_SECTIONS
 173   , EXTRA_SECTIONS
 174 #endif
 175 };
 176 static GTY(()) enum in_section in_section = no_section;
 177
 178 /* Return a nonzero value if DECL has a section attribute.  */
 179 #ifndef IN_NAMED_SECTION
 180 #define IN_NAMED_SECTION(DECL) \
 181   ((TREE_CODE (DECL) == FUNCTION_DECL || TREE_CODE (DECL) == VAR_DECL) \
 182    && DECL_SECTION_NAME (DECL) != NULL_TREE)
 183 #endif
 184
 185 /* Text of section name when in_section == in_named.  */
 186 static GTY(()) const char *in_named_name;
 187
 188 /* Hash table of flags that have been used for a particular named section.  */
 189
 190 struct in_named_entry GTY(())
 191 {
 192   const char *name;
 193   unsigned int flags;
 194   bool declared;
 195 };
 196
 197 static GTY((param_is (struct in_named_entry))) htab_t in_named_htab;
 198
 199 /* Define functions like text_section for any extra sections.  */
 200 #ifdef EXTRA_SECTION_FUNCTIONS
 201 EXTRA_SECTION_FUNCTIONS
 202 #endif
 203
 204 /* Tell assembler to switch to text section.  */
 205
 206 void
 207 text_section (void)
 208 {
 209   if (in_section != in_text)
 210     {
 211       in_section = in_text;
 212       fprintf (asm_out_file, "%s\n", TEXT_SECTION_ASM_OP);
 213     }
 214 }
 215
 216 /* Tell assembler to switch to unlikely-to-be-executed text section.  */
 217
 218 void
 219 unlikely_text_section (void)
 220 {
 221   const char *name;
 222   int len;
 223
 224   if (! unlikely_text_section_name)
 225     {
 226       if (DECL_SECTION_NAME (current_function_decl)
 227           && (strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME
 228                                            (current_function_decl)),
 229                       HOT_TEXT_SECTION_NAME) != 0)
 230           && (strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME
 231                                            (current_function_decl)),
 232                       UNLIKELY_EXECUTED_TEXT_SECTION_NAME) != 0))
 233         {
 234           name = TREE_STRING_POINTER (DECL_SECTION_NAME
 235                                                    (current_function_decl));
 236           len = strlen (name);
 237           unlikely_text_section_name = xmalloc ((len + 10) * sizeof (char));
 238           strcpy (unlikely_text_section_name, name);
 239           strcat (unlikely_text_section_name, "_unlikely");
 240         }
 241       else
 242         {
 243           len = strlen (UNLIKELY_EXECUTED_TEXT_SECTION_NAME);
 244           unlikely_text_section_name = xmalloc (len+1 * sizeof (char));
 245           strcpy (unlikely_text_section_name,
 246                   UNLIKELY_EXECUTED_TEXT_SECTION_NAME);
 247         }
 248     }
 249
 250   if ((in_section != in_unlikely_executed_text)
 251       &&  (in_section != in_named
 252            || strcmp (in_named_name, unlikely_text_section_name) != 0))
 253     {
 254       named_section (NULL_TREE, unlikely_text_section_name, 0);
 255       in_section = in_unlikely_executed_text;
 256
 257       if (!unlikely_section_label_printed)
 258         {
 259           ASM_OUTPUT_LABEL (asm_out_file, unlikely_section_label);
 260           unlikely_section_label_printed = true;
 261         }
 262     }
 263 }
 264
 265 /* Tell assembler to switch to data section.  */
 266
 267 void
 268 data_section (void)
 269 {
 270   if (in_section != in_data)
 271     {
 272       in_section = in_data;
 273       fprintf (asm_out_file, "%s\n", DATA_SECTION_ASM_OP);
 274     }
 275 }
 276
 277 /* Tell assembler to switch to read-only data section.  This is normally
 278    the text section.  */
 279
 280 void
 281 readonly_data_section (void)
 282 {
 283 #ifdef READONLY_DATA_SECTION
 284   READONLY_DATA_SECTION ();  /* Note this can call data_section.  */
 285 #else
 286 #ifdef READONLY_DATA_SECTION_ASM_OP
 287   if (in_section != in_readonly_data)
 288     {
 289       in_section = in_readonly_data;
 290       fputs (READONLY_DATA_SECTION_ASM_OP, asm_out_file);
 291       fputc ('\n', asm_out_file);
 292     }
 293 #else
 294   text_section ();
 295 #endif
 296 #endif
 297 }
 298
 299 /* Determine if we're in the text section.  */
 300
 301 int
 302 in_text_section (void)
 303 {
 304   return in_section == in_text;
 305 }
 306
 307 /* Determine if we're in the unlikely-to-be-executed text section.  */
 308
 309 int
 310 in_unlikely_text_section (void)
 311 {
 312   bool ret_val;
 313
 314   ret_val = ((in_section == in_unlikely_executed_text)
 315              || (in_section == in_named
 316                  && unlikely_text_section_name
 317                  && strcmp (in_named_name, unlikely_text_section_name) == 0));
 318
 319   return ret_val;
 320 }
 321
 322 /* Determine if we're in the data section.  */
 323
 324 int
 325 in_data_section (void)
 326 {
 327   return in_section == in_data;
 328 }
 329
 330 /* Helper routines for maintaining in_named_htab.  */
 331
 332 static int
 333 in_named_entry_eq (const void *p1, const void *p2)
 334 {
 335   const struct in_named_entry *old = p1;
 336   const char *new = p2;
 337
 338   return strcmp (old->name, new) == 0;
 339 }
 340
 341 static hashval_t
 342 in_named_entry_hash (const void *p)
 343 {
 344   const struct in_named_entry *old = p;
 345   return htab_hash_string (old->name);
 346 }
 347
 348 /* If SECTION has been seen before as a named section, return the flags
 349    that were used.  Otherwise, return 0.  Note, that 0 is a perfectly valid
 350    set of flags for a section to have, so 0 does not mean that the section
 351    has not been seen.  */
 352
 353 unsigned int
 354 get_named_section_flags (const char *section)
 355 {
 356   struct in_named_entry **slot;
 357
 358   slot = (struct in_named_entry **)
 359     htab_find_slot_with_hash (in_named_htab, section,
 360                               htab_hash_string (section), NO_INSERT);
 361
 362   return slot ? (*slot)->flags : 0;
 363 }
 364
 365 /* Returns true if the section has been declared before.   Sets internal
 366    flag on this section in in_named_hash so subsequent calls on this
 367    section will return false.  */
 368
 369 bool
 370 named_section_first_declaration (const char *name)
 371 {
 372   struct in_named_entry **slot;
 373
 374   slot = (struct in_named_entry **)
 375     htab_find_slot_with_hash (in_named_htab, name,
 376                               htab_hash_string (name), NO_INSERT);
 377   if (! (*slot)->declared)
 378     {
 379       (*slot)->declared = true;
 380       return true;
 381     }
 382   else
 383     {
 384       return false;
 385     }
 386 }
 387
 388
 389 /* Record FLAGS for SECTION.  If SECTION was previously recorded with a
 390    different set of flags, return false.  */
 391
 392 bool
 393 set_named_section_flags (const char *section, unsigned int flags)
 394 {
 395   struct in_named_entry **slot, *entry;
 396
 397   slot = (struct in_named_entry **)
 398     htab_find_slot_with_hash (in_named_htab, section,
 399                               htab_hash_string (section), INSERT);
 400   entry = *slot;
 401
 402   if (!entry)
 403     {
 404       entry = ggc_alloc (sizeof (*entry));
 405       *slot = entry;
 406       entry->name = ggc_strdup (section);
 407       entry->flags = flags;
 408       entry->declared = false;
 409     }
 410   else if (entry->flags != flags)
 411     return false;
 412
 413   return true;
 414 }
 415
 416 /* Tell assembler to change to section NAME with attributes FLAGS.  If
 417    DECL is non-NULL, it is the VAR_DECL or FUNCTION_DECL with which
 418    this section is associated.  */
 419
 420 void
 421 named_section_real (const char *name, unsigned int flags, tree decl)
 422 {
 423   if (in_section != in_named || strcmp (name, in_named_name) != 0)
 424     {
 425       if (! set_named_section_flags (name, flags))
 426         abort ();
 427
 428       targetm.asm_out.named_section (name, flags, decl);
 429
 430       if (flags & SECTION_FORGET)
 431         in_section = no_section;
 432       else
 433         {
 434           in_named_name = ggc_strdup (name);
 435           in_section = in_named;
 436         }
 437     }
 438 }
 439
 440 /* Tell assembler to change to section NAME for DECL.
 441    If DECL is NULL, just switch to section NAME.
 442    If NAME is NULL, get the name from DECL.
 443    If RELOC is 1, the initializer for DECL contains relocs.  */
 444
 445 void
 446 named_section (tree decl, const char *name, int reloc)
 447 {
 448   unsigned int flags;
 449
 450   if (decl != NULL_TREE && !DECL_P (decl))
 451     abort ();
 452   if (name == NULL)
 453     name = TREE_STRING_POINTER (DECL_SECTION_NAME (decl));
 454
 455   if (strcmp (name, UNLIKELY_EXECUTED_TEXT_SECTION_NAME) == 0
 456       && !unlikely_text_section_name)
 457     {
 458       unlikely_text_section_name = xmalloc
 459              (strlen (UNLIKELY_EXECUTED_TEXT_SECTION_NAME) + 1
 460               * sizeof (char));
 461       strcpy (unlikely_text_section_name,
 462               UNLIKELY_EXECUTED_TEXT_SECTION_NAME);
 463     }
 464
 465   flags = targetm.section_type_flags (decl, name, reloc);
 466
 467   /* Sanity check user variables for flag changes.  Non-user
 468      section flag changes will abort in named_section_flags.
 469      However, don't complain if SECTION_OVERRIDE is set.
 470      We trust that the setter knows that it is safe to ignore
 471      the default flags for this decl.  */
 472   if (decl && ! set_named_section_flags (name, flags))
 473     {
 474       flags = get_named_section_flags (name);
 475       if ((flags & SECTION_OVERRIDE) == 0)
 476         error ("%J%D causes a section type conflict", decl, decl);
 477     }
 478
 479   named_section_real (name, flags, decl);
 480 }
 481
 482 /* If required, set DECL_SECTION_NAME to a unique name.  */
 483
 484 void
 485 resolve_unique_section (tree decl, int reloc ATTRIBUTE_UNUSED,
 486                         int flag_function_or_data_sections)
 487 {
 488   if (DECL_SECTION_NAME (decl) == NULL_TREE
 489       && targetm.have_named_sections
 490       && (flag_function_or_data_sections
 491           || DECL_ONE_ONLY (decl)))
 492     targetm.asm_out.unique_section (decl, reloc);
 493 }
 494
 495 #ifdef BSS_SECTION_ASM_OP
 496
 497 /* Tell the assembler to switch to the bss section.  */
 498
 499 void
 500 bss_section (void)
 501 {
 502   if (in_section != in_bss)
 503     {
 504       fprintf (asm_out_file, "%s\n", BSS_SECTION_ASM_OP);
 505       in_section = in_bss;
 506     }
 507 }
 508
 509 #ifdef ASM_OUTPUT_BSS
 510
 511 /* Utility function for ASM_OUTPUT_BSS for targets to use if
 512    they don't support alignments in .bss.
 513    ??? It is believed that this function will work in most cases so such
 514    support is localized here.  */
 515
 516 static void
 517 asm_output_bss (FILE *file, tree decl ATTRIBUTE_UNUSED,
 518                 const char *name,
 519                 unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED,
 520                 unsigned HOST_WIDE_INT rounded)
 521 {
 522   targetm.asm_out.globalize_label (file, name);
 523   bss_section ();
 524 #ifdef ASM_DECLARE_OBJECT_NAME
 525   last_assemble_variable_decl = decl;
 526   ASM_DECLARE_OBJECT_NAME (file, name, decl);
 527 #else
 528   /* Standard thing is just output label for the object.  */
 529   ASM_OUTPUT_LABEL (file, name);
 530 #endif /* ASM_DECLARE_OBJECT_NAME */
 531   ASM_OUTPUT_SKIP (file, rounded ? rounded : 1);
 532 }
 533
 534 #endif
 535
 536 #ifdef ASM_OUTPUT_ALIGNED_BSS
 537
 538 /* Utility function for targets to use in implementing
 539    ASM_OUTPUT_ALIGNED_BSS.
 540    ??? It is believed that this function will work in most cases so such
 541    support is localized here.  */
 542
 543 static void
 544 asm_output_aligned_bss (FILE *file, tree decl ATTRIBUTE_UNUSED,
 545                         const char *name, unsigned HOST_WIDE_INT size,
 546                         int align)
 547 {
 548   bss_section ();
 549   ASM_OUTPUT_ALIGN (file, floor_log2 (align / BITS_PER_UNIT));
 550 #ifdef ASM_DECLARE_OBJECT_NAME
 551   last_assemble_variable_decl = decl;
 552   ASM_DECLARE_OBJECT_NAME (file, name, decl);
 553 #else
 554   /* Standard thing is just output label for the object.  */
 555   ASM_OUTPUT_LABEL (file, name);
 556 #endif /* ASM_DECLARE_OBJECT_NAME */
 557   ASM_OUTPUT_SKIP (file, size ? size : 1);
 558 }
 559
 560 #endif
 561
 562 #endif /* BSS_SECTION_ASM_OP */
 563
 564 /* Switch to the section for function DECL.
 565
 566    If DECL is NULL_TREE, switch to the text section.
 567    ??? It's not clear that we will ever be passed NULL_TREE, but it's
 568    safer to handle it.  */
 569
 570 void
 571 function_section (tree decl)
 572 {
 573 #ifdef USE_SELECT_SECTION_FOR_FUNCTIONS
 574   bool unlikely = scan_ahead_for_unlikely_executed_note (get_insns());
 575
 576   targetm.asm_out.select_section (decl, unlikely, DECL_ALIGN (decl));
 577 #else
 578   if (scan_ahead_for_unlikely_executed_note (get_insns()))
 579     unlikely_text_section ();
 580   else if (decl != NULL_TREE
 581            && DECL_SECTION_NAME (decl) != NULL_TREE)
 582     named_section (decl, (char *) 0, 0);
 583   else
 584     text_section ();
 585 #endif
 586 }
 587
 588 /* Switch to read-only data section associated with function DECL.  */
 589
 590 void
 591 default_function_rodata_section (tree decl)
 592 {
 593   if (decl != NULL_TREE && DECL_SECTION_NAME (decl))
 594     {
 595       const char *name = TREE_STRING_POINTER (DECL_SECTION_NAME (decl));
 596
 597       /* For .gnu.linkonce.t.foo we want to use .gnu.linkonce.r.foo.  */
 598       if (DECL_ONE_ONLY (decl) && strncmp (name, ".gnu.linkonce.t.", 16) == 0)
 599         {
 600           size_t len = strlen (name) + 1;
 601           char *rname = alloca (len);
 602
 603           memcpy (rname, name, len);
 604           rname[14] = 'r';
 605           named_section_real (rname, SECTION_LINKONCE, decl);
 606           return;
 607         }
 608       /* For .text.foo we want to use .rodata.foo.  */
 609       else if (flag_function_sections && flag_data_sections
 610                && strncmp (name, ".text.", 6) == 0)
 611         {
 612           size_t len = strlen (name) + 1;
 613           char *rname = alloca (len + 2);
 614
 615           memcpy (rname, ".rodata", 7);
 616           memcpy (rname + 7, name + 5, len - 5);
 617           named_section_flags (rname, 0);
 618           return;
 619         }
 620     }
 621
 622   readonly_data_section ();
 623 }
 624
 625 /* Switch to read-only data section associated with function DECL
 626    for targets where that section should be always the single
 627    readonly data section.  */
 628
 629 void
 630 default_no_function_rodata_section (tree decl ATTRIBUTE_UNUSED)
 631 {
 632   readonly_data_section ();
 633 }
 634
 635 /* Switch to section for variable DECL.  RELOC is the same as the
 636    argument to SELECT_SECTION.  */
 637
 638 void
 639 variable_section (tree decl, int reloc)
 640 {
 641   if (IN_NAMED_SECTION (decl))
 642     named_section (decl, NULL, reloc);
 643   else
 644     targetm.asm_out.select_section (decl, reloc, DECL_ALIGN (decl));
 645 }
 646
 647 /* Tell assembler to switch to the section for string merging.  */
 648
 649 void
 650 mergeable_string_section (tree decl ATTRIBUTE_UNUSED,
 651                           unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED,
 652                           unsigned int flags ATTRIBUTE_UNUSED)
 653 {
 654   if (HAVE_GAS_SHF_MERGE && flag_merge_constants
 655       && TREE_CODE (decl) == STRING_CST
 656       && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
 657       && align <= 256
 658       && TREE_STRING_LENGTH (decl) >= int_size_in_bytes (TREE_TYPE (decl)))
 659     {
 660       enum machine_mode mode;
 661       unsigned int modesize;
 662       const char *str;
 663       int i, j, len, unit;
 664       char name[30];
 665
 666       mode = TYPE_MODE (TREE_TYPE (TREE_TYPE (decl)));
 667       modesize = GET_MODE_BITSIZE (mode);
 668       if (modesize >= 8 && modesize <= 256
 669           && (modesize & (modesize - 1)) == 0)
 670         {
 671           if (align < modesize)
 672             align = modesize;
 673
 674           str = TREE_STRING_POINTER (decl);
 675           len = TREE_STRING_LENGTH (decl);
 676           unit = GET_MODE_SIZE (mode);
 677
 678           /* Check for embedded NUL characters.  */
 679           for (i = 0; i < len; i += unit)
 680             {
 681               for (j = 0; j < unit; j++)
 682                 if (str[i + j] != '\0')
 683                   break;
 684               if (j == unit)
 685                 break;
 686             }
 687           if (i == len - unit)
 688             {
 689               sprintf (name, ".rodata.str%d.%d", modesize / 8,
 690                        (int) (align / 8));
 691               flags |= (modesize / 8) | SECTION_MERGE | SECTION_STRINGS;
 692               if (!i && modesize < align)
 693                 {
 694                   /* A "" string with requested alignment greater than
 695                      character size might cause a problem:
 696                      if some other string required even bigger
 697                      alignment than "", then linker might think the
 698                      "" is just part of padding after some other string
 699                      and not put it into the hash table initially.
 700                      But this means "" could have smaller alignment
 701                      than requested.  */
 702 #ifdef ASM_OUTPUT_SECTION_START
 703                   named_section_flags (name, flags);
 704                   ASM_OUTPUT_SECTION_START (asm_out_file);
 705 #else
 706                   readonly_data_section ();
 707 #endif
 708                   return;
 709                 }
 710
 711               named_section_flags (name, flags);
 712               return;
 713             }
 714         }
 715     }
 716
 717   readonly_data_section ();
 718 }
 719
 720 /* Tell assembler to switch to the section for constant merging.  */
 721
 722 void
 723 mergeable_constant_section (enum machine_mode mode ATTRIBUTE_UNUSED,
 724                             unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED,
 725                             unsigned int flags ATTRIBUTE_UNUSED)
 726 {
 727   unsigned int modesize = GET_MODE_BITSIZE (mode);
 728
 729   if (HAVE_GAS_SHF_MERGE && flag_merge_constants
 730       && mode != VOIDmode
 731       && mode != BLKmode
 732       && modesize <= align
 733       && align >= 8
 734       && align <= 256
 735       && (align & (align - 1)) == 0)
 736     {
 737       char name[24];
 738
 739       sprintf (name, ".rodata.cst%d", (int) (align / 8));
 740       flags |= (align / 8) | SECTION_MERGE;
 741       named_section_flags (name, flags);
 742       return;
 743     }
 744
 745   readonly_data_section ();
 746 }
 747 \f
 748 /* Given NAME, a putative register name, discard any customary prefixes.  */
 749
 750 static const char *
 751 strip_reg_name (const char *name)
 752 {
 753 #ifdef REGISTER_PREFIX
 754   if (!strncmp (name, REGISTER_PREFIX, strlen (REGISTER_PREFIX)))
 755     name += strlen (REGISTER_PREFIX);
 756 #endif
 757   if (name[0] == '%' || name[0] == '#')
 758     name++;
 759   return name;
 760 }
 761 \f
 762 /* The user has asked for a DECL to have a particular name.  Set (or
 763    change) it in such a way that we don't prefix an underscore to
 764    it.  */
 765 void
 766 set_user_assembler_name (tree decl, const char *name)
 767 {
 768   char *starred = alloca (strlen (name) + 2);
 769   starred[0] = '*';
 770   strcpy (starred + 1, name);
 771   change_decl_assembler_name (decl, get_identifier (starred));
 772   SET_DECL_RTL (decl, NULL_RTX);
 773 }
 774 \f
 775 /* Decode an `asm' spec for a declaration as a register name.
 776    Return the register number, or -1 if nothing specified,
 777    or -2 if the ASMSPEC is not `cc' or `memory' and is not recognized,
 778    or -3 if ASMSPEC is `cc' and is not recognized,
 779    or -4 if ASMSPEC is `memory' and is not recognized.
 780    Accept an exact spelling or a decimal number.
 781    Prefixes such as % are optional.  */
 782
 783 int
 784 decode_reg_name (const char *asmspec)
 785 {
 786   if (asmspec != 0 && strlen (asmspec) != 0)
 787     {
 788       int i;
 789
 790       /* Get rid of confusing prefixes.  */
 791       asmspec = strip_reg_name (asmspec);
 792
 793       /* Allow a decimal number as a "register name".  */
 794       for (i = strlen (asmspec) - 1; i >= 0; i--)
 795         if (! ISDIGIT (asmspec[i]))
 796           break;
 797       if (asmspec[0] != 0 && i < 0)
 798         {
 799           i = atoi (asmspec);
 800           if (i < FIRST_PSEUDO_REGISTER && i >= 0)
 801             return i;
 802           else
 803             return -2;
 804         }
 805
 806       for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
 807         if (reg_names[i][0]
 808             && ! strcmp (asmspec, strip_reg_name (reg_names[i])))
 809           return i;
 810
 811 #ifdef ADDITIONAL_REGISTER_NAMES
 812       {
 813         static const struct { const char *const name; const int number; } table[]
 814           = ADDITIONAL_REGISTER_NAMES;
 815
 816         for (i = 0; i < (int) ARRAY_SIZE (table); i++)
 817           if (! strcmp (asmspec, table[i].name))
 818             return table[i].number;
 819       }
 820 #endif /* ADDITIONAL_REGISTER_NAMES */
 821
 822       if (!strcmp (asmspec, "memory"))
 823         return -4;
 824
 825       if (!strcmp (asmspec, "cc"))
 826         return -3;
 827
 828       return -2;
 829     }
 830
 831   return -1;
 832 }
 833 \f
 834 /* Create the DECL_RTL for a VAR_DECL or FUNCTION_DECL.  DECL should
 835    have static storage duration.  In other words, it should not be an
 836    automatic variable, including PARM_DECLs.
 837
 838    There is, however, one exception: this function handles variables
 839    explicitly placed in a particular register by the user.
 840
 841    This is never called for PARM_DECL nodes.  */
 842
 843 void
 844 make_decl_rtl (tree decl)
 845 {
 846   const char *name = 0;
 847   int reg_number;
 848   rtx x;
 849
 850   /* Check that we are not being given an automatic variable.  */
 851   /* A weak alias has TREE_PUBLIC set but not the other bits.  */
 852   if (TREE_CODE (decl) == PARM_DECL
 853       || TREE_CODE (decl) == RESULT_DECL
 854       || (TREE_CODE (decl) == VAR_DECL
 855           && !TREE_STATIC (decl)
 856           && !TREE_PUBLIC (decl)
 857           && !DECL_EXTERNAL (decl)
 858           && !DECL_REGISTER (decl)))
 859     abort ();
 860   /* And that we were not given a type or a label.  */
 861   else if (TREE_CODE (decl) == TYPE_DECL
 862            || TREE_CODE (decl) == LABEL_DECL)
 863     abort ();
 864
 865   /* For a duplicate declaration, we can be called twice on the
 866      same DECL node.  Don't discard the RTL already made.  */
 867   if (DECL_RTL_SET_P (decl))
 868     {
 869       /* If the old RTL had the wrong mode, fix the mode.  */
 870       if (GET_MODE (DECL_RTL (decl)) != DECL_MODE (decl))
 871         SET_DECL_RTL (decl, adjust_address_nv (DECL_RTL (decl),
 872                                                DECL_MODE (decl), 0));
 873
 874       if (TREE_CODE (decl) != FUNCTION_DECL && DECL_REGISTER (decl))
 875         return;
 876
 877       /* ??? Another way to do this would be to maintain a hashed
 878          table of such critters.  Instead of adding stuff to a DECL
 879          to give certain attributes to it, we could use an external
 880          hash map from DECL to set of attributes.  */
 881
 882       /* Let the target reassign the RTL if it wants.
 883          This is necessary, for example, when one machine specific
 884          decl attribute overrides another.  */
 885       targetm.encode_section_info (decl, DECL_RTL (decl), false);
 886
 887       /* Make this function static known to the mudflap runtime.  */
 888       if (flag_mudflap && TREE_CODE (decl) == VAR_DECL)
 889         mudflap_enqueue_decl (decl);
 890
 891       return;
 892     }
 893
 894   name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
 895
 896   reg_number = decode_reg_name (name);
 897
 898   if (TREE_CODE (decl) != FUNCTION_DECL && DECL_REGISTER (decl))
 899     {
 900       /* First detect errors in declaring global registers.  */
 901       if (reg_number == -1)
 902         error ("%Jregister name not specified for %qD", decl, decl);
 903       else if (reg_number < 0)
 904         error ("%Jinvalid register name for %qD", decl, decl);
 905       else if (TYPE_MODE (TREE_TYPE (decl)) == BLKmode)
 906         error ("%Jdata type of %qD isn%'t suitable for a register",
 907                decl, decl);
 908       else if (! HARD_REGNO_MODE_OK (reg_number, TYPE_MODE (TREE_TYPE (decl))))
 909         error ("%Jregister specified for %qD isn%'t suitable for data type",
 910                decl, decl);
 911       /* Now handle properly declared static register variables.  */
 912       else
 913         {
 914           int nregs;
 915
 916           if (DECL_INITIAL (decl) != 0 && TREE_STATIC (decl))
 917             {
 918               DECL_INITIAL (decl) = 0;
 919               error ("global register variable has initial value");
 920             }
 921           if (TREE_THIS_VOLATILE (decl))
 922             warning ("volatile register variables don%'t "
 923                      "work as you might wish");
 924
 925           /* If the user specified one of the eliminables registers here,
 926              e.g., FRAME_POINTER_REGNUM, we don't want to get this variable
 927              confused with that register and be eliminated.  This usage is
 928              somewhat suspect...  */
 929
 930           SET_DECL_RTL (decl, gen_rtx_raw_REG (DECL_MODE (decl), reg_number));
 931           ORIGINAL_REGNO (DECL_RTL (decl)) = reg_number;
 932           REG_USERVAR_P (DECL_RTL (decl)) = 1;
 933
 934           if (TREE_STATIC (decl))
 935             {
 936               /* Make this register global, so not usable for anything
 937                  else.  */
 938 #ifdef ASM_DECLARE_REGISTER_GLOBAL
 939               ASM_DECLARE_REGISTER_GLOBAL (asm_out_file, decl, reg_number, name);
 940 #endif
 941               nregs = hard_regno_nregs[reg_number][DECL_MODE (decl)];
 942               while (nregs > 0)
 943                 globalize_reg (reg_number + --nregs);
 944             }
 945
 946           /* As a register variable, it has no section.  */
 947           return;
 948         }
 949     }
 950
 951   /* Now handle ordinary static variables and functions (in memory).
 952      Also handle vars declared register invalidly.  */
 953
 954   if (name[0] == '*' && (reg_number >= 0 || reg_number == -3))
 955     error ("%Jregister name given for non-register variable %qD", decl, decl);
 956
 957   /* Specifying a section attribute on a variable forces it into a
 958      non-.bss section, and thus it cannot be common.  */
 959   if (TREE_CODE (decl) == VAR_DECL
 960       && DECL_SECTION_NAME (decl) != NULL_TREE
 961       && DECL_INITIAL (decl) == NULL_TREE
 962       && DECL_COMMON (decl))
 963     DECL_COMMON (decl) = 0;
 964
 965   /* Variables can't be both common and weak.  */
 966   if (TREE_CODE (decl) == VAR_DECL && DECL_WEAK (decl))
 967     DECL_COMMON (decl) = 0;
 968
 969   x = gen_rtx_SYMBOL_REF (Pmode, name);
 970   SYMBOL_REF_WEAK (x) = DECL_WEAK (decl);
 971   SYMBOL_REF_DECL (x) = decl;
 972
 973   x = gen_rtx_MEM (DECL_MODE (decl), x);
 974   if (TREE_CODE (decl) != FUNCTION_DECL)
 975     set_mem_attributes (x, decl, 1);
 976   SET_DECL_RTL (decl, x);
 977
 978   /* Optionally set flags or add text to the name to record information
 979      such as that it is a function name.
 980      If the name is changed, the macro ASM_OUTPUT_LABELREF
 981      will have to know how to strip this information.  */
 982   targetm.encode_section_info (decl, DECL_RTL (decl), true);
 983
 984   /* Make this function static known to the mudflap runtime.  */
 985   if (flag_mudflap && TREE_CODE (decl) == VAR_DECL)
 986     mudflap_enqueue_decl (decl);
 987 }
 988
 989 /* Make the rtl for variable VAR be volatile.
 990    Use this only for static variables.  */
 991
 992 void
 993 make_var_volatile (tree var)
 994 {
 995   if (!MEM_P (DECL_RTL (var)))
 996     abort ();
 997
 998   MEM_VOLATILE_P (DECL_RTL (var)) = 1;
 999 }
1000 \f
1001 /* Output a string of literal assembler code
1002    for an `asm' keyword used between functions.  */
1003
1004 void
1005 assemble_asm (tree string)
1006 {
1007   app_enable ();
1008
1009   if (TREE_CODE (string) == ADDR_EXPR)
1010     string = TREE_OPERAND (string, 0);
1011
1012   fprintf (asm_out_file, "\t%s\n", TREE_STRING_POINTER (string));
1013 }
1014
1015 /* Record an element in the table of global destructors.  SYMBOL is
1016    a SYMBOL_REF of the function to be called; PRIORITY is a number
1017    between 0 and MAX_INIT_PRIORITY.  */
1018
1019 void
1020 default_stabs_asm_out_destructor (rtx symbol, int priority ATTRIBUTE_UNUSED)
1021 {
1022 #if defined DBX_DEBUGGING_INFO || defined XCOFF_DEBUGGING_INFO
1023   /* Tell GNU LD that this is part of the static destructor set.
1024      This will work for any system that uses stabs, most usefully
1025      aout systems.  */
1026   dbxout_begin_simple_stabs ("___DTOR_LIST__", 22 /* N_SETT */);
1027   dbxout_stab_value_label (XSTR (symbol, 0));
1028 #else
1029   sorry ("global destructors not supported on this target");
1030 #endif
1031 }
1032
1033 void
1034 default_named_section_asm_out_destructor (rtx symbol, int priority)
1035 {
1036   const char *section = ".dtors";
1037   char buf[16];
1038
1039   /* ??? This only works reliably with the GNU linker.  */
1040   if (priority != DEFAULT_INIT_PRIORITY)
1041     {
1042       sprintf (buf, ".dtors.%.5u",
1043                /* Invert the numbering so the linker puts us in the proper
1044                   order; constructors are run from right to left, and the
1045                   linker sorts in increasing order.  */
1046                MAX_INIT_PRIORITY - priority);
1047       section = buf;
1048     }
1049
1050   named_section_flags (section, SECTION_WRITE);
1051   assemble_align (POINTER_SIZE);
1052   assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1053 }
1054
1055 #ifdef DTORS_SECTION_ASM_OP
1056 void
1057 dtors_section (void)
1058 {
1059   if (in_section != in_dtors)
1060     {
1061       in_section = in_dtors;
1062       fputs (DTORS_SECTION_ASM_OP, asm_out_file);
1063       fputc ('\n', asm_out_file);
1064     }
1065 }
1066
1067 void
1068 default_dtor_section_asm_out_destructor (rtx symbol,
1069                                          int priority ATTRIBUTE_UNUSED)
1070 {
1071   dtors_section ();
1072   assemble_align (POINTER_SIZE);
1073   assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1074 }
1075 #endif
1076
1077 /* Likewise for global constructors.  */
1078
1079 void
1080 default_stabs_asm_out_constructor (rtx symbol, int priority ATTRIBUTE_UNUSED)
1081 {
1082 #if defined DBX_DEBUGGING_INFO || defined XCOFF_DEBUGGING_INFO
1083   /* Tell GNU LD that this is part of the static destructor set.
1084      This will work for any system that uses stabs, most usefully
1085      aout systems.  */
1086   dbxout_begin_simple_stabs ("___CTOR_LIST__", 22 /* N_SETT */);
1087   dbxout_stab_value_label (XSTR (symbol, 0));
1088 #else
1089   sorry ("global constructors not supported on this target");
1090 #endif
1091 }
1092
1093 void
1094 default_named_section_asm_out_constructor (rtx symbol, int priority)
1095 {
1096   const char *section = ".ctors";
1097   char buf[16];
1098
1099   /* ??? This only works reliably with the GNU linker.  */
1100   if (priority != DEFAULT_INIT_PRIORITY)
1101     {
1102       sprintf (buf, ".ctors.%.5u",
1103                /* Invert the numbering so the linker puts us in the proper
1104                   order; constructors are run from right to left, and the
1105                   linker sorts in increasing order.  */
1106                MAX_INIT_PRIORITY - priority);
1107       section = buf;
1108     }
1109
1110   named_section_flags (section, SECTION_WRITE);
1111   assemble_align (POINTER_SIZE);
1112   assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1113 }
1114
1115 #ifdef CTORS_SECTION_ASM_OP
1116 void
1117 ctors_section (void)
1118 {
1119   if (in_section != in_ctors)
1120     {
1121       in_section = in_ctors;
1122       fputs (CTORS_SECTION_ASM_OP, asm_out_file);
1123       fputc ('\n', asm_out_file);
1124     }
1125 }
1126
1127 void
1128 default_ctor_section_asm_out_constructor (rtx symbol,
1129                                           int priority ATTRIBUTE_UNUSED)
1130 {
1131   ctors_section ();
1132   assemble_align (POINTER_SIZE);
1133   assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1134 }
1135 #endif
1136 \f
1137 /* CONSTANT_POOL_BEFORE_FUNCTION may be defined as an expression with
1138    a nonzero value if the constant pool should be output before the
1139    start of the function, or a zero value if the pool should output
1140    after the end of the function.  The default is to put it before the
1141    start.  */
1142
1143 #ifndef CONSTANT_POOL_BEFORE_FUNCTION
1144 #define CONSTANT_POOL_BEFORE_FUNCTION 1
1145 #endif
1146
1147 /* DECL is an object (either VAR_DECL or FUNCTION_DECL) which is going
1148    to be output to assembler.
1149    Set first_global_object_name and weak_global_object_name as appropriate.  */
1150
1151 void
1152 notice_global_symbol (tree decl)
1153 {
1154   const char **type = &first_global_object_name;
1155
1156   if (first_global_object_name
1157       || !TREE_PUBLIC (decl) || DECL_EXTERNAL (decl)
1158       || !DECL_NAME (decl)
1159       || (TREE_CODE (decl) != FUNCTION_DECL
1160           && (TREE_CODE (decl) != VAR_DECL
1161               || (DECL_COMMON (decl)
1162                   && (DECL_INITIAL (decl) == 0
1163                       || DECL_INITIAL (decl) == error_mark_node))))
1164       || !MEM_P (DECL_RTL (decl)))
1165     return;
1166
1167   /* We win when global object is found, but it is useful to know about weak
1168      symbol as well so we can produce nicer unique names.  */
1169   if (DECL_WEAK (decl) || DECL_ONE_ONLY (decl))
1170     type = &weak_global_object_name;
1171
1172   if (!*type)
1173     {
1174       const char *p;
1175       char *name;
1176       rtx decl_rtl = DECL_RTL (decl);
1177
1178       p = targetm.strip_name_encoding (XSTR (XEXP (decl_rtl, 0), 0));
1179       name = xstrdup (p);
1180
1181       *type = name;
1182     }
1183 }
1184
1185 /* Output assembler code for the constant pool of a function and associated
1186    with defining the name of the function.  DECL describes the function.
1187    NAME is the function's name.  For the constant pool, we use the current
1188    constant pool data.  */
1189
1190 void
1191 assemble_start_function (tree decl, const char *fnname)
1192 {
1193   int align;
1194
1195   if (unlikely_text_section_name)
1196     free (unlikely_text_section_name);
1197
1198   unlikely_section_label_printed = false;
1199   unlikely_text_section_name = NULL;
1200
1201   unlikely_section_label = reconcat (unlikely_section_label,
1202                                      fnname, ".unlikely_section", NULL);
1203
1204   /* The following code does not need preprocessing in the assembler.  */
1205
1206   app_disable ();
1207
1208   if (CONSTANT_POOL_BEFORE_FUNCTION)
1209     output_constant_pool (fnname, decl);
1210
1211   /* Make sure the cold text (code) section is properly aligned.  This
1212      is necessary here in the case where the function has both hot and
1213      cold sections, because we don't want to re-set the alignment when the
1214      section switch happens mid-function.  We don't need to set the hot
1215      section alignment here, because code further down in this function
1216      sets the alignment for whichever section comes first, and if there
1217      is a hot section it is guaranteed to be first.  */
1218
1219   if (flag_reorder_blocks_and_partition)
1220     {
1221       unlikely_text_section ();
1222       assemble_align (FUNCTION_BOUNDARY);
1223     }
1224
1225   resolve_unique_section (decl, 0, flag_function_sections);
1226   function_section (decl);
1227
1228   /* Tell assembler to move to target machine's alignment for functions.  */
1229   align = floor_log2 (FUNCTION_BOUNDARY / BITS_PER_UNIT);
1230   if (align < force_align_functions_log)
1231     align = force_align_functions_log;
1232   if (align > 0)
1233     {
1234       ASM_OUTPUT_ALIGN (asm_out_file, align);
1235     }
1236
1237   /* Handle a user-specified function alignment.
1238      Note that we still need to align to FUNCTION_BOUNDARY, as above,
1239      because ASM_OUTPUT_MAX_SKIP_ALIGN might not do any alignment at all.  */
1240   if (align_functions_log > align
1241       && cfun->function_frequency != FUNCTION_FREQUENCY_UNLIKELY_EXECUTED)
1242     {
1243 #ifdef ASM_OUTPUT_MAX_SKIP_ALIGN
1244       ASM_OUTPUT_MAX_SKIP_ALIGN (asm_out_file,
1245                                  align_functions_log, align_functions - 1);
1246 #else
1247       ASM_OUTPUT_ALIGN (asm_out_file, align_functions_log);
1248 #endif
1249     }
1250
1251 #ifdef ASM_OUTPUT_FUNCTION_PREFIX
1252   ASM_OUTPUT_FUNCTION_PREFIX (asm_out_file, fnname);
1253 #endif
1254
1255   (*debug_hooks->begin_function) (decl);
1256
1257   /* Make function name accessible from other files, if appropriate.  */
1258
1259   if (TREE_PUBLIC (decl))
1260     {
1261       notice_global_symbol (decl);
1262
1263       globalize_decl (decl);
1264
1265       maybe_assemble_visibility (decl);
1266     }
1267
1268   if (DECL_PRESERVE_P (decl))
1269     targetm.asm_out.mark_decl_preserved (fnname);
1270
1271   /* Do any machine/system dependent processing of the function name.  */
1272 #ifdef ASM_DECLARE_FUNCTION_NAME
1273   ASM_DECLARE_FUNCTION_NAME (asm_out_file, fnname, current_function_decl);
1274 #else
1275   /* Standard thing is just output label for the function.  */
1276   ASM_OUTPUT_LABEL (asm_out_file, fnname);
1277 #endif /* ASM_DECLARE_FUNCTION_NAME */
1278
1279   if (in_unlikely_text_section ()
1280       && !unlikely_section_label_printed)
1281     {
1282       ASM_OUTPUT_LABEL (asm_out_file, unlikely_section_label);
1283       unlikely_section_label_printed = true;
1284     }
1285 }
1286
1287 /* Output assembler code associated with defining the size of the
1288    function.  DECL describes the function.  NAME is the function's name.  */
1289
1290 void
1291 assemble_end_function (tree decl, const char *fnname)
1292 {
1293 #ifdef ASM_DECLARE_FUNCTION_SIZE
1294   ASM_DECLARE_FUNCTION_SIZE (asm_out_file, fnname, decl);
1295 #endif
1296   if (! CONSTANT_POOL_BEFORE_FUNCTION)
1297     {
1298       output_constant_pool (fnname, decl);
1299       function_section (decl);  /* need to switch back */
1300     }
1301 }
1302 \f
1303 /* Assemble code to leave SIZE bytes of zeros.  */
1304
1305 void
1306 assemble_zeros (unsigned HOST_WIDE_INT size)
1307 {
1308   /* Do no output if -fsyntax-only.  */
1309   if (flag_syntax_only)
1310     return;
1311
1312 #ifdef ASM_NO_SKIP_IN_TEXT
1313   /* The `space' pseudo in the text section outputs nop insns rather than 0s,
1314      so we must output 0s explicitly in the text section.  */
1315   if ((ASM_NO_SKIP_IN_TEXT && in_text_section ())
1316       || (ASM_NO_SKIP_IN_TEXT && in_unlikely_text_section ()))
1317     {
1318       unsigned HOST_WIDE_INT i;
1319       for (i = 0; i < size; i++)
1320         assemble_integer (const0_rtx, 1, BITS_PER_UNIT, 1);
1321     }
1322   else
1323 #endif
1324     if (size > 0)
1325       ASM_OUTPUT_SKIP (asm_out_file, size);
1326 }
1327
1328 /* Assemble an alignment pseudo op for an ALIGN-bit boundary.  */
1329
1330 void
1331 assemble_align (int align)
1332 {
1333   if (align > BITS_PER_UNIT)
1334     {
1335       ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
1336     }
1337 }
1338
1339 /* Assemble a string constant with the specified C string as contents.  */
1340
1341 void
1342 assemble_string (const char *p, int size)
1343 {
1344   int pos = 0;
1345   int maximum = 2000;
1346
1347   /* If the string is very long, split it up.  */
1348
1349   while (pos < size)
1350     {
1351       int thissize = size - pos;
1352       if (thissize > maximum)
1353         thissize = maximum;
1354
1355       ASM_OUTPUT_ASCII (asm_out_file, p, thissize);
1356
1357       pos += thissize;
1358       p += thissize;
1359     }
1360 }
1361
1362 \f
1363 #if defined  ASM_OUTPUT_ALIGNED_DECL_LOCAL
1364 #define ASM_EMIT_LOCAL(decl, name, size, rounded) \
1365   ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file, decl, name, size, DECL_ALIGN (decl))
1366 #else
1367 #if defined  ASM_OUTPUT_ALIGNED_LOCAL
1368 #define ASM_EMIT_LOCAL(decl, name, size, rounded) \
1369   ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, DECL_ALIGN (decl))
1370 #else
1371 #define ASM_EMIT_LOCAL(decl, name, size, rounded) \
1372   ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded)
1373 #endif
1374 #endif
1375
1376 #if defined ASM_OUTPUT_ALIGNED_BSS
1377 #define ASM_EMIT_BSS(decl, name, size, rounded) \
1378   ASM_OUTPUT_ALIGNED_BSS (asm_out_file, decl, name, size, DECL_ALIGN (decl))
1379 #else
1380 #if defined ASM_OUTPUT_BSS
1381 #define ASM_EMIT_BSS(decl, name, size, rounded) \
1382   ASM_OUTPUT_BSS (asm_out_file, decl, name, size, rounded)
1383 #else
1384 #undef  ASM_EMIT_BSS
1385 #endif
1386 #endif
1387
1388 #if defined ASM_OUTPUT_ALIGNED_DECL_COMMON
1389 #define ASM_EMIT_COMMON(decl, name, size, rounded) \
1390   ASM_OUTPUT_ALIGNED_DECL_COMMON (asm_out_file, decl, name, size, DECL_ALIGN (decl))
1391 #else
1392 #if defined ASM_OUTPUT_ALIGNED_COMMON
1393 #define ASM_EMIT_COMMON(decl, name, size, rounded) \
1394   ASM_OUTPUT_ALIGNED_COMMON (asm_out_file, name, size, DECL_ALIGN (decl))
1395 #else
1396 #define ASM_EMIT_COMMON(decl, name, size, rounded) \
1397   ASM_OUTPUT_COMMON (asm_out_file, name, size, rounded)
1398 #endif
1399 #endif
1400
1401 static bool
1402 asm_emit_uninitialised (tree decl, const char *name,
1403                         unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED,
1404                         unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED)
1405 {
1406   enum
1407   {
1408     asm_dest_common,
1409     asm_dest_bss,
1410     asm_dest_local
1411   }
1412   destination = asm_dest_local;
1413
1414   /* ??? We should handle .bss via select_section mechanisms rather than
1415      via special target hooks.  That would eliminate this special case.  */
1416   if (TREE_PUBLIC (decl))
1417     {
1418       if (!DECL_COMMON (decl))
1419 #ifdef ASM_EMIT_BSS
1420         destination = asm_dest_bss;
1421 #else
1422         return false;
1423 #endif
1424       else
1425         destination = asm_dest_common;
1426     }
1427
1428   if (destination == asm_dest_bss)
1429     globalize_decl (decl);
1430   resolve_unique_section (decl, 0, flag_data_sections);
1431
1432   if (flag_shared_data)
1433     {
1434       switch (destination)
1435         {
1436 #ifdef ASM_OUTPUT_SHARED_BSS
1437         case asm_dest_bss:
1438           ASM_OUTPUT_SHARED_BSS (asm_out_file, decl, name, size, rounded);
1439           return;
1440 #endif
1441 #ifdef ASM_OUTPUT_SHARED_COMMON
1442         case asm_dest_common:
1443           ASM_OUTPUT_SHARED_COMMON (asm_out_file, name, size, rounded);
1444           return;
1445 #endif
1446 #ifdef ASM_OUTPUT_SHARED_LOCAL
1447         case asm_dest_local:
1448           ASM_OUTPUT_SHARED_LOCAL (asm_out_file, name, size, rounded);
1449           return;
1450 #endif
1451         default:
1452           break;
1453         }
1454     }
1455
1456   switch (destination)
1457     {
1458 #ifdef ASM_EMIT_BSS
1459     case asm_dest_bss:
1460       ASM_EMIT_BSS (decl, name, size, rounded);
1461       break;
1462 #endif
1463     case asm_dest_common:
1464       ASM_EMIT_COMMON (decl, name, size, rounded);
1465       break;
1466     case asm_dest_local:
1467       ASM_EMIT_LOCAL (decl, name, size, rounded);
1468       break;
1469     default:
1470       abort ();
1471     }
1472
1473   return true;
1474 }
1475
1476 /* Assemble everything that is needed for a variable or function declaration.
1477    Not used for automatic variables, and not used for function definitions.
1478    Should not be called for variables of incomplete structure type.
1479
1480    TOP_LEVEL is nonzero if this variable has file scope.
1481    AT_END is nonzero if this is the special handling, at end of compilation,
1482    to define things that have had only tentative definitions.
1483    DONT_OUTPUT_DATA if nonzero means don't actually output the
1484    initial value (that will be done by the caller).  */
1485
1486 void
1487 assemble_variable (tree decl, int top_level ATTRIBUTE_UNUSED,
1488                    int at_end ATTRIBUTE_UNUSED, int dont_output_data)
1489 {
1490   const char *name;
1491   unsigned int align;
1492   int reloc = 0;
1493   rtx decl_rtl;
1494
1495   if (lang_hooks.decls.prepare_assemble_variable)
1496     lang_hooks.decls.prepare_assemble_variable (decl);
1497
1498   last_assemble_variable_decl = 0;
1499
1500   /* Normally no need to say anything here for external references,
1501      since assemble_external is called by the language-specific code
1502      when a declaration is first seen.  */
1503
1504   if (DECL_EXTERNAL (decl))
1505     return;
1506
1507   /* Output no assembler code for a function declaration.
1508      Only definitions of functions output anything.  */
1509
1510   if (TREE_CODE (decl) == FUNCTION_DECL)
1511     return;
1512
1513   /* Do nothing for global register variables.  */
1514   if (DECL_RTL_SET_P (decl) && REG_P (DECL_RTL (decl)))
1515     {
1516       TREE_ASM_WRITTEN (decl) = 1;
1517       return;
1518     }
1519
1520   /* If type was incomplete when the variable was declared,
1521      see if it is complete now.  */
1522
1523   if (DECL_SIZE (decl) == 0)
1524     layout_decl (decl, 0);
1525
1526   /* Still incomplete => don't allocate it; treat the tentative defn
1527      (which is what it must have been) as an `extern' reference.  */
1528
1529   if (!dont_output_data && DECL_SIZE (decl) == 0)
1530     {
1531       error ("%Jstorage size of %qD isn%'t known", decl, decl);
1532       TREE_ASM_WRITTEN (decl) = 1;
1533       return;
1534     }
1535
1536   /* The first declaration of a variable that comes through this function
1537      decides whether it is global (in C, has external linkage)
1538      or local (in C, has internal linkage).  So do nothing more
1539      if this function has already run.  */
1540
1541   if (TREE_ASM_WRITTEN (decl))
1542     return;
1543
1544   /* Make sure targetm.encode_section_info is invoked before we set
1545      ASM_WRITTEN.  */
1546   decl_rtl = DECL_RTL (decl);
1547
1548   TREE_ASM_WRITTEN (decl) = 1;
1549
1550   /* Do no output if -fsyntax-only.  */
1551   if (flag_syntax_only)
1552     return;
1553
1554   app_disable ();
1555
1556   if (! dont_output_data
1557       && ! host_integerp (DECL_SIZE_UNIT (decl), 1))
1558     {
1559       error ("%Jsize of variable %qD is too large", decl, decl);
1560       return;
1561     }
1562
1563   name = XSTR (XEXP (decl_rtl, 0), 0);
1564   if (TREE_PUBLIC (decl) && DECL_NAME (decl))
1565     notice_global_symbol (decl);
1566
1567   /* Compute the alignment of this data.  */
1568
1569   align = DECL_ALIGN (decl);
1570
1571   /* In the case for initialing an array whose length isn't specified,
1572      where we have not yet been able to do the layout,
1573      figure out the proper alignment now.  */
1574   if (dont_output_data && DECL_SIZE (decl) == 0
1575       && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
1576     align = MAX (align, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (decl))));
1577
1578   /* Some object file formats have a maximum alignment which they support.
1579      In particular, a.out format supports a maximum alignment of 4.  */
1580   if (align > MAX_OFILE_ALIGNMENT)
1581     {
1582       warning ("%Jalignment of %qD is greater than maximum object "
1583                "file alignment.  Using %d", decl, decl,
1584                MAX_OFILE_ALIGNMENT/BITS_PER_UNIT);
1585       align = MAX_OFILE_ALIGNMENT;
1586     }
1587
1588   /* On some machines, it is good to increase alignment sometimes.  */
1589   if (! DECL_USER_ALIGN (decl))
1590     {
1591 #ifdef DATA_ALIGNMENT
1592       align = DATA_ALIGNMENT (TREE_TYPE (decl), align);
1593 #endif
1594 #ifdef CONSTANT_ALIGNMENT
1595       if (DECL_INITIAL (decl) != 0 && DECL_INITIAL (decl) != error_mark_node)
1596         align = CONSTANT_ALIGNMENT (DECL_INITIAL (decl), align);
1597 #endif
1598     }
1599
1600   /* Reset the alignment in case we have made it tighter, so we can benefit
1601      from it in get_pointer_alignment.  */
1602   DECL_ALIGN (decl) = align;
1603   set_mem_align (decl_rtl, align);
1604
1605   if (TREE_PUBLIC (decl))
1606     maybe_assemble_visibility (decl);
1607
1608   if (DECL_PRESERVE_P (decl))
1609     targetm.asm_out.mark_decl_preserved (name);
1610
1611   /* Output any data that we will need to use the address of.  */
1612   if (DECL_INITIAL (decl) == error_mark_node)
1613     reloc = contains_pointers_p (TREE_TYPE (decl)) ? 3 : 0;
1614   else if (DECL_INITIAL (decl))
1615     {
1616       reloc = compute_reloc_for_constant (DECL_INITIAL (decl));
1617       output_addressed_constants (DECL_INITIAL (decl));
1618     }
1619   resolve_unique_section (decl, reloc, flag_data_sections);
1620
1621   /* Handle uninitialized definitions.  */
1622
1623   /* If the decl has been given an explicit section name, then it
1624      isn't common, and shouldn't be handled as such.  */
1625   if (DECL_SECTION_NAME (decl) || dont_output_data)
1626     ;
1627   /* We don't implement common thread-local data at present.  */
1628   else if (DECL_THREAD_LOCAL (decl))
1629     {
1630       if (DECL_COMMON (decl))
1631         sorry ("thread-local COMMON data not implemented");
1632     }
1633   else if (DECL_INITIAL (decl) == 0
1634            || DECL_INITIAL (decl) == error_mark_node
1635            || (flag_zero_initialized_in_bss
1636                /* Leave constant zeroes in .rodata so they can be shared.  */
1637                && !TREE_READONLY (decl)
1638                && initializer_zerop (DECL_INITIAL (decl))))
1639     {
1640       unsigned HOST_WIDE_INT size = tree_low_cst (DECL_SIZE_UNIT (decl), 1);
1641       unsigned HOST_WIDE_INT rounded = size;
1642
1643       /* Don't allocate zero bytes of common,
1644          since that means "undefined external" in the linker.  */
1645       if (size == 0)
1646         rounded = 1;
1647
1648       /* Round size up to multiple of BIGGEST_ALIGNMENT bits
1649          so that each uninitialized object starts on such a boundary.  */
1650       rounded += (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1;
1651       rounded = (rounded / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
1652                  * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
1653
1654 #if !defined(ASM_OUTPUT_ALIGNED_COMMON) && !defined(ASM_OUTPUT_ALIGNED_DECL_COMMON) && !defined(ASM_OUTPUT_ALIGNED_BSS)
1655       if ((unsigned HOST_WIDE_INT) DECL_ALIGN_UNIT (decl) > rounded)
1656         warning ("%Jrequested alignment for %qD is greater than "
1657                  "implemented alignment of %d", decl, decl, rounded);
1658 #endif
1659
1660       /* If the target cannot output uninitialized but not common global data
1661          in .bss, then we have to use .data, so fall through.  */
1662       if (asm_emit_uninitialised (decl, name, size, rounded))
1663         return;
1664     }
1665
1666   /* Handle initialized definitions.
1667      Also handle uninitialized global definitions if -fno-common and the
1668      target doesn't support ASM_OUTPUT_BSS.  */
1669
1670   /* First make the assembler name(s) global if appropriate.  */
1671   if (TREE_PUBLIC (decl) && DECL_NAME (decl))
1672     globalize_decl (decl);
1673
1674   /* Switch to the appropriate section.  */
1675   variable_section (decl, reloc);
1676
1677   /* dbxout.c needs to know this.  */
1678   if (in_text_section () || in_unlikely_text_section ())
1679     DECL_IN_TEXT_SECTION (decl) = 1;
1680
1681   /* Output the alignment of this data.  */
1682   if (align > BITS_PER_UNIT)
1683     ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (DECL_ALIGN_UNIT (decl)));
1684
1685   /* Do any machine/system dependent processing of the object.  */
1686 #ifdef ASM_DECLARE_OBJECT_NAME
1687   last_assemble_variable_decl = decl;
1688   ASM_DECLARE_OBJECT_NAME (asm_out_file, name, decl);
1689 #else
1690   /* Standard thing is just output label for the object.  */
1691   ASM_OUTPUT_LABEL (asm_out_file, name);
1692 #endif /* ASM_DECLARE_OBJECT_NAME */
1693
1694   if (!dont_output_data)
1695     {
1696       if (DECL_INITIAL (decl)
1697           && DECL_INITIAL (decl) != error_mark_node
1698           && !initializer_zerop (DECL_INITIAL (decl)))
1699         /* Output the actual data.  */
1700         output_constant (DECL_INITIAL (decl),
1701                          tree_low_cst (DECL_SIZE_UNIT (decl), 1),
1702                          align);
1703       else
1704         /* Leave space for it.  */
1705         assemble_zeros (tree_low_cst (DECL_SIZE_UNIT (decl), 1));
1706     }
1707 }
1708
1709 /* Return 1 if type TYPE contains any pointers.  */
1710
1711 static int
1712 contains_pointers_p (tree type)
1713 {
1714   switch (TREE_CODE (type))
1715     {
1716     case POINTER_TYPE:
1717     case REFERENCE_TYPE:
1718       /* I'm not sure whether OFFSET_TYPE needs this treatment,
1719          so I'll play safe and return 1.  */
1720     case OFFSET_TYPE:
1721       return 1;
1722
1723     case RECORD_TYPE:
1724     case UNION_TYPE:
1725     case QUAL_UNION_TYPE:
1726       {
1727         tree fields;
1728         /* For a type that has fields, see if the fields have pointers.  */
1729         for (fields = TYPE_FIELDS (type); fields; fields = TREE_CHAIN (fields))
1730           if (TREE_CODE (fields) == FIELD_DECL
1731               && contains_pointers_p (TREE_TYPE (fields)))
1732             return 1;
1733         return 0;
1734       }
1735
1736     case ARRAY_TYPE:
1737       /* An array type contains pointers if its element type does.  */
1738       return contains_pointers_p (TREE_TYPE (type));
1739
1740     default:
1741       return 0;
1742     }
1743 }
1744
1745 #ifdef ASM_OUTPUT_EXTERNAL
1746 /* True if DECL is a function decl for which no out-of-line copy exists.
1747    It is assumed that DECL's assembler name has been set.  */
1748
1749 static bool
1750 incorporeal_function_p (tree decl)
1751 {
1752   if (TREE_CODE (decl) == FUNCTION_DECL && DECL_BUILT_IN (decl))
1753     {
1754       const char *name;
1755
1756       if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
1757           && DECL_FUNCTION_CODE (decl) == BUILT_IN_ALLOCA)
1758         return true;
1759
1760       name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
1761       if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
1762         return true;
1763     }
1764   return false;
1765 }
1766 #endif
1767
1768 /* Output something to declare an external symbol to the assembler.
1769    (Most assemblers don't need this, so we normally output nothing.)
1770    Do nothing if DECL is not external.  */
1771
1772 void
1773 assemble_external (tree decl ATTRIBUTE_UNUSED)
1774 {
1775   /* Because most platforms do not define ASM_OUTPUT_EXTERNAL, the
1776      main body of this code is only rarely exercised.  To provide some
1777      testing, on all platforms, we make sure that the ASM_OUT_FILE is
1778      open.  If it's not, we should not be calling this function.  */
1779   if (!asm_out_file)
1780     abort ();
1781
1782 #ifdef ASM_OUTPUT_EXTERNAL
1783   if (DECL_P (decl) && DECL_EXTERNAL (decl) && TREE_PUBLIC (decl))
1784     {
1785       rtx rtl = DECL_RTL (decl);
1786
1787       if (MEM_P (rtl) && GET_CODE (XEXP (rtl, 0)) == SYMBOL_REF
1788           && !SYMBOL_REF_USED (XEXP (rtl, 0))
1789           && !incorporeal_function_p (decl))
1790         {
1791           /* Some systems do require some output.  */
1792           SYMBOL_REF_USED (XEXP (rtl, 0)) = 1;
1793           ASM_OUTPUT_EXTERNAL (asm_out_file, decl, XSTR (XEXP (rtl, 0), 0));
1794         }
1795     }
1796 #endif
1797 }
1798
1799 /* Similar, for calling a library function FUN.  */
1800
1801 void
1802 assemble_external_libcall (rtx fun)
1803 {
1804   /* Declare library function name external when first used, if nec.  */
1805   if (! SYMBOL_REF_USED (fun))
1806     {
1807       SYMBOL_REF_USED (fun) = 1;
1808       targetm.asm_out.external_libcall (fun);
1809     }
1810 }
1811
1812 /* Assemble a label named NAME.  */
1813
1814 void
1815 assemble_label (const char *name)
1816 {
1817   ASM_OUTPUT_LABEL (asm_out_file, name);
1818 }
1819
1820 /* Set the symbol_referenced flag for ID.  */
1821 void
1822 mark_referenced (tree id)
1823 {
1824   TREE_SYMBOL_REFERENCED (id) = 1;
1825 }
1826
1827 /* Set the symbol_referenced flag for DECL and notify callgraph.  */
1828 void
1829 mark_decl_referenced (tree decl)
1830 {
1831   if (TREE_CODE (decl) == FUNCTION_DECL)
1832     cgraph_mark_needed_node (cgraph_node (decl));
1833   else if (TREE_CODE (decl) == VAR_DECL)
1834     cgraph_varpool_mark_needed_node (cgraph_varpool_node (decl));
1835   /* else do nothing - we can get various sorts of CST nodes here,
1836      which do not need to be marked.  */
1837 }
1838
1839 /* Output to FILE a reference to the assembler name of a C-level name NAME.
1840    If NAME starts with a *, the rest of NAME is output verbatim.
1841    Otherwise NAME is transformed in an implementation-defined way
1842    (usually by the addition of an underscore).
1843    Many macros in the tm file are defined to call this function.  */
1844
1845 void
1846 assemble_name (FILE *file, const char *name)
1847 {
1848   const char *real_name;
1849   tree id;
1850
1851   real_name = targetm.strip_name_encoding (name);
1852
1853   id = maybe_get_identifier (real_name);
1854   if (id)
1855     mark_referenced (id);
1856
1857   if (name[0] == '*')
1858     fputs (&name[1], file);
1859   else
1860     ASM_OUTPUT_LABELREF (file, name);
1861 }
1862
1863 /* Allocate SIZE bytes writable static space with a gensym name
1864    and return an RTX to refer to its address.  */
1865
1866 rtx
1867 assemble_static_space (unsigned HOST_WIDE_INT size)
1868 {
1869   char name[12];
1870   const char *namestring;
1871   rtx x;
1872
1873 #if 0
1874   if (flag_shared_data)
1875     data_section ();
1876 #endif
1877
1878   ASM_GENERATE_INTERNAL_LABEL (name, "LF", const_labelno);
1879   ++const_labelno;
1880   namestring = ggc_strdup (name);
1881
1882   x = gen_rtx_SYMBOL_REF (Pmode, namestring);
1883   SYMBOL_REF_FLAGS (x) = SYMBOL_FLAG_LOCAL;
1884
1885 #ifdef ASM_OUTPUT_ALIGNED_DECL_LOCAL
1886   ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file, NULL_TREE, name, size,
1887                                  BIGGEST_ALIGNMENT);
1888 #else
1889 #ifdef ASM_OUTPUT_ALIGNED_LOCAL
1890   ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, BIGGEST_ALIGNMENT);
1891 #else
1892   {
1893     /* Round size up to multiple of BIGGEST_ALIGNMENT bits
1894        so that each uninitialized object starts on such a boundary.  */
1895     /* Variable `rounded' might or might not be used in ASM_OUTPUT_LOCAL.  */
1896     unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED
1897       = ((size + (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1)
1898          / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
1899          * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
1900     ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
1901   }
1902 #endif
1903 #endif
1904   return x;
1905 }
1906
1907 /* Assemble the static constant template for function entry trampolines.
1908    This is done at most once per compilation.
1909    Returns an RTX for the address of the template.  */
1910
1911 static GTY(()) rtx initial_trampoline;
1912
1913 #ifdef TRAMPOLINE_TEMPLATE
1914 rtx
1915 assemble_trampoline_template (void)
1916 {
1917   char label[256];
1918   const char *name;
1919   int align;
1920   rtx symbol;
1921
1922   if (initial_trampoline)
1923     return initial_trampoline;
1924
1925   /* By default, put trampoline templates in read-only data section.  */
1926
1927 #ifdef TRAMPOLINE_SECTION
1928   TRAMPOLINE_SECTION ();
1929 #else
1930   readonly_data_section ();
1931 #endif
1932
1933   /* Write the assembler code to define one.  */
1934   align = floor_log2 (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT);
1935   if (align > 0)
1936     {
1937       ASM_OUTPUT_ALIGN (asm_out_file, align);
1938     }
1939
1940   targetm.asm_out.internal_label (asm_out_file, "LTRAMP", 0);
1941   TRAMPOLINE_TEMPLATE (asm_out_file);
1942
1943   /* Record the rtl to refer to it.  */
1944   ASM_GENERATE_INTERNAL_LABEL (label, "LTRAMP", 0);
1945   name = ggc_strdup (label);
1946   symbol = gen_rtx_SYMBOL_REF (Pmode, name);
1947   SYMBOL_REF_FLAGS (symbol) = SYMBOL_FLAG_LOCAL;
1948
1949   initial_trampoline = gen_rtx_MEM (BLKmode, symbol);
1950   set_mem_align (initial_trampoline, TRAMPOLINE_ALIGNMENT);
1951
1952   return initial_trampoline;
1953 }
1954 #endif
1955 \f
1956 /* A and B are either alignments or offsets.  Return the minimum alignment
1957    that may be assumed after adding the two together.  */
1958
1959 static inline unsigned
1960 min_align (unsigned int a, unsigned int b)
1961 {
1962   return (a | b) & -(a | b);
1963 }
1964
1965 /* Return the assembler directive for creating a given kind of integer
1966    object.  SIZE is the number of bytes in the object and ALIGNED_P
1967    indicates whether it is known to be aligned.  Return NULL if the
1968    assembly dialect has no such directive.
1969
1970    The returned string should be printed at the start of a new line and
1971    be followed immediately by the object's initial value.  */
1972
1973 const char *
1974 integer_asm_op (int size, int aligned_p)
1975 {
1976   struct asm_int_op *ops;
1977
1978   if (aligned_p)
1979     ops = &targetm.asm_out.aligned_op;
1980   else
1981     ops = &targetm.asm_out.unaligned_op;
1982
1983   switch (size)
1984     {
1985     case 1:
1986       return targetm.asm_out.byte_op;
1987     case 2:
1988       return ops->hi;
1989     case 4:
1990       return ops->si;
1991     case 8:
1992       return ops->di;
1993     case 16:
1994       return ops->ti;
1995     default:
1996       return NULL;
1997     }
1998 }
1999
2000 /* Use directive OP to assemble an integer object X.  Print OP at the
2001    start of the line, followed immediately by the value of X.  */
2002
2003 void
2004 assemble_integer_with_op (const char *op, rtx x)
2005 {
2006   fputs (op, asm_out_file);
2007   output_addr_const (asm_out_file, x);
2008   fputc ('\n', asm_out_file);
2009 }
2010
2011 /* The default implementation of the asm_out.integer target hook.  */
2012
2013 bool
2014 default_assemble_integer (rtx x ATTRIBUTE_UNUSED,
2015                           unsigned int size ATTRIBUTE_UNUSED,
2016                           int aligned_p ATTRIBUTE_UNUSED)
2017 {
2018   const char *op = integer_asm_op (size, aligned_p);
2019   /* Avoid GAS bugs for values > word size.  */
2020   if (size > UNITS_PER_WORD)
2021     return false;
2022   return op && (assemble_integer_with_op (op, x), true);
2023 }
2024
2025 /* Assemble the integer constant X into an object of SIZE bytes.  ALIGN is
2026    the alignment of the integer in bits.  Return 1 if we were able to output
2027    the constant, otherwise 0.  If FORCE is nonzero, abort if we can't output
2028    the constant.  */
2029
2030 bool
2031 assemble_integer (rtx x, unsigned int size, unsigned int align, int force)
2032 {
2033   int aligned_p;
2034
2035   aligned_p = (align >= MIN (size * BITS_PER_UNIT, BIGGEST_ALIGNMENT));
2036
2037   /* See if the target hook can handle this kind of object.  */
2038   if (targetm.asm_out.integer (x, size, aligned_p))
2039     return true;
2040
2041   /* If the object is a multi-byte one, try splitting it up.  Split
2042      it into words it if is multi-word, otherwise split it into bytes.  */
2043   if (size > 1)
2044     {
2045       enum machine_mode omode, imode;
2046       unsigned int subalign;
2047       unsigned int subsize, i;
2048
2049       subsize = size > UNITS_PER_WORD? UNITS_PER_WORD : 1;
2050       subalign = MIN (align, subsize * BITS_PER_UNIT);
2051       omode = mode_for_size (subsize * BITS_PER_UNIT, MODE_INT, 0);
2052       imode = mode_for_size (size * BITS_PER_UNIT, MODE_INT, 0);
2053
2054       for (i = 0; i < size; i += subsize)
2055         {
2056           rtx partial = simplify_subreg (omode, x, imode, i);
2057           if (!partial || !assemble_integer (partial, subsize, subalign, 0))
2058             break;
2059         }
2060       if (i == size)
2061         return true;
2062
2063       /* If we've printed some of it, but not all of it, there's no going
2064          back now.  */
2065       if (i > 0)
2066         abort ();
2067     }
2068
2069   if (force)
2070     abort ();
2071
2072   return false;
2073 }
2074 \f
2075 void
2076 assemble_real (REAL_VALUE_TYPE d, enum machine_mode mode, unsigned int align)
2077 {
2078   long data[4];
2079   int i;
2080   int bitsize, nelts, nunits, units_per;
2081
2082   /* This is hairy.  We have a quantity of known size.  real_to_target
2083      will put it into an array of *host* longs, 32 bits per element
2084      (even if long is more than 32 bits).  We need to determine the
2085      number of array elements that are occupied (nelts) and the number
2086      of *target* min-addressable units that will be occupied in the
2087      object file (nunits).  We cannot assume that 32 divides the
2088      mode's bitsize (size * BITS_PER_UNIT) evenly.
2089
2090      size * BITS_PER_UNIT is used here to make sure that padding bits
2091      (which might appear at either end of the value; real_to_target
2092      will include the padding bits in its output array) are included.  */
2093
2094   nunits = GET_MODE_SIZE (mode);
2095   bitsize = nunits * BITS_PER_UNIT;
2096   nelts = CEIL (bitsize, 32);
2097   units_per = 32 / BITS_PER_UNIT;
2098
2099   real_to_target (data, &d, mode);
2100
2101   /* Put out the first word with the specified alignment.  */
2102   assemble_integer (GEN_INT (data[0]), MIN (nunits, units_per), align, 1);
2103   nunits -= units_per;
2104
2105   /* Subsequent words need only 32-bit alignment.  */
2106   align = min_align (align, 32);
2107
2108   for (i = 1; i < nelts; i++)
2109     {
2110       assemble_integer (GEN_INT (data[i]), MIN (nunits, units_per), align, 1);
2111       nunits -= units_per;
2112     }
2113 }
2114 \f
2115 /* Given an expression EXP with a constant value,
2116    reduce it to the sum of an assembler symbol and an integer.
2117    Store them both in the structure *VALUE.
2118    Abort if EXP does not reduce.  */
2119
2120 struct addr_const GTY(())
2121 {
2122   rtx base;
2123   HOST_WIDE_INT offset;
2124 };
2125
2126 static void
2127 decode_addr_const (tree exp, struct addr_const *value)
2128 {
2129   tree target = TREE_OPERAND (exp, 0);
2130   int offset = 0;
2131   rtx x;
2132
2133   while (1)
2134     {
2135       if (TREE_CODE (target) == COMPONENT_REF
2136           && host_integerp (byte_position (TREE_OPERAND (target, 1)), 0))
2137
2138         {
2139           offset += int_byte_position (TREE_OPERAND (target, 1));
2140           target = TREE_OPERAND (target, 0);
2141         }
2142       else if (TREE_CODE (target) == ARRAY_REF
2143                || TREE_CODE (target) == ARRAY_RANGE_REF)
2144         {
2145           offset += (tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (target)), 1)
2146                      * tree_low_cst (TREE_OPERAND (target, 1), 0));
2147           target = TREE_OPERAND (target, 0);
2148         }
2149       else
2150         break;
2151     }
2152
2153   switch (TREE_CODE (target))
2154     {
2155     case VAR_DECL:
2156     case FUNCTION_DECL:
2157       x = DECL_RTL (target);
2158       break;
2159
2160     case LABEL_DECL:
2161       x = gen_rtx_MEM (FUNCTION_MODE,
2162                        gen_rtx_LABEL_REF (VOIDmode, force_label_rtx (target)));
2163       break;
2164
2165     case REAL_CST:
2166     case STRING_CST:
2167     case COMPLEX_CST:
2168     case CONSTRUCTOR:
2169     case INTEGER_CST:
2170       x = output_constant_def (target, 1);
2171       break;
2172
2173     default:
2174       abort ();
2175     }
2176
2177   if (!MEM_P (x))
2178     abort ();
2179   x = XEXP (x, 0);
2180
2181   value->base = x;
2182   value->offset = offset;
2183 }
2184 \f
2185 /* Uniquize all constants that appear in memory.
2186    Each constant in memory thus far output is recorded
2187    in `const_desc_table'.  */
2188
2189 struct constant_descriptor_tree GTY(())
2190 {
2191   /* A MEM for the constant.  */
2192   rtx rtl;
2193
2194   /* The value of the constant.  */
2195   tree value;
2196 };
2197
2198 static GTY((param_is (struct constant_descriptor_tree)))
2199      htab_t const_desc_htab;
2200
2201 static struct constant_descriptor_tree * build_constant_desc (tree);
2202 static void maybe_output_constant_def_contents (struct constant_descriptor_tree *, int);
2203
2204 /* Compute a hash code for a constant expression.  */
2205
2206 static hashval_t
2207 const_desc_hash (const void *ptr)
2208 {
2209   return const_hash_1 (((struct constant_descriptor_tree *)ptr)->value);
2210 }
2211
2212 static hashval_t
2213 const_hash_1 (const tree exp)
2214 {
2215   const char *p;
2216   hashval_t hi;
2217   int len, i;
2218   enum tree_code code = TREE_CODE (exp);
2219
2220   /* Either set P and LEN to the address and len of something to hash and
2221      exit the switch or return a value.  */
2222
2223   switch (code)
2224     {
2225     case INTEGER_CST:
2226       p = (char *) &TREE_INT_CST (exp);
2227       len = sizeof TREE_INT_CST (exp);
2228       break;
2229
2230     case REAL_CST:
2231       return real_hash (TREE_REAL_CST_PTR (exp));
2232
2233     case STRING_CST:
2234       p = TREE_STRING_POINTER (exp);
2235       len = TREE_STRING_LENGTH (exp);
2236       break;
2237
2238     case COMPLEX_CST:
2239       return (const_hash_1 (TREE_REALPART (exp)) * 5
2240               + const_hash_1 (TREE_IMAGPART (exp)));
2241
2242     case CONSTRUCTOR:
2243       if (TREE_CODE (TREE_TYPE (exp)) == SET_TYPE)
2244         {
2245           char *tmp;
2246
2247           len = int_size_in_bytes (TREE_TYPE (exp));
2248           tmp = alloca (len);
2249           get_set_constructor_bytes (exp, (unsigned char *) tmp, len);
2250           p = tmp;
2251           break;
2252         }
2253       else
2254         {
2255           tree link;
2256
2257           hi = 5 + int_size_in_bytes (TREE_TYPE (exp));
2258
2259           for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
2260             if (TREE_VALUE (link))
2261               hi = hi * 603 + const_hash_1 (TREE_VALUE (link));
2262
2263           return hi;
2264         }
2265
2266     case ADDR_EXPR:
2267     case FDESC_EXPR:
2268       {
2269         struct addr_const value;
2270
2271         decode_addr_const (exp, &value);
2272         if (GET_CODE (value.base) == SYMBOL_REF)
2273           {
2274             /* Don't hash the address of the SYMBOL_REF;
2275                only use the offset and the symbol name.  */
2276             hi = value.offset;
2277             p = XSTR (value.base, 0);
2278             for (i = 0; p[i] != 0; i++)
2279               hi = ((hi * 613) + (unsigned) (p[i]));
2280           }
2281         else if (GET_CODE (value.base) == LABEL_REF)
2282           hi = value.offset + CODE_LABEL_NUMBER (XEXP (value.base, 0)) * 13;
2283         else
2284           abort ();
2285       }
2286       return hi;
2287
2288     case PLUS_EXPR:
2289     case MINUS_EXPR:
2290       return (const_hash_1 (TREE_OPERAND (exp, 0)) * 9
2291               + const_hash_1 (TREE_OPERAND (exp, 1)));
2292
2293     case NOP_EXPR:
2294     case CONVERT_EXPR:
2295     case NON_LVALUE_EXPR:
2296       return const_hash_1 (TREE_OPERAND (exp, 0)) * 7 + 2;
2297
2298     default:
2299       /* A language specific constant. Just hash the code.  */
2300       return code;
2301     }
2302
2303   /* Compute hashing function.  */
2304   hi = len;
2305   for (i = 0; i < len; i++)
2306     hi = ((hi * 613) + (unsigned) (p[i]));
2307
2308   return hi;
2309 }
2310
2311 /* Wrapper of compare_constant, for the htab interface.  */
2312 static int
2313 const_desc_eq (const void *p1, const void *p2)
2314 {
2315   return compare_constant (((struct constant_descriptor_tree *)p1)->value,
2316                            ((struct constant_descriptor_tree *)p2)->value);
2317 }
2318
2319 /* Compare t1 and t2, and return 1 only if they are known to result in
2320    the same bit pattern on output.  */
2321
2322 static int
2323 compare_constant (const tree t1, const tree t2)
2324 {
2325   enum tree_code typecode;
2326
2327   if (t1 == NULL_TREE)
2328     return t2 == NULL_TREE;
2329   if (t2 == NULL_TREE)
2330     return 0;
2331
2332   if (TREE_CODE (t1) != TREE_CODE (t2))
2333     return 0;
2334
2335   switch (TREE_CODE (t1))
2336     {
2337     case INTEGER_CST:
2338       /* Integer constants are the same only if the same width of type.  */
2339       if (TYPE_PRECISION (TREE_TYPE (t1)) != TYPE_PRECISION (TREE_TYPE (t2)))
2340         return 0;
2341       return tree_int_cst_equal (t1, t2);
2342
2343     case REAL_CST:
2344       /* Real constants are the same only if the same width of type.  */
2345       if (TYPE_PRECISION (TREE_TYPE (t1)) != TYPE_PRECISION (TREE_TYPE (t2)))
2346         return 0;
2347
2348       return REAL_VALUES_IDENTICAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2));
2349
2350     case STRING_CST:
2351       if (TYPE_MODE (TREE_TYPE (t1)) != TYPE_MODE (TREE_TYPE (t2)))
2352         return 0;
2353
2354       return (TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
2355               && ! memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
2356                          TREE_STRING_LENGTH (t1)));
2357
2358     case COMPLEX_CST:
2359       return (compare_constant (TREE_REALPART (t1), TREE_REALPART (t2))
2360               && compare_constant (TREE_IMAGPART (t1), TREE_IMAGPART (t2)));
2361
2362     case CONSTRUCTOR:
2363       typecode = TREE_CODE (TREE_TYPE (t1));
2364       if (typecode != TREE_CODE (TREE_TYPE (t2)))
2365         return 0;
2366
2367       if (typecode == SET_TYPE)
2368         {
2369           int len = int_size_in_bytes (TREE_TYPE (t2));
2370           unsigned char *tmp1, *tmp2;
2371
2372           if (int_size_in_bytes (TREE_TYPE (t1)) != len)
2373             return 0;
2374
2375           tmp1 = alloca (len);
2376           tmp2 = alloca (len);
2377
2378           if (get_set_constructor_bytes (t1, tmp1, len) != NULL_TREE)
2379             return 0;
2380           if (get_set_constructor_bytes (t2, tmp2, len) != NULL_TREE)
2381             return 0;
2382
2383           return memcmp (tmp1, tmp2, len) == 0;
2384         }
2385       else
2386         {
2387           tree l1, l2;
2388
2389           if (typecode == ARRAY_TYPE)
2390             {
2391               HOST_WIDE_INT size_1 = int_size_in_bytes (TREE_TYPE (t1));
2392               /* For arrays, check that the sizes all match.  */
2393               if (TYPE_MODE (TREE_TYPE (t1)) != TYPE_MODE (TREE_TYPE (t2))
2394                   || size_1 == -1
2395                   || size_1 != int_size_in_bytes (TREE_TYPE (t2)))
2396                 return 0;
2397             }
2398           else
2399             {
2400               /* For record and union constructors, require exact type
2401                  equality.  */
2402               if (TREE_TYPE (t1) != TREE_TYPE (t2))
2403                 return 0;
2404             }
2405
2406           for (l1 = CONSTRUCTOR_ELTS (t1), l2 = CONSTRUCTOR_ELTS (t2);
2407                l1 && l2;
2408                l1 = TREE_CHAIN (l1), l2 = TREE_CHAIN (l2))
2409             {
2410               /* Check that each value is the same...  */
2411               if (! compare_constant (TREE_VALUE (l1), TREE_VALUE (l2)))
2412                 return 0;
2413               /* ... and that they apply to the same fields!  */
2414               if (typecode == ARRAY_TYPE)
2415                 {
2416                   if (! compare_constant (TREE_PURPOSE (l1),
2417                                           TREE_PURPOSE (l2)))
2418                     return 0;
2419                 }
2420               else
2421                 {
2422                   if (TREE_PURPOSE (l1) != TREE_PURPOSE (l2))
2423                     return 0;
2424                 }
2425             }
2426
2427           return l1 == NULL_TREE && l2 == NULL_TREE;
2428         }
2429
2430     case ADDR_EXPR:
2431     case FDESC_EXPR:
2432       {
2433         struct addr_const value1, value2;
2434
2435         decode_addr_const (t1, &value1);
2436         decode_addr_const (t2, &value2);
2437         return (value1.offset == value2.offset
2438                 && strcmp (XSTR (value1.base, 0), XSTR (value2.base, 0)) == 0);
2439       }
2440
2441     case PLUS_EXPR:
2442     case MINUS_EXPR:
2443     case RANGE_EXPR:
2444       return (compare_constant (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0))
2445               && compare_constant(TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1)));
2446
2447     case NOP_EXPR:
2448     case CONVERT_EXPR:
2449     case NON_LVALUE_EXPR:
2450     case VIEW_CONVERT_EXPR:
2451       return compare_constant (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2452
2453     default:
2454       {
2455         tree nt1, nt2;
2456         nt1 = lang_hooks.expand_constant (t1);
2457         nt2 = lang_hooks.expand_constant (t2);
2458         if (nt1 != t1 || nt2 != t2)
2459           return compare_constant (nt1, nt2);
2460         else
2461           return 0;
2462       }
2463     }
2464
2465   /* Should not get here.  */
2466   abort ();
2467 }
2468 \f
2469 /* Make a copy of the whole tree structure for a constant.  This
2470    handles the same types of nodes that compare_constant handles.  */
2471
2472 static tree
2473 copy_constant (tree exp)
2474 {
2475   switch (TREE_CODE (exp))
2476     {
2477     case ADDR_EXPR:
2478       /* For ADDR_EXPR, we do not want to copy the decl whose address
2479          is requested.  We do want to copy constants though.  */
2480       if (CONSTANT_CLASS_P (TREE_OPERAND (exp, 0)))
2481         return build1 (TREE_CODE (exp), TREE_TYPE (exp),
2482                        copy_constant (TREE_OPERAND (exp, 0)));
2483       else
2484         return copy_node (exp);
2485
2486     case INTEGER_CST:
2487     case REAL_CST:
2488     case STRING_CST:
2489       return copy_node (exp);
2490
2491     case COMPLEX_CST:
2492       return build_complex (TREE_TYPE (exp),
2493                             copy_constant (TREE_REALPART (exp)),
2494                             copy_constant (TREE_IMAGPART (exp)));
2495
2496     case PLUS_EXPR:
2497     case MINUS_EXPR:
2498       return build2 (TREE_CODE (exp), TREE_TYPE (exp),
2499                      copy_constant (TREE_OPERAND (exp, 0)),
2500                      copy_constant (TREE_OPERAND (exp, 1)));
2501
2502     case NOP_EXPR:
2503     case CONVERT_EXPR:
2504     case NON_LVALUE_EXPR:
2505     case VIEW_CONVERT_EXPR:
2506       return build1 (TREE_CODE (exp), TREE_TYPE (exp),
2507                      copy_constant (TREE_OPERAND (exp, 0)));
2508
2509     case CONSTRUCTOR:
2510       {
2511         tree copy = copy_node (exp);
2512         tree list = copy_list (CONSTRUCTOR_ELTS (exp));
2513         tree tail;
2514
2515         CONSTRUCTOR_ELTS (copy) = list;
2516         for (tail = list; tail; tail = TREE_CHAIN (tail))
2517           TREE_VALUE (tail) = copy_constant (TREE_VALUE (tail));
2518         if (TREE_CODE (TREE_TYPE (exp)) == SET_TYPE)
2519           for (tail = list; tail; tail = TREE_CHAIN (tail))
2520             TREE_PURPOSE (tail) = copy_constant (TREE_PURPOSE (tail));
2521
2522         return copy;
2523       }
2524
2525     default:
2526       {
2527         tree t;
2528         t = lang_hooks.expand_constant (exp);
2529         if (t != exp)
2530           return copy_constant (t);
2531         else
2532           abort ();
2533       }
2534     }
2535 }
2536 \f
2537 /* Subroutine of output_constant_def:
2538    No constant equal to EXP is known to have been output.
2539    Make a constant descriptor to enter EXP in the hash table.
2540    Assign the label number and construct RTL to refer to the
2541    constant's location in memory.
2542    Caller is responsible for updating the hash table.  */
2543
2544 static struct constant_descriptor_tree *
2545 build_constant_desc (tree exp)
2546 {
2547   rtx symbol;
2548   rtx rtl;
2549   char label[256];
2550   int labelno;
2551   struct constant_descriptor_tree *desc;
2552
2553   desc = ggc_alloc (sizeof (*desc));
2554   desc->value = copy_constant (exp);
2555
2556   /* Propagate marked-ness to copied constant.  */
2557   if (flag_mudflap && mf_marked_p (exp))
2558     mf_mark (desc->value);
2559
2560   /* Create a string containing the label name, in LABEL.  */
2561   labelno = const_labelno++;
2562   ASM_GENERATE_INTERNAL_LABEL (label, "LC", labelno);
2563
2564   /* We have a symbol name; construct the SYMBOL_REF and the MEM.  */
2565   symbol = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (label));
2566   SYMBOL_REF_FLAGS (symbol) = SYMBOL_FLAG_LOCAL;
2567   SYMBOL_REF_DECL (symbol) = desc->value;
2568   TREE_CONSTANT_POOL_ADDRESS_P (symbol) = 1;
2569
2570   rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (exp)), symbol);
2571   set_mem_attributes (rtl, exp, 1);
2572   set_mem_alias_set (rtl, 0);
2573   set_mem_alias_set (rtl, const_alias_set);
2574
2575   /* Set flags or add text to the name to record information, such as
2576      that it is a local symbol.  If the name is changed, the macro
2577      ASM_OUTPUT_LABELREF will have to know how to strip this
2578      information.  This call might invalidate our local variable
2579      SYMBOL; we can't use it afterward.  */
2580
2581   targetm.encode_section_info (exp, rtl, true);
2582
2583   desc->rtl = rtl;
2584
2585   return desc;
2586 }
2587
2588 /* Return an rtx representing a reference to constant data in memory
2589    for the constant expression EXP.
2590
2591    If assembler code for such a constant has already been output,
2592    return an rtx to refer to it.
2593    Otherwise, output such a constant in memory
2594    and generate an rtx for it.
2595
2596    If DEFER is nonzero, this constant can be deferred and output only
2597    if referenced in the function after all optimizations.
2598
2599    `const_desc_table' records which constants already have label strings.  */
2600
2601 rtx
2602 output_constant_def (tree exp, int defer)
2603 {
2604   struct constant_descriptor_tree *desc;
2605   struct constant_descriptor_tree key;
2606   void **loc;
2607
2608   /* Look up EXP in the table of constant descriptors.  If we didn't find
2609      it, create a new one.  */
2610   key.value = exp;
2611   loc = htab_find_slot (const_desc_htab, &key, INSERT);
2612
2613   desc = *loc;
2614   if (desc == 0)
2615     {
2616       desc = build_constant_desc (exp);
2617       *loc = desc;
2618     }
2619
2620   maybe_output_constant_def_contents (desc, defer);
2621   return desc->rtl;
2622 }
2623
2624 /* Subroutine of output_constant_def: Decide whether or not we need to
2625    output the constant DESC now, and if so, do it.  */
2626 static void
2627 maybe_output_constant_def_contents (struct constant_descriptor_tree *desc,
2628                                     int defer)
2629 {
2630   rtx symbol = XEXP (desc->rtl, 0);
2631   tree exp = desc->value;
2632
2633   if (flag_syntax_only)
2634     return;
2635
2636   if (TREE_ASM_WRITTEN (exp))
2637     /* Already output; don't do it again.  */
2638     return;
2639
2640   /* We can always defer constants as long as the context allows
2641      doing so.  */
2642   if (defer)
2643     {
2644       /* Increment n_deferred_constants if it exists.  It needs to be at
2645          least as large as the number of constants actually referred to
2646          by the function.  If it's too small we'll stop looking too early
2647          and fail to emit constants; if it's too large we'll only look
2648          through the entire function when we could have stopped earlier.  */
2649       if (cfun)
2650         n_deferred_constants++;
2651       return;
2652     }
2653
2654   output_constant_def_contents (symbol);
2655 }
2656
2657 /* We must output the constant data referred to by SYMBOL; do so.  */
2658
2659 static void
2660 output_constant_def_contents (rtx symbol)
2661 {
2662   tree exp = SYMBOL_REF_DECL (symbol);
2663   const char *label = XSTR (symbol, 0);
2664   HOST_WIDE_INT size;
2665
2666   /* Make sure any other constants whose addresses appear in EXP
2667      are assigned label numbers.  */
2668   int reloc = compute_reloc_for_constant (exp);
2669
2670   /* Align the location counter as required by EXP's data type.  */
2671   unsigned int align = TYPE_ALIGN (TREE_TYPE (exp));
2672 #ifdef CONSTANT_ALIGNMENT
2673   align = CONSTANT_ALIGNMENT (exp, align);
2674 #endif
2675
2676   output_addressed_constants (exp);
2677
2678   /* We are no longer deferring this constant.  */
2679   TREE_ASM_WRITTEN (exp) = 1;
2680
2681   if (IN_NAMED_SECTION (exp))
2682     named_section (exp, NULL, reloc);
2683   else
2684     targetm.asm_out.select_section (exp, reloc, align);
2685
2686   if (align > BITS_PER_UNIT)
2687     {
2688       ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
2689     }
2690
2691   size = int_size_in_bytes (TREE_TYPE (exp));
2692   if (TREE_CODE (exp) == STRING_CST)
2693     size = MAX (TREE_STRING_LENGTH (exp), size);
2694
2695   /* Do any machine/system dependent processing of the constant.  */
2696 #ifdef ASM_DECLARE_CONSTANT_NAME
2697   ASM_DECLARE_CONSTANT_NAME (asm_out_file, label, exp, size);
2698 #else
2699   /* Standard thing is just output label for the constant.  */
2700   ASM_OUTPUT_LABEL (asm_out_file, label);
2701 #endif /* ASM_DECLARE_CONSTANT_NAME */
2702
2703   /* Output the value of EXP.  */
2704   output_constant (exp, size, align);
2705   if (flag_mudflap)
2706     mudflap_enqueue_constant (exp);
2707 }
2708
2709 /* Look up EXP in the table of constant descriptors.  Return the rtl
2710    if it has been emitted, else null.  */
2711
2712 rtx
2713 lookup_constant_def (tree exp)
2714 {
2715   struct constant_descriptor_tree *desc;
2716   struct constant_descriptor_tree key;
2717
2718   key.value = exp;
2719   desc = htab_find (const_desc_htab, &key);
2720
2721   return (desc ? desc->rtl : NULL_RTX);
2722 }
2723 \f
2724 /* Used in the hash tables to avoid outputting the same constant
2725    twice.  Unlike 'struct constant_descriptor_tree', RTX constants
2726    are output once per function, not once per file.  */
2727 /* ??? Only a few targets need per-function constant pools.  Most
2728    can use one per-file pool.  Should add a targetm bit to tell the
2729    difference.  */
2730
2731 struct rtx_constant_pool GTY(())
2732 {
2733   /* Pointers to first and last constant in pool, as ordered by offset.  */
2734   struct constant_descriptor_rtx *first;
2735   struct constant_descriptor_rtx *last;
2736
2737   /* Hash facility for making memory-constants from constant rtl-expressions.
2738      It is used on RISC machines where immediate integer arguments and
2739      constant addresses are restricted so that such constants must be stored
2740      in memory.  */
2741   htab_t GTY((param_is (struct constant_descriptor_rtx))) const_rtx_htab;
2742   htab_t GTY((param_is (struct constant_descriptor_rtx))) const_rtx_sym_htab;
2743
2744   /* Current offset in constant pool (does not include any
2745      machine-specific header).  */
2746   HOST_WIDE_INT offset;
2747 };
2748
2749 struct constant_descriptor_rtx GTY((chain_next ("%h.next")))
2750 {
2751   struct constant_descriptor_rtx *next;
2752   rtx mem;
2753   rtx sym;
2754   rtx constant;
2755   HOST_WIDE_INT offset;
2756   hashval_t hash;
2757   enum machine_mode mode;
2758   unsigned int align;
2759   int labelno;
2760   int mark;
2761 };
2762
2763 /* Hash and compare functions for const_rtx_htab.  */
2764
2765 static hashval_t
2766 const_desc_rtx_hash (const void *ptr)
2767 {
2768   const struct constant_descriptor_rtx *desc = ptr;
2769   return desc->hash;
2770 }
2771
2772 static int
2773 const_desc_rtx_eq (const void *a, const void *b)
2774 {
2775   const struct constant_descriptor_rtx *x = a;
2776   const struct constant_descriptor_rtx *y = b;
2777
2778   if (x->mode != y->mode)
2779     return 0;
2780   return rtx_equal_p (x->constant, y->constant);
2781 }
2782
2783 /* Hash and compare functions for const_rtx_sym_htab.  */
2784
2785 static hashval_t
2786 const_desc_rtx_sym_hash (const void *ptr)
2787 {
2788   const struct constant_descriptor_rtx *desc = ptr;
2789   return htab_hash_string (XSTR (desc->sym, 0));
2790 }
2791
2792 static int
2793 const_desc_rtx_sym_eq (const void *a, const void *b)
2794 {
2795   const struct constant_descriptor_rtx *x = a;
2796   const struct constant_descriptor_rtx *y = b;
2797   return XSTR (x->sym, 0) == XSTR (y->sym, 0);
2798 }
2799
2800 /* This is the worker function for const_rtx_hash, called via for_each_rtx.  */
2801
2802 static int
2803 const_rtx_hash_1 (rtx *xp, void *data)
2804 {
2805   unsigned HOST_WIDE_INT hwi;
2806   enum machine_mode mode;
2807   enum rtx_code code;
2808   hashval_t h, *hp;
2809   rtx x;
2810
2811   x = *xp;
2812   code = GET_CODE (x);
2813   mode = GET_MODE (x);
2814   h = (hashval_t) code * 1048573 + mode;
2815
2816   switch (code)
2817     {
2818     case CONST_INT:
2819       hwi = INTVAL (x);
2820     fold_hwi:
2821       {
2822         const int shift = sizeof (hashval_t) * CHAR_BIT;
2823         const int n = sizeof (HOST_WIDE_INT) / sizeof (hashval_t);
2824         int i;
2825
2826         h ^= (hashval_t) hwi;
2827         for (i = 1; i < n; ++i)
2828           {
2829             hwi >>= shift;
2830             h ^= (hashval_t) hwi;
2831           }
2832       }
2833       break;
2834
2835     case CONST_DOUBLE:
2836       if (mode == VOIDmode)
2837         {
2838           hwi = CONST_DOUBLE_LOW (x) ^ CONST_DOUBLE_HIGH (x);
2839           goto fold_hwi;
2840         }
2841       else
2842         h ^= real_hash (CONST_DOUBLE_REAL_VALUE (x));
2843       break;
2844
2845     case SYMBOL_REF:
2846       h ^= htab_hash_string (XSTR (x, 0));
2847       break;
2848
2849     case LABEL_REF:
2850       h = h * 251 + CODE_LABEL_NUMBER (XEXP (x, 0));
2851       break;
2852
2853     case UNSPEC:
2854     case UNSPEC_VOLATILE:
2855       h = h * 251 + XINT (x, 1);
2856       break;
2857
2858     default:
2859       break;
2860     }
2861
2862   hp = data;
2863   *hp = *hp * 509 + h;
2864   return 0;
2865 }
2866
2867 /* Compute a hash value for X, which should be a constant.  */
2868
2869 static hashval_t
2870 const_rtx_hash (rtx x)
2871 {
2872   hashval_t h = 0;
2873   for_each_rtx (&x, const_rtx_hash_1, &h);
2874   return h;
2875 }
2876
2877 \f
2878 /* Initialize constant pool hashing for a new function.  */
2879
2880 void
2881 init_varasm_status (struct function *f)
2882 {
2883   struct varasm_status *p;
2884   struct rtx_constant_pool *pool;
2885
2886   p = ggc_alloc (sizeof (struct varasm_status));
2887   f->varasm = p;
2888
2889   pool = ggc_alloc (sizeof (struct rtx_constant_pool));
2890   p->pool = pool;
2891   p->deferred_constants = 0;
2892
2893   pool->const_rtx_htab = htab_create_ggc (31, const_desc_rtx_hash,
2894                                           const_desc_rtx_eq, NULL);
2895   pool->const_rtx_sym_htab = htab_create_ggc (31, const_desc_rtx_sym_hash,
2896                                               const_desc_rtx_sym_eq, NULL);
2897   pool->first = pool->last = NULL;
2898   pool->offset = 0;
2899 }
2900 \f
2901 /* Given a MINUS expression, simplify it if both sides
2902    include the same symbol.  */
2903
2904 rtx
2905 simplify_subtraction (rtx x)
2906 {
2907   rtx r = simplify_rtx (x);
2908   return r ? r : x;
2909 }
2910 \f
2911 /* Given a constant rtx X, make (or find) a memory constant for its value
2912    and return a MEM rtx to refer to it in memory.  */
2913
2914 rtx
2915 force_const_mem (enum machine_mode mode, rtx x)
2916 {
2917   struct constant_descriptor_rtx *desc, tmp;
2918   struct rtx_constant_pool *pool = cfun->varasm->pool;
2919   char label[256];
2920   rtx def, symbol;
2921   hashval_t hash;
2922   unsigned int align;
2923   void **slot;
2924
2925   /* If we're not allowed to drop X into the constant pool, don't.  */
2926   if (targetm.cannot_force_const_mem (x))
2927     return NULL_RTX;
2928
2929   /* Lookup the value in the hashtable.  */
2930   tmp.constant = x;
2931   tmp.mode = mode;
2932   hash = const_rtx_hash (x);
2933   slot = htab_find_slot_with_hash (pool->const_rtx_htab, &tmp, hash, INSERT);
2934   desc = *slot;
2935
2936   /* If the constant was already present, return its memory.  */
2937   if (desc)
2938     return copy_rtx (desc->mem);
2939
2940   /* Otherwise, create a new descriptor.  */
2941   desc = ggc_alloc (sizeof (*desc));
2942   *slot = desc;
2943
2944   /* Align the location counter as required by EXP's data type.  */
2945   align = GET_MODE_ALIGNMENT (mode == VOIDmode ? word_mode : mode);
2946 #ifdef CONSTANT_ALIGNMENT
2947   {
2948     tree type = lang_hooks.types.type_for_mode (mode, 0);
2949     if (type != NULL_TREE)
2950       align = CONSTANT_ALIGNMENT (make_tree (type, x), align);
2951   }
2952 #endif
2953
2954   pool->offset += (align / BITS_PER_UNIT) - 1;
2955   pool->offset &= ~ ((align / BITS_PER_UNIT) - 1);
2956
2957   desc->next = NULL;
2958   desc->constant = tmp.constant;
2959   desc->offset = pool->offset;
2960   desc->hash = hash;
2961   desc->mode = mode;
2962   desc->align = align;
2963   desc->labelno = const_labelno;
2964   desc->mark = 0;
2965
2966   pool->offset += GET_MODE_SIZE (mode);
2967   if (pool->last)
2968     pool->last->next = desc;
2969   else
2970     pool->first = pool->last = desc;
2971   pool->last = desc;
2972
2973   /* Create a string containing the label name, in LABEL.  */
2974   ASM_GENERATE_INTERNAL_LABEL (label, "LC", const_labelno);
2975   ++const_labelno;
2976
2977   /* Construct the SYMBOL_REF.  Make sure to mark it as belonging to
2978      the constants pool.  */
2979   desc->sym = symbol = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (label));
2980   SYMBOL_REF_FLAGS (symbol) = SYMBOL_FLAG_LOCAL;
2981   CONSTANT_POOL_ADDRESS_P (symbol) = 1;
2982   current_function_uses_const_pool = 1;
2983
2984   /* Insert the descriptor into the symbol cross-reference table too.  */
2985   slot = htab_find_slot (pool->const_rtx_sym_htab, desc, INSERT);
2986   if (*slot)
2987     abort ();
2988   *slot = desc;
2989
2990   /* Construct the MEM.  */
2991   desc->mem = def = gen_const_mem (mode, symbol);
2992   set_mem_attributes (def, lang_hooks.types.type_for_mode (mode, 0), 1);
2993
2994   /* If we're dropping a label to the constant pool, make sure we
2995      don't delete it.  */
2996   if (GET_CODE (x) == LABEL_REF)
2997     LABEL_PRESERVE_P (XEXP (x, 0)) = 1;
2998
2999   return copy_rtx (def);
3000 }
3001 \f
3002 /* Given a SYMBOL_REF with CONSTANT_POOL_ADDRESS_P true, return a pointer to
3003    the corresponding constant_descriptor_rtx structure.  */
3004
3005 static struct constant_descriptor_rtx *
3006 find_pool_constant (struct rtx_constant_pool *pool, rtx sym)
3007 {
3008   struct constant_descriptor_rtx tmp;
3009   tmp.sym = sym;
3010   return htab_find (pool->const_rtx_sym_htab, &tmp);
3011 }
3012
3013 /* Given a constant pool SYMBOL_REF, return the corresponding constant.  */
3014
3015 rtx
3016 get_pool_constant (rtx addr)
3017 {
3018   return find_pool_constant (cfun->varasm->pool, addr)->constant;
3019 }
3020
3021 /* Given a constant pool SYMBOL_REF, return the corresponding constant
3022    and whether it has been output or not.  */
3023
3024 rtx
3025 get_pool_constant_mark (rtx addr, bool *pmarked)
3026 {
3027   struct constant_descriptor_rtx *desc;
3028
3029   desc = find_pool_constant (cfun->varasm->pool, addr);
3030   *pmarked = (desc->mark != 0);
3031   return desc->constant;
3032 }
3033
3034 /* Likewise, but for the constant pool of a specific function.  */
3035
3036 rtx
3037 get_pool_constant_for_function (struct function *f, rtx addr)
3038 {
3039   return find_pool_constant (f->varasm->pool, addr)->constant;
3040 }
3041
3042 /* Similar, return the mode.  */
3043
3044 enum machine_mode
3045 get_pool_mode (rtx addr)
3046 {
3047   return find_pool_constant (cfun->varasm->pool, addr)->mode;
3048 }
3049
3050 /* Return the size of the constant pool.  */
3051
3052 int
3053 get_pool_size (void)
3054 {
3055   return cfun->varasm->pool->offset;
3056 }
3057 \f
3058 /* Worker function for output_constant_pool_1.  Emit assembly for X
3059    in MODE with known alignment ALIGN.  */
3060
3061 static void
3062 output_constant_pool_2 (enum machine_mode mode, rtx x, unsigned int align)
3063 {
3064   switch (GET_MODE_CLASS (mode))
3065     {
3066     case MODE_FLOAT:
3067       if (GET_CODE (x) != CONST_DOUBLE)
3068         abort ();
3069       else
3070         {
3071           REAL_VALUE_TYPE r;
3072           REAL_VALUE_FROM_CONST_DOUBLE (r, x);
3073           assemble_real (r, mode, align);
3074         }
3075       break;
3076
3077     case MODE_INT:
3078     case MODE_PARTIAL_INT:
3079       assemble_integer (x, GET_MODE_SIZE (mode), align, 1);
3080       break;
3081
3082     case MODE_VECTOR_FLOAT:
3083     case MODE_VECTOR_INT:
3084       {
3085         int i, units;
3086         enum machine_mode submode = GET_MODE_INNER (mode);
3087         unsigned int subalign = MIN (align, GET_MODE_BITSIZE (submode));
3088
3089         if (GET_CODE (x) != CONST_VECTOR)
3090           abort ();
3091         units = CONST_VECTOR_NUNITS (x);
3092
3093         for (i = 0; i < units; i++)
3094           {
3095             rtx elt = CONST_VECTOR_ELT (x, i);
3096             output_constant_pool_2 (submode, elt, i ? subalign : align);
3097           }
3098       }
3099       break;
3100
3101     default:
3102       abort ();
3103     }
3104 }
3105
3106 /* Worker function for output_constant_pool.  Emit POOL.  */
3107
3108 static void
3109 output_constant_pool_1 (struct constant_descriptor_rtx *desc)
3110 {
3111   rtx x, tmp;
3112
3113   if (!desc->mark)
3114     return;
3115   x = desc->constant;
3116
3117   /* See if X is a LABEL_REF (or a CONST referring to a LABEL_REF)
3118      whose CODE_LABEL has been deleted.  This can occur if a jump table
3119      is eliminated by optimization.  If so, write a constant of zero
3120      instead.  Note that this can also happen by turning the
3121      CODE_LABEL into a NOTE.  */
3122   /* ??? This seems completely and utterly wrong.  Certainly it's
3123      not true for NOTE_INSN_DELETED_LABEL, but I disbelieve proper
3124      functioning even with INSN_DELETED_P and friends.  */
3125
3126   tmp = x;
3127   switch (GET_CODE (x))
3128     {
3129     case CONST:
3130       if (GET_CODE (XEXP (x, 0)) != PLUS
3131           || GET_CODE (XEXP (XEXP (x, 0), 0)) != LABEL_REF)
3132         break;
3133       tmp = XEXP (XEXP (x, 0), 0);
3134       /* FALLTHRU  */
3135
3136     case LABEL_REF:
3137       tmp = XEXP (x, 0);
3138       if (INSN_DELETED_P (tmp)
3139           || (NOTE_P (tmp)
3140               && NOTE_LINE_NUMBER (tmp) == NOTE_INSN_DELETED))
3141         {
3142           abort ();
3143           x = const0_rtx;
3144         }
3145       break;
3146
3147     default:
3148       break;
3149     }
3150
3151   /* First switch to correct section.  */
3152   targetm.asm_out.select_rtx_section (desc->mode, x, desc->align);
3153
3154 #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
3155   ASM_OUTPUT_SPECIAL_POOL_ENTRY (asm_out_file, x, desc->mode,
3156                                  desc->align, desc->labelno, done);
3157 #endif
3158
3159   assemble_align (desc->align);
3160
3161   /* Output the label.  */
3162   targetm.asm_out.internal_label (asm_out_file, "LC", desc->labelno);
3163
3164   /* Output the data.  */
3165   output_constant_pool_2 (desc->mode, x, desc->align);
3166
3167   /* Make sure all constants in SECTION_MERGE and not SECTION_STRINGS
3168      sections have proper size.  */
3169   if (desc->align > GET_MODE_BITSIZE (desc->mode)
3170       && in_section == in_named
3171       && get_named_section_flags (in_named_name) & SECTION_MERGE)
3172     assemble_align (desc->align);
3173
3174 #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
3175  done:
3176 #endif
3177   return;
3178 }
3179
3180 /* Given a SYMBOL_REF CURRENT_RTX, mark it and all constants it refers
3181    to as used.  Emit referenced deferred strings.  This function can
3182    be used with for_each_rtx to mark all SYMBOL_REFs in an rtx.  */
3183
3184 static int
3185 mark_constant (rtx *current_rtx, void *data)
3186 {
3187   struct rtx_constant_pool *pool = data;
3188   rtx x = *current_rtx;
3189
3190   if (x == NULL_RTX || GET_CODE (x) != SYMBOL_REF)
3191     return 0;
3192
3193   if (CONSTANT_POOL_ADDRESS_P (x))
3194     {
3195       struct constant_descriptor_rtx *desc = find_pool_constant (pool, x);
3196       if (desc->mark == 0)
3197         {
3198           desc->mark = 1;
3199           for_each_rtx (&desc->constant, mark_constant, pool);
3200         }
3201     }
3202   else if (TREE_CONSTANT_POOL_ADDRESS_P (x))
3203     {
3204       tree exp = SYMBOL_REF_DECL (x);
3205       if (!TREE_ASM_WRITTEN (exp))
3206         {
3207           n_deferred_constants--;
3208           output_constant_def_contents (x);
3209         }
3210     }
3211
3212   return -1;
3213 }
3214
3215 /* Look through appropriate parts of INSN, marking all entries in the
3216    constant pool which are actually being used.  Entries that are only
3217    referenced by other constants are also marked as used.  Emit
3218    deferred strings that are used.  */
3219
3220 static void
3221 mark_constants (struct rtx_constant_pool *pool, rtx insn)
3222 {
3223   if (!INSN_P (insn))
3224     return;
3225
3226   /* Insns may appear inside a SEQUENCE.  Only check the patterns of
3227      insns, not any notes that may be attached.  We don't want to mark
3228      a constant just because it happens to appear in a REG_EQUIV note.  */
3229   if (GET_CODE (PATTERN (insn)) == SEQUENCE)
3230     {
3231       rtx seq = PATTERN (insn);
3232       int i, n = XVECLEN (seq, 0);
3233       for (i = 0; i < n; ++i)
3234         {
3235           rtx subinsn = XVECEXP (seq, 0, i);
3236           if (INSN_P (subinsn))
3237             for_each_rtx (&PATTERN (subinsn), mark_constant, pool);
3238         }
3239     }
3240   else
3241     for_each_rtx (&PATTERN (insn), mark_constant, pool);
3242 }
3243
3244 /* Look through the instructions for this function, and mark all the
3245    entries in POOL which are actually being used.  Emit deferred constants
3246    which have indeed been used.  */
3247
3248 static void
3249 mark_constant_pool (struct rtx_constant_pool *pool)
3250 {
3251   rtx insn, link;
3252
3253   if (pool->first == 0 && n_deferred_constants == 0)
3254     return;
3255
3256   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
3257     mark_constants (pool, insn);
3258
3259   for (link = current_function_epilogue_delay_list;
3260        link;
3261        link = XEXP (link, 1))
3262     mark_constants (pool, XEXP (link, 0));
3263 }
3264
3265 /* Write all the constants in the constant pool.  */
3266
3267 void
3268 output_constant_pool (const char *fnname ATTRIBUTE_UNUSED,
3269                       tree fndecl ATTRIBUTE_UNUSED)
3270 {
3271   struct rtx_constant_pool *pool = cfun->varasm->pool;
3272   struct constant_descriptor_rtx *desc;
3273
3274   /* It is possible for gcc to call force_const_mem and then to later
3275      discard the instructions which refer to the constant.  In such a
3276      case we do not need to output the constant.  */
3277   mark_constant_pool (pool);
3278
3279 #ifdef ASM_OUTPUT_POOL_PROLOGUE
3280   ASM_OUTPUT_POOL_PROLOGUE (asm_out_file, fnname, fndecl, pool->offset);
3281 #endif
3282
3283   for (desc = pool->first; desc ; desc = desc->next)
3284     output_constant_pool_1 (desc);
3285
3286 #ifdef ASM_OUTPUT_POOL_EPILOGUE
3287   ASM_OUTPUT_POOL_EPILOGUE (asm_out_file, fnname, fndecl, pool->offset);
3288 #endif
3289 }
3290 \f
3291 /* Determine what kind of relocations EXP may need.  */
3292
3293 int
3294 compute_reloc_for_constant (tree exp)
3295 {
3296   int reloc = 0, reloc2;
3297   tree tem;
3298
3299   /* Give the front-end a chance to convert VALUE to something that
3300      looks more like a constant to the back-end.  */
3301   exp = lang_hooks.expand_constant (exp);
3302
3303   switch (TREE_CODE (exp))
3304     {
3305     case ADDR_EXPR:
3306     case FDESC_EXPR:
3307       /* Go inside any operations that get_inner_reference can handle and see
3308          if what's inside is a constant: no need to do anything here for
3309          addresses of variables or functions.  */
3310       for (tem = TREE_OPERAND (exp, 0); handled_component_p (tem);
3311            tem = TREE_OPERAND (tem, 0))
3312         ;
3313
3314       if (TREE_PUBLIC (tem))
3315         reloc |= 2;
3316       else
3317         reloc |= 1;
3318       break;
3319
3320     case PLUS_EXPR:
3321       reloc = compute_reloc_for_constant (TREE_OPERAND (exp, 0));
3322       reloc |= compute_reloc_for_constant (TREE_OPERAND (exp, 1));
3323       break;
3324
3325     case MINUS_EXPR:
3326       reloc = compute_reloc_for_constant (TREE_OPERAND (exp, 0));
3327       reloc2 = compute_reloc_for_constant (TREE_OPERAND (exp, 1));
3328       /* The difference of two local labels is computable at link time.  */
3329       if (reloc == 1 && reloc2 == 1)
3330         reloc = 0;
3331       else
3332         reloc |= reloc2;
3333       break;
3334
3335     case NOP_EXPR:
3336     case CONVERT_EXPR:
3337     case NON_LVALUE_EXPR:
3338       reloc = compute_reloc_for_constant (TREE_OPERAND (exp, 0));
3339       break;
3340
3341     case CONSTRUCTOR:
3342       for (tem = CONSTRUCTOR_ELTS (exp); tem; tem = TREE_CHAIN (tem))
3343         if (TREE_VALUE (tem) != 0)
3344           reloc |= compute_reloc_for_constant (TREE_VALUE (tem));
3345
3346       break;
3347
3348     default:
3349       break;
3350     }
3351   return reloc;
3352 }
3353
3354 /* Find all the constants whose addresses are referenced inside of EXP,
3355    and make sure assembler code with a label has been output for each one.
3356    Indicate whether an ADDR_EXPR has been encountered.  */
3357
3358 static void
3359 output_addressed_constants (tree exp)
3360 {
3361   tree tem;
3362
3363   /* Give the front-end a chance to convert VALUE to something that
3364      looks more like a constant to the back-end.  */
3365   exp = lang_hooks.expand_constant (exp);
3366
3367   switch (TREE_CODE (exp))
3368     {
3369     case ADDR_EXPR:
3370     case FDESC_EXPR:
3371       /* Go inside any operations that get_inner_reference can handle and see
3372          if what's inside is a constant: no need to do anything here for
3373          addresses of variables or functions.  */
3374       for (tem = TREE_OPERAND (exp, 0); handled_component_p (tem);
3375            tem = TREE_OPERAND (tem, 0))
3376         ;
3377
3378       if (CONSTANT_CLASS_P (tem) || TREE_CODE (tem) == CONSTRUCTOR)
3379         output_constant_def (tem, 0);
3380       break;
3381
3382     case PLUS_EXPR:
3383     case MINUS_EXPR:
3384       output_addressed_constants (TREE_OPERAND (exp, 1));
3385       /* Fall through.  */
3386
3387     case NOP_EXPR:
3388     case CONVERT_EXPR:
3389     case NON_LVALUE_EXPR:
3390       output_addressed_constants (TREE_OPERAND (exp, 0));
3391       break;
3392
3393     case CONSTRUCTOR:
3394       for (tem = CONSTRUCTOR_ELTS (exp); tem; tem = TREE_CHAIN (tem))
3395         if (TREE_VALUE (tem) != 0)
3396           output_addressed_constants (TREE_VALUE (tem));
3397
3398       break;
3399
3400     default:
3401       break;
3402     }
3403 }
3404 \f
3405 /* Return nonzero if VALUE is a valid constant-valued expression
3406    for use in initializing a static variable; one that can be an
3407    element of a "constant" initializer.
3408
3409    Return null_pointer_node if the value is absolute;
3410    if it is relocatable, return the variable that determines the relocation.
3411    We assume that VALUE has been folded as much as possible;
3412    therefore, we do not need to check for such things as
3413    arithmetic-combinations of integers.  */
3414
3415 tree
3416 initializer_constant_valid_p (tree value, tree endtype)
3417 {
3418   /* Give the front-end a chance to convert VALUE to something that
3419      looks more like a constant to the back-end.  */
3420   value = lang_hooks.expand_constant (value);
3421
3422   switch (TREE_CODE (value))
3423     {
3424     case CONSTRUCTOR:
3425       if ((TREE_CODE (TREE_TYPE (value)) == UNION_TYPE
3426            || TREE_CODE (TREE_TYPE (value)) == RECORD_TYPE)
3427           && TREE_CONSTANT (value)
3428           && CONSTRUCTOR_ELTS (value))
3429         {
3430           tree elt;
3431           bool absolute = true;
3432
3433           for (elt = CONSTRUCTOR_ELTS (value); elt; elt = TREE_CHAIN (elt))
3434             {
3435               tree reloc;
3436               value = TREE_VALUE (elt);
3437               reloc = initializer_constant_valid_p (value, TREE_TYPE (value));
3438               if (!reloc)
3439                 return NULL_TREE;
3440               if (reloc != null_pointer_node)
3441                 absolute = false;
3442             }
3443           /* For a non-absolute relocation, there is no single
3444              variable that can be "the variable that determines the
3445              relocation."  */
3446           return absolute ? null_pointer_node : error_mark_node;
3447         }
3448
3449       return TREE_STATIC (value) ? null_pointer_node : NULL_TREE;
3450
3451     case INTEGER_CST:
3452     case VECTOR_CST:
3453     case REAL_CST:
3454     case STRING_CST:
3455     case COMPLEX_CST:
3456       return null_pointer_node;
3457
3458     case ADDR_EXPR:
3459     case FDESC_EXPR:
3460       value = staticp (TREE_OPERAND (value, 0));
3461       /* "&(*a).f" is like unto pointer arithmetic.  If "a" turns out to
3462          be a constant, this is old-skool offsetof-like nonsense.  */
3463       if (value
3464           && TREE_CODE (value) == INDIRECT_REF
3465           && TREE_CONSTANT (TREE_OPERAND (value, 0)))
3466         return null_pointer_node;
3467       return value;
3468
3469     case VIEW_CONVERT_EXPR:
3470     case NON_LVALUE_EXPR:
3471       return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
3472
3473     case CONVERT_EXPR:
3474     case NOP_EXPR:
3475       /* Allow conversions between pointer types.  */
3476       if (POINTER_TYPE_P (TREE_TYPE (value))
3477           && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (value, 0))))
3478         return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
3479
3480       /* Allow conversions between real types.  */
3481       if (FLOAT_TYPE_P (TREE_TYPE (value))
3482           && FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (value, 0))))
3483         return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
3484
3485       /* Allow length-preserving conversions between integer types.  */
3486       if (INTEGRAL_TYPE_P (TREE_TYPE (value))
3487           && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (value, 0)))
3488           && (TYPE_PRECISION (TREE_TYPE (value))
3489               == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value, 0)))))
3490         return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
3491
3492       /* Allow conversions between other integer types only if
3493          explicit value.  */
3494       if (INTEGRAL_TYPE_P (TREE_TYPE (value))
3495           && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (value, 0))))
3496         {
3497           tree inner = initializer_constant_valid_p (TREE_OPERAND (value, 0),
3498                                                      endtype);
3499           if (inner == null_pointer_node)
3500             return null_pointer_node;
3501           break;
3502         }
3503
3504       /* Allow (int) &foo provided int is as wide as a pointer.  */
3505       if (INTEGRAL_TYPE_P (TREE_TYPE (value))
3506           && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (value, 0)))
3507           && (TYPE_PRECISION (TREE_TYPE (value))
3508               >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value, 0)))))
3509         return initializer_constant_valid_p (TREE_OPERAND (value, 0),
3510                                              endtype);
3511
3512       /* Likewise conversions from int to pointers, but also allow
3513          conversions from 0.  */
3514       if ((POINTER_TYPE_P (TREE_TYPE (value))
3515            || TREE_CODE (TREE_TYPE (value)) == OFFSET_TYPE)
3516           && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (value, 0))))
3517         {
3518           if (integer_zerop (TREE_OPERAND (value, 0)))
3519             return null_pointer_node;
3520           else if (TYPE_PRECISION (TREE_TYPE (value))
3521                    <= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value, 0))))
3522             return initializer_constant_valid_p (TREE_OPERAND (value, 0),
3523                                                  endtype);
3524         }
3525
3526       /* Allow conversions to struct or union types if the value
3527          inside is okay.  */
3528       if (TREE_CODE (TREE_TYPE (value)) == RECORD_TYPE
3529           || TREE_CODE (TREE_TYPE (value)) == UNION_TYPE)
3530         return initializer_constant_valid_p (TREE_OPERAND (value, 0),
3531                                              endtype);
3532       break;
3533
3534     case PLUS_EXPR:
3535       if (! INTEGRAL_TYPE_P (endtype)
3536           || TYPE_PRECISION (endtype) >= POINTER_SIZE)
3537         {
3538           tree valid0 = initializer_constant_valid_p (TREE_OPERAND (value, 0),
3539                                                       endtype);
3540           tree valid1 = initializer_constant_valid_p (TREE_OPERAND (value, 1),
3541                                                       endtype);
3542           /* If either term is absolute, use the other terms relocation.  */
3543           if (valid0 == null_pointer_node)
3544             return valid1;
3545           if (valid1 == null_pointer_node)
3546             return valid0;
3547         }
3548       break;
3549
3550     case MINUS_EXPR:
3551       if (! INTEGRAL_TYPE_P (endtype)
3552           || TYPE_PRECISION (endtype) >= POINTER_SIZE)
3553         {
3554           tree valid0 = initializer_constant_valid_p (TREE_OPERAND (value, 0),
3555                                                       endtype);
3556           tree valid1 = initializer_constant_valid_p (TREE_OPERAND (value, 1),
3557                                                       endtype);
3558           /* Win if second argument is absolute.  */
3559           if (valid1 == null_pointer_node)
3560             return valid0;
3561           /* Win if both arguments have the same relocation.
3562              Then the value is absolute.  */
3563           if (valid0 == valid1 && valid0 != 0)
3564             return null_pointer_node;
3565
3566           /* Since GCC guarantees that string constants are unique in the
3567              generated code, a subtraction between two copies of the same
3568              constant string is absolute.  */
3569           if (valid0 && TREE_CODE (valid0) == STRING_CST
3570               && valid1 && TREE_CODE (valid1) == STRING_CST
3571               && operand_equal_p (valid0, valid1, 1))
3572             return null_pointer_node;
3573         }
3574
3575       /* Support narrowing differences.  */
3576       if (INTEGRAL_TYPE_P (endtype))
3577         {
3578           tree op0, op1;
3579
3580           op0 = TREE_OPERAND (value, 0);
3581           op1 = TREE_OPERAND (value, 1);
3582
3583           /* Like STRIP_NOPS except allow the operand mode to widen.
3584              This works around a feature of fold that simplifies
3585              (int)(p1 - p2) to ((int)p1 - (int)p2) under the theory
3586              that the narrower operation is cheaper.  */
3587
3588           while (TREE_CODE (op0) == NOP_EXPR
3589                  || TREE_CODE (op0) == CONVERT_EXPR
3590                  || TREE_CODE (op0) == NON_LVALUE_EXPR)
3591             {
3592               tree inner = TREE_OPERAND (op0, 0);
3593               if (inner == error_mark_node
3594                   || ! INTEGRAL_MODE_P (TYPE_MODE (TREE_TYPE (inner)))
3595                   || (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op0)))
3596                       > GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (inner)))))
3597                 break;
3598               op0 = inner;
3599             }
3600
3601           while (TREE_CODE (op1) == NOP_EXPR
3602                  || TREE_CODE (op1) == CONVERT_EXPR
3603                  || TREE_CODE (op1) == NON_LVALUE_EXPR)
3604             {
3605               tree inner = TREE_OPERAND (op1, 0);
3606               if (inner == error_mark_node
3607                   || ! INTEGRAL_MODE_P (TYPE_MODE (TREE_TYPE (inner)))
3608                   || (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op1)))
3609                       > GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (inner)))))
3610                 break;
3611               op1 = inner;
3612             }
3613
3614           op0 = initializer_constant_valid_p (op0, endtype);
3615           op1 = initializer_constant_valid_p (op1, endtype);
3616
3617           /* Both initializers must be known.  */
3618           if (op0 && op1)
3619             {
3620               if (op0 == op1)
3621                 return null_pointer_node;
3622
3623               /* Support differences between labels.  */
3624               if (TREE_CODE (op0) == LABEL_DECL
3625                   && TREE_CODE (op1) == LABEL_DECL)
3626                 return null_pointer_node;
3627
3628               if (TREE_CODE (op0) == STRING_CST
3629                   && TREE_CODE (op1) == STRING_CST
3630                   && operand_equal_p (op0, op1, 1))
3631                 return null_pointer_node;
3632             }
3633         }
3634       break;
3635
3636     default:
3637       break;
3638     }
3639
3640   return 0;
3641 }
3642 \f
3643 /* Output assembler code for constant EXP to FILE, with no label.
3644    This includes the pseudo-op such as ".int" or ".byte", and a newline.
3645    Assumes output_addressed_constants has been done on EXP already.
3646
3647    Generate exactly SIZE bytes of assembler data, padding at the end
3648    with zeros if necessary.  SIZE must always be specified.
3649
3650    SIZE is important for structure constructors,
3651    since trailing members may have been omitted from the constructor.
3652    It is also important for initialization of arrays from string constants
3653    since the full length of the string constant might not be wanted.
3654    It is also needed for initialization of unions, where the initializer's
3655    type is just one member, and that may not be as long as the union.
3656
3657    There a case in which we would fail to output exactly SIZE bytes:
3658    for a structure constructor that wants to produce more than SIZE bytes.
3659    But such constructors will never be generated for any possible input.
3660
3661    ALIGN is the alignment of the data in bits.  */
3662
3663 void
3664 output_constant (tree exp, unsigned HOST_WIDE_INT size, unsigned int align)
3665 {
3666   enum tree_code code;
3667   unsigned HOST_WIDE_INT thissize;
3668
3669   /* Some front-ends use constants other than the standard language-independent
3670      varieties, but which may still be output directly.  Give the front-end a
3671      chance to convert EXP to a language-independent representation.  */
3672   exp = lang_hooks.expand_constant (exp);
3673
3674   if (size == 0 || flag_syntax_only)
3675     return;
3676
3677   /* Eliminate any conversions since we'll be outputting the underlying
3678      constant.  */
3679   while (TREE_CODE (exp) == NOP_EXPR || TREE_CODE (exp) == CONVERT_EXPR
3680          || TREE_CODE (exp) == NON_LVALUE_EXPR
3681          || TREE_CODE (exp) == VIEW_CONVERT_EXPR)
3682     exp = TREE_OPERAND (exp, 0);
3683
3684   code = TREE_CODE (TREE_TYPE (exp));
3685   thissize = int_size_in_bytes (TREE_TYPE (exp));
3686
3687   /* Allow a constructor with no elements for any data type.
3688      This means to fill the space with zeros.  */
3689   if (TREE_CODE (exp) == CONSTRUCTOR && CONSTRUCTOR_ELTS (exp) == 0)
3690     {
3691       assemble_zeros (size);
3692       return;
3693     }
3694
3695   if (TREE_CODE (exp) == FDESC_EXPR)
3696     {
3697 #ifdef ASM_OUTPUT_FDESC
3698       HOST_WIDE_INT part = tree_low_cst (TREE_OPERAND (exp, 1), 0);
3699       tree decl = TREE_OPERAND (exp, 0);
3700       ASM_OUTPUT_FDESC (asm_out_file, decl, part);
3701 #else
3702       abort ();
3703 #endif
3704       return;
3705     }
3706
3707   /* Now output the underlying data.  If we've handling the padding, return.
3708      Otherwise, break and ensure SIZE is the size written.  */
3709   switch (code)
3710     {
3711     case CHAR_TYPE:
3712     case BOOLEAN_TYPE:
3713     case INTEGER_TYPE:
3714     case ENUMERAL_TYPE:
3715     case POINTER_TYPE:
3716     case REFERENCE_TYPE:
3717     case OFFSET_TYPE:
3718       if (! assemble_integer (expand_expr (exp, NULL_RTX, VOIDmode,
3719                                            EXPAND_INITIALIZER),
3720                               MIN (size, thissize), align, 0))
3721         error ("initializer for integer value is too complicated");
3722       break;
3723
3724     case REAL_TYPE:
3725       if (TREE_CODE (exp) != REAL_CST)
3726         error ("initializer for floating value is not a floating constant");
3727
3728       assemble_real (TREE_REAL_CST (exp), TYPE_MODE (TREE_TYPE (exp)), align);
3729       break;
3730
3731     case COMPLEX_TYPE:
3732       output_constant (TREE_REALPART (exp), thissize / 2, align);
3733       output_constant (TREE_IMAGPART (exp), thissize / 2,
3734                        min_align (align, BITS_PER_UNIT * (thissize / 2)));
3735       break;
3736
3737     case ARRAY_TYPE:
3738     case VECTOR_TYPE:
3739       if (TREE_CODE (exp) == CONSTRUCTOR)
3740         {
3741           output_constructor (exp, size, align);
3742           return;
3743         }
3744       else if (TREE_CODE (exp) == STRING_CST)
3745         {
3746           thissize = MIN ((unsigned HOST_WIDE_INT)TREE_STRING_LENGTH (exp),
3747                           size);
3748           assemble_string (TREE_STRING_POINTER (exp), thissize);
3749         }
3750       else if (TREE_CODE (exp) == VECTOR_CST)
3751         {
3752           int elt_size;
3753           tree link;
3754           unsigned int nalign;
3755           enum machine_mode inner;
3756
3757           inner = TYPE_MODE (TREE_TYPE (TREE_TYPE (exp)));
3758           nalign = MIN (align, GET_MODE_ALIGNMENT (inner));
3759
3760           elt_size = GET_MODE_SIZE (inner);
3761
3762           link = TREE_VECTOR_CST_ELTS (exp);
3763           output_constant (TREE_VALUE (link), elt_size, align);
3764           while ((link = TREE_CHAIN (link)) != NULL)
3765             output_constant (TREE_VALUE (link), elt_size, nalign);
3766         }
3767       else
3768         abort ();
3769       break;
3770
3771     case RECORD_TYPE:
3772     case UNION_TYPE:
3773       if (TREE_CODE (exp) == CONSTRUCTOR)
3774         output_constructor (exp, size, align);
3775       else
3776         abort ();
3777       return;
3778
3779     case SET_TYPE:
3780       if (TREE_CODE (exp) == INTEGER_CST)
3781         assemble_integer (expand_expr (exp, NULL_RTX,
3782                                        VOIDmode, EXPAND_INITIALIZER),
3783                           thissize, align, 1);
3784       else if (TREE_CODE (exp) == CONSTRUCTOR)
3785         {
3786           unsigned char *buffer = alloca (thissize);
3787           if (get_set_constructor_bytes (exp, buffer, thissize))
3788             abort ();
3789           assemble_string ((char *) buffer, thissize);
3790         }
3791       else
3792         error ("unknown set constructor type");
3793       return;
3794
3795     case ERROR_MARK:
3796       return;
3797
3798     default:
3799       abort ();
3800     }
3801
3802   if (size > thissize)
3803     assemble_zeros (size - thissize);
3804 }
3805
3806 \f
3807 /* Subroutine of output_constructor, used for computing the size of
3808    arrays of unspecified length.  VAL must be a CONSTRUCTOR of an array
3809    type with an unspecified upper bound.  */
3810
3811 static unsigned HOST_WIDE_INT
3812 array_size_for_constructor (tree val)
3813 {
3814   tree max_index, i;
3815
3816   /* This code used to attempt to handle string constants that are not
3817      arrays of single-bytes, but nothing else does, so there's no point in
3818      doing it here.  */
3819   if (TREE_CODE (val) == STRING_CST)
3820     return TREE_STRING_LENGTH (val);
3821
3822   max_index = NULL_TREE;
3823   for (i = CONSTRUCTOR_ELTS (val); i; i = TREE_CHAIN (i))
3824     {
3825       tree index = TREE_PURPOSE (i);
3826
3827       if (TREE_CODE (index) == RANGE_EXPR)
3828         index = TREE_OPERAND (index, 1);
3829       if (max_index == NULL_TREE || tree_int_cst_lt (max_index, index))
3830         max_index = index;
3831     }
3832
3833   if (max_index == NULL_TREE)
3834     return 0;
3835
3836   /* Compute the total number of array elements.  */
3837   i = size_binop (MINUS_EXPR, convert (sizetype, max_index),
3838                   convert (sizetype,
3839                            TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (val)))));
3840   i = size_binop (PLUS_EXPR, i, convert (sizetype, integer_one_node));
3841
3842   /* Multiply by the array element unit size to find number of bytes.  */
3843   i = size_binop (MULT_EXPR, i, TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (val))));
3844
3845   return tree_low_cst (i, 1);
3846 }
3847
3848 /* Subroutine of output_constant, used for CONSTRUCTORs (aggregate constants).
3849    Generate at least SIZE bytes, padding if necessary.  */
3850
3851 static void
3852 output_constructor (tree exp, unsigned HOST_WIDE_INT size,
3853                     unsigned int align)
3854 {
3855   tree type = TREE_TYPE (exp);
3856   tree link, field = 0;
3857   tree min_index = 0;
3858   /* Number of bytes output or skipped so far.
3859      In other words, current position within the constructor.  */
3860   HOST_WIDE_INT total_bytes = 0;
3861   /* Nonzero means BYTE contains part of a byte, to be output.  */
3862   int byte_buffer_in_use = 0;
3863   int byte = 0;
3864
3865   if (HOST_BITS_PER_WIDE_INT < BITS_PER_UNIT)
3866     abort ();
3867
3868   if (TREE_CODE (type) == RECORD_TYPE)
3869     field = TYPE_FIELDS (type);
3870
3871   if (TREE_CODE (type) == ARRAY_TYPE
3872       && TYPE_DOMAIN (type) != 0)
3873     min_index = TYPE_MIN_VALUE (TYPE_DOMAIN (type));
3874
3875   /* As LINK goes through the elements of the constant,
3876      FIELD goes through the structure fields, if the constant is a structure.
3877      if the constant is a union, then we override this,
3878      by getting the field from the TREE_LIST element.
3879      But the constant could also be an array.  Then FIELD is zero.
3880
3881      There is always a maximum of one element in the chain LINK for unions
3882      (even if the initializer in a source program incorrectly contains
3883      more one).  */
3884   for (link = CONSTRUCTOR_ELTS (exp);
3885        link;
3886        link = TREE_CHAIN (link),
3887        field = field ? TREE_CHAIN (field) : 0)
3888     {
3889       tree val = TREE_VALUE (link);
3890       tree index = 0;
3891
3892       /* The element in a union constructor specifies the proper field
3893          or index.  */
3894       if ((TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE
3895            || TREE_CODE (type) == QUAL_UNION_TYPE)
3896           && TREE_PURPOSE (link) != 0)
3897         field = TREE_PURPOSE (link);
3898
3899       else if (TREE_CODE (type) == ARRAY_TYPE)
3900         index = TREE_PURPOSE (link);
3901
3902 #ifdef ASM_COMMENT_START
3903       if (field && flag_verbose_asm)
3904         fprintf (asm_out_file, "%s %s:\n",
3905                  ASM_COMMENT_START,
3906                  DECL_NAME (field)
3907                  ? IDENTIFIER_POINTER (DECL_NAME (field))
3908                  : "<anonymous>");
3909 #endif
3910
3911       /* Eliminate the marker that makes a cast not be an lvalue.  */
3912       if (val != 0)
3913         STRIP_NOPS (val);
3914
3915       if (index && TREE_CODE (index) == RANGE_EXPR)
3916         {
3917           unsigned HOST_WIDE_INT fieldsize
3918             = int_size_in_bytes (TREE_TYPE (type));
3919           HOST_WIDE_INT lo_index = tree_low_cst (TREE_OPERAND (index, 0), 0);
3920           HOST_WIDE_INT hi_index = tree_low_cst (TREE_OPERAND (index, 1), 0);
3921           HOST_WIDE_INT index;
3922           unsigned int align2 = min_align (align, fieldsize * BITS_PER_UNIT);
3923
3924           for (index = lo_index; index <= hi_index; index++)
3925             {
3926               /* Output the element's initial value.  */
3927               if (val == 0)
3928                 assemble_zeros (fieldsize);
3929               else
3930                 output_constant (val, fieldsize, align2);
3931
3932               /* Count its size.  */
3933               total_bytes += fieldsize;
3934             }
3935         }
3936       else if (field == 0 || !DECL_BIT_FIELD (field))
3937         {
3938           /* An element that is not a bit-field.  */
3939
3940           unsigned HOST_WIDE_INT fieldsize;
3941           /* Since this structure is static,
3942              we know the positions are constant.  */
3943           HOST_WIDE_INT pos = field ? int_byte_position (field) : 0;
3944           unsigned int align2;
3945
3946           if (index != 0)
3947             pos = (tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (val)), 1)
3948                    * (tree_low_cst (index, 0) - tree_low_cst (min_index, 0)));
3949
3950           /* Output any buffered-up bit-fields preceding this element.  */
3951           if (byte_buffer_in_use)
3952             {
3953               assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1);
3954               total_bytes++;
3955               byte_buffer_in_use = 0;
3956             }
3957
3958           /* Advance to offset of this element.
3959              Note no alignment needed in an array, since that is guaranteed
3960              if each element has the proper size.  */
3961           if ((field != 0 || index != 0) && pos != total_bytes)
3962             {
3963               assemble_zeros (pos - total_bytes);
3964               total_bytes = pos;
3965             }
3966
3967           /* Find the alignment of this element.  */
3968           align2 = min_align (align, BITS_PER_UNIT * pos);
3969
3970           /* Determine size this element should occupy.  */
3971           if (field)
3972             {
3973               fieldsize = 0;
3974
3975               /* If this is an array with an unspecified upper bound,
3976                  the initializer determines the size.  */
3977               /* ??? This ought to only checked if DECL_SIZE_UNIT is NULL,
3978                  but we cannot do this until the deprecated support for
3979                  initializing zero-length array members is removed.  */
3980               if (TREE_CODE (TREE_TYPE (field)) == ARRAY_TYPE
3981                   && TYPE_DOMAIN (TREE_TYPE (field))
3982                   && ! TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (field))))
3983                 {
3984                   fieldsize = array_size_for_constructor (val);
3985                   /* Given a non-empty initialization, this field had
3986                      better be last.  */
3987                   if (fieldsize != 0 && TREE_CHAIN (field) != NULL_TREE)
3988                     abort ();
3989                 }
3990               else if (DECL_SIZE_UNIT (field))
3991                 {
3992                   /* ??? This can't be right.  If the decl size overflows
3993                      a host integer we will silently emit no data.  */
3994                   if (host_integerp (DECL_SIZE_UNIT (field), 1))
3995                     fieldsize = tree_low_cst (DECL_SIZE_UNIT (field), 1);
3996                 }
3997             }
3998           else
3999             fieldsize = int_size_in_bytes (TREE_TYPE (type));
4000
4001           /* Output the element's initial value.  */
4002           if (val == 0)
4003             assemble_zeros (fieldsize);
4004           else
4005             output_constant (val, fieldsize, align2);
4006
4007           /* Count its size.  */
4008           total_bytes += fieldsize;
4009         }
4010       else if (val != 0 && TREE_CODE (val) != INTEGER_CST)
4011         error ("invalid initial value for member %qs",
4012                IDENTIFIER_POINTER (DECL_NAME (field)));
4013       else
4014         {
4015           /* Element that is a bit-field.  */
4016
4017           HOST_WIDE_INT next_offset = int_bit_position (field);
4018           HOST_WIDE_INT end_offset
4019             = (next_offset + tree_low_cst (DECL_SIZE (field), 1));
4020
4021           if (val == 0)
4022             val = integer_zero_node;
4023
4024           /* If this field does not start in this (or, next) byte,
4025              skip some bytes.  */
4026           if (next_offset / BITS_PER_UNIT != total_bytes)
4027             {
4028               /* Output remnant of any bit field in previous bytes.  */
4029               if (byte_buffer_in_use)
4030                 {
4031                   assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1);
4032                   total_bytes++;
4033                   byte_buffer_in_use = 0;
4034                 }
4035
4036               /* If still not at proper byte, advance to there.  */
4037               if (next_offset / BITS_PER_UNIT != total_bytes)
4038                 {
4039                   assemble_zeros (next_offset / BITS_PER_UNIT - total_bytes);
4040                   total_bytes = next_offset / BITS_PER_UNIT;
4041                 }
4042             }
4043
4044           if (! byte_buffer_in_use)
4045             byte = 0;
4046
4047           /* We must split the element into pieces that fall within
4048              separate bytes, and combine each byte with previous or
4049              following bit-fields.  */
4050
4051           /* next_offset is the offset n fbits from the beginning of
4052              the structure to the next bit of this element to be processed.
4053              end_offset is the offset of the first bit past the end of
4054              this element.  */
4055           while (next_offset < end_offset)
4056             {
4057               int this_time;
4058               int shift;
4059               HOST_WIDE_INT value;
4060               HOST_WIDE_INT next_byte = next_offset / BITS_PER_UNIT;
4061               HOST_WIDE_INT next_bit = next_offset % BITS_PER_UNIT;
4062
4063               /* Advance from byte to byte
4064                  within this element when necessary.  */
4065               while (next_byte != total_bytes)
4066                 {
4067                   assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1);
4068                   total_bytes++;
4069                   byte = 0;
4070                 }
4071
4072               /* Number of bits we can process at once
4073                  (all part of the same byte).  */
4074               this_time = MIN (end_offset - next_offset,
4075                                BITS_PER_UNIT - next_bit);
4076               if (BYTES_BIG_ENDIAN)
4077                 {
4078                   /* On big-endian machine, take the most significant bits
4079                      first (of the bits that are significant)
4080                      and put them into bytes from the most significant end.  */
4081                   shift = end_offset - next_offset - this_time;
4082
4083                   /* Don't try to take a bunch of bits that cross
4084                      the word boundary in the INTEGER_CST. We can
4085                      only select bits from the LOW or HIGH part
4086                      not from both.  */
4087                   if (shift < HOST_BITS_PER_WIDE_INT
4088                       && shift + this_time > HOST_BITS_PER_WIDE_INT)
4089                     {
4090                       this_time = shift + this_time - HOST_BITS_PER_WIDE_INT;
4091                       shift = HOST_BITS_PER_WIDE_INT;
4092                     }
4093
4094                   /* Now get the bits from the appropriate constant word.  */
4095                   if (shift < HOST_BITS_PER_WIDE_INT)
4096                     value = TREE_INT_CST_LOW (val);
4097                   else if (shift < 2 * HOST_BITS_PER_WIDE_INT)
4098                     {
4099                       value = TREE_INT_CST_HIGH (val);
4100                       shift -= HOST_BITS_PER_WIDE_INT;
4101                     }
4102                   else
4103                     abort ();
4104
4105                   /* Get the result. This works only when:
4106                      1 <= this_time <= HOST_BITS_PER_WIDE_INT.  */
4107                   byte |= (((value >> shift)
4108                             & (((HOST_WIDE_INT) 2 << (this_time - 1)) - 1))
4109                            << (BITS_PER_UNIT - this_time - next_bit));
4110                 }
4111               else
4112                 {
4113                   /* On little-endian machines,
4114                      take first the least significant bits of the value
4115                      and pack them starting at the least significant
4116                      bits of the bytes.  */
4117                   shift = next_offset - int_bit_position (field);
4118
4119                   /* Don't try to take a bunch of bits that cross
4120                      the word boundary in the INTEGER_CST. We can
4121                      only select bits from the LOW or HIGH part
4122                      not from both.  */
4123                   if (shift < HOST_BITS_PER_WIDE_INT
4124                       && shift + this_time > HOST_BITS_PER_WIDE_INT)
4125                     this_time = (HOST_BITS_PER_WIDE_INT - shift);
4126
4127                   /* Now get the bits from the appropriate constant word.  */
4128                   if (shift < HOST_BITS_PER_WIDE_INT)
4129                     value = TREE_INT_CST_LOW (val);
4130                   else if (shift < 2 * HOST_BITS_PER_WIDE_INT)
4131                     {
4132                       value = TREE_INT_CST_HIGH (val);
4133                       shift -= HOST_BITS_PER_WIDE_INT;
4134                     }
4135                   else
4136                     abort ();
4137
4138                   /* Get the result. This works only when:
4139                      1 <= this_time <= HOST_BITS_PER_WIDE_INT.  */
4140                   byte |= (((value >> shift)
4141                             & (((HOST_WIDE_INT) 2 << (this_time - 1)) - 1))
4142                            << next_bit);
4143                 }
4144
4145               next_offset += this_time;
4146               byte_buffer_in_use = 1;
4147             }
4148         }
4149     }
4150
4151   if (byte_buffer_in_use)
4152     {
4153       assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1);
4154       total_bytes++;
4155     }
4156
4157   if ((unsigned HOST_WIDE_INT)total_bytes < size)
4158     assemble_zeros (size - total_bytes);
4159 }
4160
4161 /* This TREE_LIST contains any weak symbol declarations waiting
4162    to be emitted.  */
4163 static GTY(()) tree weak_decls;
4164
4165 /* Mark DECL as weak.  */
4166
4167 static void
4168 mark_weak (tree decl)
4169 {
4170   DECL_WEAK (decl) = 1;
4171
4172   if (DECL_RTL_SET_P (decl)
4173       && MEM_P (DECL_RTL (decl))
4174       && XEXP (DECL_RTL (decl), 0)
4175       && GET_CODE (XEXP (DECL_RTL (decl), 0)) == SYMBOL_REF)
4176     SYMBOL_REF_WEAK (XEXP (DECL_RTL (decl), 0)) = 1;
4177 }
4178
4179 /* Merge weak status between NEWDECL and OLDDECL.  */
4180
4181 void
4182 merge_weak (tree newdecl, tree olddecl)
4183 {
4184   if (DECL_WEAK (newdecl) == DECL_WEAK (olddecl))
4185     return;
4186
4187   if (DECL_WEAK (newdecl))
4188     {
4189       tree wd;
4190
4191       /* NEWDECL is weak, but OLDDECL is not.  */
4192
4193       /* If we already output the OLDDECL, we're in trouble; we can't
4194          go back and make it weak.  This error cannot caught in
4195          declare_weak because the NEWDECL and OLDDECL was not yet
4196          been merged; therefore, TREE_ASM_WRITTEN was not set.  */
4197       if (TREE_ASM_WRITTEN (olddecl))
4198         error ("%Jweak declaration of %qD must precede definition",
4199                newdecl, newdecl);
4200
4201       /* If we've already generated rtl referencing OLDDECL, we may
4202          have done so in a way that will not function properly with
4203          a weak symbol.  */
4204       else if (TREE_USED (olddecl)
4205                && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (olddecl)))
4206         warning ("%Jweak declaration of %qD after first use results "
4207                  "in unspecified behavior", newdecl, newdecl);
4208
4209       if (SUPPORTS_WEAK)
4210         {
4211           /* We put the NEWDECL on the weak_decls list at some point.
4212              Replace it with the OLDDECL.  */
4213           for (wd = weak_decls; wd; wd = TREE_CHAIN (wd))
4214             if (TREE_VALUE (wd) == newdecl)
4215               {
4216                 TREE_VALUE (wd) = olddecl;
4217                 break;
4218               }
4219           /* We may not find the entry on the list.  If NEWDECL is a
4220              weak alias, then we will have already called
4221              globalize_decl to remove the entry; in that case, we do
4222              not need to do anything.  */
4223         }
4224
4225       /* Make the OLDDECL weak; it's OLDDECL that we'll be keeping.  */
4226       mark_weak (olddecl);
4227     }
4228   else
4229     /* OLDDECL was weak, but NEWDECL was not explicitly marked as
4230        weak.  Just update NEWDECL to indicate that it's weak too.  */
4231     mark_weak (newdecl);
4232 }
4233
4234 /* Declare DECL to be a weak symbol.  */
4235
4236 void
4237 declare_weak (tree decl)
4238 {
4239   if (! TREE_PUBLIC (decl))
4240     error ("%Jweak declaration of %qD must be public", decl, decl);
4241   else if (TREE_CODE (decl) == FUNCTION_DECL && TREE_ASM_WRITTEN (decl))
4242     error ("%Jweak declaration of %qD must precede definition", decl, decl);
4243   else if (SUPPORTS_WEAK)
4244     {
4245       if (! DECL_WEAK (decl))
4246         weak_decls = tree_cons (NULL, decl, weak_decls);
4247     }
4248   else
4249     warning ("%Jweak declaration of %qD not supported", decl, decl);
4250
4251   mark_weak (decl);
4252 }
4253
4254 /* Emit any pending weak declarations.  */
4255
4256 void
4257 weak_finish (void)
4258 {
4259   tree t;
4260
4261   for (t = weak_decls; t; t = TREE_CHAIN (t))
4262     {
4263       tree decl = TREE_VALUE (t);
4264 #if defined (ASM_WEAKEN_DECL) || defined (ASM_WEAKEN_LABEL)
4265       const char *const name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
4266 #endif
4267
4268       if (! TREE_USED (decl))
4269         continue;
4270
4271 #ifdef ASM_WEAKEN_DECL
4272       ASM_WEAKEN_DECL (asm_out_file, decl, name, NULL);
4273 #else
4274 #ifdef ASM_WEAKEN_LABEL
4275       ASM_WEAKEN_LABEL (asm_out_file, name);
4276 #else
4277 #ifdef ASM_OUTPUT_WEAK_ALIAS
4278       warning ("only weak aliases are supported in this configuration");
4279       return;
4280 #endif
4281 #endif
4282 #endif
4283     }
4284 }
4285
4286 /* Emit the assembly bits to indicate that DECL is globally visible.  */
4287
4288 static void
4289 globalize_decl (tree decl)
4290 {
4291   const char *name = XSTR (XEXP (DECL_RTL (decl), 0), 0);
4292
4293 #if defined (ASM_WEAKEN_LABEL) || defined (ASM_WEAKEN_DECL)
4294   if (DECL_WEAK (decl))
4295     {
4296       tree *p, t;
4297
4298 #ifdef ASM_WEAKEN_DECL
4299       ASM_WEAKEN_DECL (asm_out_file, decl, name, 0);
4300 #else
4301       ASM_WEAKEN_LABEL (asm_out_file, name);
4302 #endif
4303
4304       /* Remove this function from the pending weak list so that
4305          we do not emit multiple .weak directives for it.  */
4306       for (p = &weak_decls; (t = *p) ; )
4307         {
4308           if (DECL_ASSEMBLER_NAME (decl) == DECL_ASSEMBLER_NAME (TREE_VALUE (t)))
4309             *p = TREE_CHAIN (t);
4310           else
4311             p = &TREE_CHAIN (t);
4312         }
4313       return;
4314     }
4315 #elif defined(ASM_MAKE_LABEL_LINKONCE)
4316   if (DECL_ONE_ONLY (decl))
4317     ASM_MAKE_LABEL_LINKONCE (asm_out_file, name);
4318 #endif
4319
4320   targetm.asm_out.globalize_label (asm_out_file, name);
4321 }
4322
4323 /* Emit an assembler directive to make the symbol for DECL an alias to
4324    the symbol for TARGET.  */
4325
4326 void
4327 assemble_alias (tree decl, tree target ATTRIBUTE_UNUSED)
4328 {
4329   const char *name;
4330
4331   /* We must force creation of DECL_RTL for debug info generation, even though
4332      we don't use it here.  */
4333   make_decl_rtl (decl);
4334
4335   name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
4336
4337 #ifdef ASM_OUTPUT_DEF
4338   /* Make name accessible from other files, if appropriate.  */
4339
4340   if (TREE_PUBLIC (decl))
4341     {
4342       globalize_decl (decl);
4343       maybe_assemble_visibility (decl);
4344     }
4345
4346 #ifdef ASM_OUTPUT_DEF_FROM_DECLS
4347   ASM_OUTPUT_DEF_FROM_DECLS (asm_out_file, decl, target);
4348 #else
4349   ASM_OUTPUT_DEF (asm_out_file, name, IDENTIFIER_POINTER (target));
4350 #endif
4351 #else /* !ASM_OUTPUT_DEF */
4352 #if defined (ASM_OUTPUT_WEAK_ALIAS) || defined (ASM_WEAKEN_DECL)
4353   if (DECL_WEAK (decl))
4354     {
4355       tree *p, t;
4356 #ifdef ASM_WEAKEN_DECL
4357       ASM_WEAKEN_DECL (asm_out_file, decl, name, IDENTIFIER_POINTER (target));
4358 #else
4359       ASM_OUTPUT_WEAK_ALIAS (asm_out_file, name, IDENTIFIER_POINTER (target));
4360 #endif
4361       /* Remove this function from the pending weak list so that
4362          we do not emit multiple .weak directives for it.  */
4363       for (p = &weak_decls; (t = *p) ; )
4364         if (DECL_ASSEMBLER_NAME (decl)
4365             == DECL_ASSEMBLER_NAME (TREE_VALUE (t)))
4366           *p = TREE_CHAIN (t);
4367         else
4368           p = &TREE_CHAIN (t);
4369     }
4370   else
4371     warning ("only weak aliases are supported in this configuration");
4372
4373 #else
4374   warning ("alias definitions not supported in this configuration; ignored");
4375 #endif
4376 #endif
4377
4378   TREE_USED (decl) = 1;
4379   TREE_ASM_WRITTEN (decl) = 1;
4380   TREE_ASM_WRITTEN (DECL_ASSEMBLER_NAME (decl)) = 1;
4381 }
4382
4383 /* Emit an assembler directive to set symbol for DECL visibility to
4384    the visibility type VIS, which must not be VISIBILITY_DEFAULT.  */
4385
4386 void
4387 default_assemble_visibility (tree decl, int vis)
4388 {
4389   static const char * const visibility_types[] = {
4390     NULL, "internal", "hidden", "protected"
4391   };
4392
4393   const char *name, *type;
4394
4395   name = (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
4396   type = visibility_types[vis];
4397
4398 #ifdef HAVE_GAS_HIDDEN
4399   fprintf (asm_out_file, "\t.%s\t", type);
4400   assemble_name (asm_out_file, name);
4401   fprintf (asm_out_file, "\n");
4402 #else
4403   warning ("visibility attribute not supported in this configuration; ignored");
4404 #endif
4405 }
4406
4407 /* A helper function to call assemble_visibility when needed for a decl.  */
4408
4409 static void
4410 maybe_assemble_visibility (tree decl)
4411 {
4412   enum symbol_visibility vis = DECL_VISIBILITY (decl);
4413
4414   if (vis != VISIBILITY_DEFAULT)
4415     targetm.asm_out.visibility (decl, vis);
4416 }
4417
4418 /* Returns 1 if the target configuration supports defining public symbols
4419    so that one of them will be chosen at link time instead of generating a
4420    multiply-defined symbol error, whether through the use of weak symbols or
4421    a target-specific mechanism for having duplicates discarded.  */
4422
4423 int
4424 supports_one_only (void)
4425 {
4426   if (SUPPORTS_ONE_ONLY)
4427     return 1;
4428   return SUPPORTS_WEAK;
4429 }
4430
4431 /* Set up DECL as a public symbol that can be defined in multiple
4432    translation units without generating a linker error.  */
4433
4434 void
4435 make_decl_one_only (tree decl)
4436 {
4437   if (TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != FUNCTION_DECL)
4438     abort ();
4439
4440   TREE_PUBLIC (decl) = 1;
4441
4442   if (SUPPORTS_ONE_ONLY)
4443     {
4444 #ifdef MAKE_DECL_ONE_ONLY
4445       MAKE_DECL_ONE_ONLY (decl);
4446 #endif
4447       DECL_ONE_ONLY (decl) = 1;
4448     }
4449   else if (TREE_CODE (decl) == VAR_DECL
4450       && (DECL_INITIAL (decl) == 0 || DECL_INITIAL (decl) == error_mark_node))
4451     DECL_COMMON (decl) = 1;
4452   else if (SUPPORTS_WEAK)
4453     DECL_WEAK (decl) = 1;
4454   else
4455     abort ();
4456 }
4457
4458 void
4459 init_varasm_once (void)
4460 {
4461   in_named_htab = htab_create_ggc (31, in_named_entry_hash,
4462                                    in_named_entry_eq, NULL);
4463   const_desc_htab = htab_create_ggc (1009, const_desc_hash,
4464                                      const_desc_eq, NULL);
4465
4466   const_alias_set = new_alias_set ();
4467 }
4468
4469 enum tls_model
4470 decl_tls_model (tree decl)
4471 {
4472   enum tls_model kind;
4473   tree attr = lookup_attribute ("tls_model", DECL_ATTRIBUTES (decl));
4474   bool is_local;
4475
4476   if (attr)
4477     {
4478       attr = TREE_VALUE (TREE_VALUE (attr));
4479       if (TREE_CODE (attr) != STRING_CST)
4480         abort ();
4481       if (!strcmp (TREE_STRING_POINTER (attr), "local-exec"))
4482         kind = TLS_MODEL_LOCAL_EXEC;
4483       else if (!strcmp (TREE_STRING_POINTER (attr), "initial-exec"))
4484         kind = TLS_MODEL_INITIAL_EXEC;
4485       else if (!strcmp (TREE_STRING_POINTER (attr), "local-dynamic"))
4486         kind = optimize ? TLS_MODEL_LOCAL_DYNAMIC : TLS_MODEL_GLOBAL_DYNAMIC;
4487       else if (!strcmp (TREE_STRING_POINTER (attr), "global-dynamic"))
4488         kind = TLS_MODEL_GLOBAL_DYNAMIC;
4489       else
4490         abort ();
4491       return kind;
4492     }
4493
4494   is_local = targetm.binds_local_p (decl);
4495   if (!flag_pic)
4496     {
4497       if (is_local)
4498         kind = TLS_MODEL_LOCAL_EXEC;
4499       else
4500         kind = TLS_MODEL_INITIAL_EXEC;
4501     }
4502   /* Local dynamic is inefficient when we're not combining the
4503      parts of the address.  */
4504   else if (optimize && is_local)
4505     kind = TLS_MODEL_LOCAL_DYNAMIC;
4506   else
4507     kind = TLS_MODEL_GLOBAL_DYNAMIC;
4508   if (kind < flag_tls_default)
4509     kind = flag_tls_default;
4510
4511   return kind;
4512 }
4513
4514 /* Select a set of attributes for section NAME based on the properties
4515    of DECL and whether or not RELOC indicates that DECL's initializer
4516    might contain runtime relocations.
4517
4518    We make the section read-only and executable for a function decl,
4519    read-only for a const data decl, and writable for a non-const data decl.  */
4520
4521 unsigned int
4522 default_section_type_flags (tree decl, const char *name, int reloc)
4523 {
4524   return default_section_type_flags_1 (decl, name, reloc, flag_pic);
4525 }
4526
4527 unsigned int
4528 default_section_type_flags_1 (tree decl, const char *name, int reloc,
4529                               int shlib)
4530 {
4531   unsigned int flags;
4532
4533   if (decl && TREE_CODE (decl) == FUNCTION_DECL)
4534     flags = SECTION_CODE;
4535   else if (decl && decl_readonly_section_1 (decl, reloc, shlib))
4536     flags = 0;
4537   else if (unlikely_text_section_name
4538            && strcmp (name, unlikely_text_section_name) == 0)
4539     flags = SECTION_CODE;
4540   else
4541     flags = SECTION_WRITE;
4542
4543   if (decl && DECL_ONE_ONLY (decl))
4544     flags |= SECTION_LINKONCE;
4545
4546   if (decl && TREE_CODE (decl) == VAR_DECL && DECL_THREAD_LOCAL (decl))
4547     flags |= SECTION_TLS | SECTION_WRITE;
4548
4549   if (strcmp (name, ".bss") == 0
4550       || strncmp (name, ".bss.", 5) == 0
4551       || strncmp (name, ".gnu.linkonce.b.", 16) == 0
4552       || strcmp (name, ".sbss") == 0
4553       || strncmp (name, ".sbss.", 6) == 0
4554       || strncmp (name, ".gnu.linkonce.sb.", 17) == 0
4555       || strcmp (name, ".tbss") == 0
4556       || strncmp (name, ".gnu.linkonce.tb.", 17) == 0)
4557     flags |= SECTION_BSS;
4558
4559   if (strcmp (name, ".tdata") == 0
4560       || strcmp (name, ".tbss") == 0
4561       || strncmp (name, ".gnu.linkonce.td.", 17) == 0
4562       || strncmp (name, ".gnu.linkonce.tb.", 17) == 0)
4563     flags |= SECTION_TLS;
4564
4565   /* These three sections have special ELF types.  They are neither
4566      SHT_PROGBITS nor SHT_NOBITS, so when changing sections we don't
4567      want to print a section type (@progbits or @nobits).  If someone
4568      is silly enough to emit code or TLS variables to one of these
4569      sections, then don't handle them specially.  */
4570   if (!(flags & (SECTION_CODE | SECTION_BSS | SECTION_TLS))
4571       && (strcmp (name, ".init_array") == 0
4572           || strcmp (name, ".fini_array") == 0
4573           || strcmp (name, ".preinit_array") == 0))
4574     flags |= SECTION_NOTYPE;
4575
4576   return flags;
4577 }
4578
4579 /* Output assembly to switch to section NAME with attribute FLAGS.
4580    Four variants for common object file formats.  */
4581
4582 void
4583 default_no_named_section (const char *name ATTRIBUTE_UNUSED,
4584                           unsigned int flags ATTRIBUTE_UNUSED,
4585                           tree decl ATTRIBUTE_UNUSED)
4586 {
4587   /* Some object formats don't support named sections at all.  The
4588      front-end should already have flagged this as an error.  */
4589   abort ();
4590 }
4591
4592 void
4593 default_elf_asm_named_section (const char *name, unsigned int flags,
4594                                tree decl ATTRIBUTE_UNUSED)
4595 {
4596   char flagchars[10], *f = flagchars;
4597
4598   /* If we have already declared this section, we can use an
4599      abbreviated form to switch back to it -- unless this section is
4600      part of a COMDAT groups, in which case GAS requires the full
4601      declaration every time.  */
4602   if (!(HAVE_GAS_COMDAT_GROUP && (flags & SECTION_LINKONCE))
4603       && ! named_section_first_declaration (name))
4604     {
4605       fprintf (asm_out_file, "\t.section\t%s\n", name);
4606       return;
4607     }
4608
4609   if (!(flags & SECTION_DEBUG))
4610     *f++ = 'a';
4611   if (flags & SECTION_WRITE)
4612     *f++ = 'w';
4613   if (flags & SECTION_CODE)
4614     *f++ = 'x';
4615   if (flags & SECTION_SMALL)
4616     *f++ = 's';
4617   if (flags & SECTION_MERGE)
4618     *f++ = 'M';
4619   if (flags & SECTION_STRINGS)
4620     *f++ = 'S';
4621   if (flags & SECTION_TLS)
4622     *f++ = 'T';
4623   if (HAVE_GAS_COMDAT_GROUP && (flags & SECTION_LINKONCE))
4624     *f++ = 'G';
4625   *f = '\0';
4626
4627   fprintf (asm_out_file, "\t.section\t%s,\"%s\"", name, flagchars);
4628
4629   if (!(flags & SECTION_NOTYPE))
4630     {
4631       const char *type;
4632       const char *format;
4633
4634       if (flags & SECTION_BSS)
4635         type = "nobits";
4636       else
4637         type = "progbits";
4638
4639       format = ",@%s";
4640 #ifdef ASM_COMMENT_START
4641       /* On platforms that use "@" as the assembly comment character,
4642          use "%" instead.  */
4643       if (strcmp (ASM_COMMENT_START, "@") == 0)
4644         format = ",%%%s";
4645 #endif
4646       fprintf (asm_out_file, format, type);
4647
4648       if (flags & SECTION_ENTSIZE)
4649         fprintf (asm_out_file, ",%d", flags & SECTION_ENTSIZE);
4650       if (HAVE_GAS_COMDAT_GROUP && (flags & SECTION_LINKONCE))
4651         fprintf (asm_out_file, ",%s,comdat",
4652                  lang_hooks.decls.comdat_group (decl));
4653     }
4654
4655   putc ('\n', asm_out_file);
4656 }
4657
4658 void
4659 default_coff_asm_named_section (const char *name, unsigned int flags,
4660                                 tree decl ATTRIBUTE_UNUSED)
4661 {
4662   char flagchars[8], *f = flagchars;
4663
4664   if (flags & SECTION_WRITE)
4665     *f++ = 'w';
4666   if (flags & SECTION_CODE)
4667     *f++ = 'x';
4668   *f = '\0';
4669
4670   fprintf (asm_out_file, "\t.section\t%s,\"%s\"\n", name, flagchars);
4671 }
4672
4673 void
4674 default_pe_asm_named_section (const char *name, unsigned int flags,
4675                               tree decl)
4676 {
4677   default_coff_asm_named_section (name, flags, decl);
4678
4679   if (flags & SECTION_LINKONCE)
4680     {
4681       /* Functions may have been compiled at various levels of
4682          optimization so we can't use `same_size' here.
4683          Instead, have the linker pick one.  */
4684       fprintf (asm_out_file, "\t.linkonce %s\n",
4685                (flags & SECTION_CODE ? "discard" : "same_size"));
4686     }
4687 }
4688 \f
4689 /* The lame default section selector.  */
4690
4691 void
4692 default_select_section (tree decl, int reloc,
4693                         unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED)
4694 {
4695   bool readonly = false;
4696
4697   if (DECL_P (decl))
4698     {
4699       if (decl_readonly_section (decl, reloc))
4700         readonly = true;
4701     }
4702   else if (TREE_CODE (decl) == CONSTRUCTOR)
4703     {
4704       if (! ((flag_pic && reloc)
4705              || !TREE_READONLY (decl)
4706              || TREE_SIDE_EFFECTS (decl)
4707              || !TREE_CONSTANT (decl)))
4708         readonly = true;
4709     }
4710   else if (TREE_CODE (decl) == STRING_CST)
4711     readonly = true;
4712   else if (! (flag_pic && reloc))
4713     readonly = true;
4714
4715   if (readonly)
4716     readonly_data_section ();
4717   else
4718     data_section ();
4719 }
4720
4721 /* A helper function for default_elf_select_section and
4722    default_elf_unique_section.  Categorizes the DECL.  */
4723
4724 enum section_category
4725 {
4726   SECCAT_TEXT,
4727
4728   SECCAT_RODATA,
4729   SECCAT_RODATA_MERGE_STR,
4730   SECCAT_RODATA_MERGE_STR_INIT,
4731   SECCAT_RODATA_MERGE_CONST,
4732   SECCAT_SRODATA,
4733
4734   SECCAT_DATA,
4735
4736   /* To optimize loading of shared programs, define following subsections
4737      of data section:
4738         _REL    Contains data that has relocations, so they get grouped
4739                 together and dynamic linker will visit fewer pages in memory.
4740         _RO     Contains data that is otherwise read-only.  This is useful
4741                 with prelinking as most relocations won't be dynamically
4742                 linked and thus stay read only.
4743         _LOCAL  Marks data containing relocations only to local objects.
4744                 These relocations will get fully resolved by prelinking.  */
4745   SECCAT_DATA_REL,
4746   SECCAT_DATA_REL_LOCAL,
4747   SECCAT_DATA_REL_RO,
4748   SECCAT_DATA_REL_RO_LOCAL,
4749
4750   SECCAT_SDATA,
4751   SECCAT_TDATA,
4752
4753   SECCAT_BSS,
4754   SECCAT_SBSS,
4755   SECCAT_TBSS
4756 };
4757
4758 static enum section_category
4759 categorize_decl_for_section (tree, int, int);
4760
4761 static enum section_category
4762 categorize_decl_for_section (tree decl, int reloc, int shlib)
4763 {
4764   enum section_category ret;
4765
4766   if (TREE_CODE (decl) == FUNCTION_DECL)
4767     return SECCAT_TEXT;
4768   else if (TREE_CODE (decl) == STRING_CST)
4769     {
4770       if (flag_mudflap) /* or !flag_merge_constants */
4771         return SECCAT_RODATA;
4772       else
4773         return SECCAT_RODATA_MERGE_STR;
4774     }
4775   else if (TREE_CODE (decl) == VAR_DECL)
4776     {
4777       if (DECL_INITIAL (decl) == NULL
4778           || DECL_INITIAL (decl) == error_mark_node
4779           || (flag_zero_initialized_in_bss
4780               /* Leave constant zeroes in .rodata so they can be shared.  */
4781               && !TREE_READONLY (decl)
4782               && initializer_zerop (DECL_INITIAL (decl))))
4783         ret = SECCAT_BSS;
4784       else if (! TREE_READONLY (decl)
4785                || TREE_SIDE_EFFECTS (decl)
4786                || ! TREE_CONSTANT (DECL_INITIAL (decl)))
4787         {
4788           if (shlib && (reloc & 2))
4789             ret = SECCAT_DATA_REL;
4790           else if (shlib && reloc)
4791             ret = SECCAT_DATA_REL_LOCAL;
4792           else
4793             ret = SECCAT_DATA;
4794         }
4795       else if (shlib && (reloc & 2))
4796         ret = SECCAT_DATA_REL_RO;
4797       else if (shlib && reloc)
4798         ret = SECCAT_DATA_REL_RO_LOCAL;
4799       else if (reloc || flag_merge_constants < 2)
4800         /* C and C++ don't allow different variables to share the same
4801            location.  -fmerge-all-constants allows even that (at the
4802            expense of not conforming).  */
4803         ret = SECCAT_RODATA;
4804       else if (TREE_CODE (DECL_INITIAL (decl)) == STRING_CST)
4805         ret = SECCAT_RODATA_MERGE_STR_INIT;
4806       else
4807         ret = SECCAT_RODATA_MERGE_CONST;
4808     }
4809   else if (TREE_CODE (decl) == CONSTRUCTOR)
4810     {
4811       if ((shlib && reloc)
4812           || TREE_SIDE_EFFECTS (decl)
4813           || ! TREE_CONSTANT (decl))
4814         ret = SECCAT_DATA;
4815       else
4816         ret = SECCAT_RODATA;
4817     }
4818   else
4819     ret = SECCAT_RODATA;
4820
4821   /* There are no read-only thread-local sections.  */
4822   if (TREE_CODE (decl) == VAR_DECL && DECL_THREAD_LOCAL (decl))
4823     {
4824       /* Note that this would be *just* SECCAT_BSS, except that there's
4825          no concept of a read-only thread-local-data section.  */
4826       if (ret == SECCAT_BSS
4827           || (flag_zero_initialized_in_bss
4828               && initializer_zerop (DECL_INITIAL (decl))))
4829         ret = SECCAT_TBSS;
4830       else
4831         ret = SECCAT_TDATA;
4832     }
4833
4834   /* If the target uses small data sections, select it.  */
4835   else if (targetm.in_small_data_p (decl))
4836     {
4837       if (ret == SECCAT_BSS)
4838         ret = SECCAT_SBSS;
4839       else if (targetm.have_srodata_section && ret == SECCAT_RODATA)
4840         ret = SECCAT_SRODATA;
4841       else
4842         ret = SECCAT_SDATA;
4843     }
4844
4845   return ret;
4846 }
4847
4848 bool
4849 decl_readonly_section (tree decl, int reloc)
4850 {
4851   return decl_readonly_section_1 (decl, reloc, flag_pic);
4852 }
4853
4854 bool
4855 decl_readonly_section_1 (tree decl, int reloc, int shlib)
4856 {
4857   switch (categorize_decl_for_section (decl, reloc, shlib))
4858     {
4859     case SECCAT_RODATA:
4860     case SECCAT_RODATA_MERGE_STR:
4861     case SECCAT_RODATA_MERGE_STR_INIT:
4862     case SECCAT_RODATA_MERGE_CONST:
4863     case SECCAT_SRODATA:
4864       return true;
4865       break;
4866     default:
4867       return false;
4868       break;
4869     }
4870 }
4871
4872 /* Select a section based on the above categorization.  */
4873
4874 void
4875 default_elf_select_section (tree decl, int reloc,
4876                             unsigned HOST_WIDE_INT align)
4877 {
4878   default_elf_select_section_1 (decl, reloc, align, flag_pic);
4879 }
4880
4881 void
4882 default_elf_select_section_1 (tree decl, int reloc,
4883                               unsigned HOST_WIDE_INT align, int shlib)
4884 {
4885   switch (categorize_decl_for_section (decl, reloc, shlib))
4886     {
4887     case SECCAT_TEXT:
4888       /* We're not supposed to be called on FUNCTION_DECLs.  */
4889       abort ();
4890     case SECCAT_RODATA:
4891       readonly_data_section ();
4892       break;
4893     case SECCAT_RODATA_MERGE_STR:
4894       mergeable_string_section (decl, align, 0);
4895       break;
4896     case SECCAT_RODATA_MERGE_STR_INIT:
4897       mergeable_string_section (DECL_INITIAL (decl), align, 0);
4898       break;
4899     case SECCAT_RODATA_MERGE_CONST:
4900       mergeable_constant_section (DECL_MODE (decl), align, 0);
4901       break;
4902     case SECCAT_SRODATA:
4903       named_section (NULL_TREE, ".sdata2", reloc);
4904       break;
4905     case SECCAT_DATA:
4906       data_section ();
4907       break;
4908     case SECCAT_DATA_REL:
4909       named_section (NULL_TREE, ".data.rel", reloc);
4910       break;
4911     case SECCAT_DATA_REL_LOCAL:
4912       named_section (NULL_TREE, ".data.rel.local", reloc);
4913       break;
4914     case SECCAT_DATA_REL_RO:
4915       named_section (NULL_TREE, ".data.rel.ro", reloc);
4916       break;
4917     case SECCAT_DATA_REL_RO_LOCAL:
4918       named_section (NULL_TREE, ".data.rel.ro.local", reloc);
4919       break;
4920     case SECCAT_SDATA:
4921       named_section (NULL_TREE, ".sdata", reloc);
4922       break;
4923     case SECCAT_TDATA:
4924       named_section (NULL_TREE, ".tdata", reloc);
4925       break;
4926     case SECCAT_BSS:
4927 #ifdef BSS_SECTION_ASM_OP
4928       bss_section ();
4929 #else
4930       named_section (NULL_TREE, ".bss", reloc);
4931 #endif
4932       break;
4933     case SECCAT_SBSS:
4934       named_section (NULL_TREE, ".sbss", reloc);
4935       break;
4936     case SECCAT_TBSS:
4937       named_section (NULL_TREE, ".tbss", reloc);
4938       break;
4939     default:
4940       abort ();
4941     }
4942 }
4943
4944 /* Construct a unique section name based on the decl name and the
4945    categorization performed above.  */
4946
4947 void
4948 default_unique_section (tree decl, int reloc)
4949 {
4950   default_unique_section_1 (decl, reloc, flag_pic);
4951 }
4952
4953 void
4954 default_unique_section_1 (tree decl, int reloc, int shlib)
4955 {
4956   bool one_only = DECL_ONE_ONLY (decl);
4957   const char *prefix, *name;
4958   size_t nlen, plen;
4959   char *string;
4960
4961   switch (categorize_decl_for_section (decl, reloc, shlib))
4962     {
4963     case SECCAT_TEXT:
4964       prefix = one_only ? ".gnu.linkonce.t." : ".text.";
4965       break;
4966     case SECCAT_RODATA:
4967     case SECCAT_RODATA_MERGE_STR:
4968     case SECCAT_RODATA_MERGE_STR_INIT:
4969     case SECCAT_RODATA_MERGE_CONST:
4970       prefix = one_only ? ".gnu.linkonce.r." : ".rodata.";
4971       break;
4972     case SECCAT_SRODATA:
4973       prefix = one_only ? ".gnu.linkonce.s2." : ".sdata2.";
4974       break;
4975     case SECCAT_DATA:
4976     case SECCAT_DATA_REL:
4977     case SECCAT_DATA_REL_LOCAL:
4978     case SECCAT_DATA_REL_RO:
4979     case SECCAT_DATA_REL_RO_LOCAL:
4980       prefix = one_only ? ".gnu.linkonce.d." : ".data.";
4981       break;
4982     case SECCAT_SDATA:
4983       prefix = one_only ? ".gnu.linkonce.s." : ".sdata.";
4984       break;
4985     case SECCAT_BSS:
4986       prefix = one_only ? ".gnu.linkonce.b." : ".bss.";
4987       break;
4988     case SECCAT_SBSS:
4989       prefix = one_only ? ".gnu.linkonce.sb." : ".sbss.";
4990       break;
4991     case SECCAT_TDATA:
4992       prefix = one_only ? ".gnu.linkonce.td." : ".tdata.";
4993       break;
4994     case SECCAT_TBSS:
4995       prefix = one_only ? ".gnu.linkonce.tb." : ".tbss.";
4996       break;
4997     default:
4998       abort ();
4999     }
5000   plen = strlen (prefix);
5001
5002   name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
5003   name = targetm.strip_name_encoding (name);
5004   nlen = strlen (name);
5005
5006   string = alloca (nlen + plen + 1);
5007   memcpy (string, prefix, plen);
5008   memcpy (string + plen, name, nlen + 1);
5009
5010   DECL_SECTION_NAME (decl) = build_string (nlen + plen, string);
5011 }
5012
5013 void
5014 default_select_rtx_section (enum machine_mode mode ATTRIBUTE_UNUSED,
5015                             rtx x,
5016                             unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED)
5017 {
5018   if (flag_pic)
5019     switch (GET_CODE (x))
5020       {
5021       case CONST:
5022       case SYMBOL_REF:
5023       case LABEL_REF:
5024         data_section ();
5025         return;
5026
5027       default:
5028         break;
5029       }
5030
5031   readonly_data_section ();
5032 }
5033
5034 void
5035 default_elf_select_rtx_section (enum machine_mode mode, rtx x,
5036                                 unsigned HOST_WIDE_INT align)
5037 {
5038   /* ??? Handle small data here somehow.  */
5039
5040   if (flag_pic)
5041     switch (GET_CODE (x))
5042       {
5043       case CONST:
5044       case SYMBOL_REF:
5045         named_section (NULL_TREE, ".data.rel.ro", 3);
5046         return;
5047
5048       case LABEL_REF:
5049         named_section (NULL_TREE, ".data.rel.ro.local", 1);
5050         return;
5051
5052       default:
5053         break;
5054       }
5055
5056   mergeable_constant_section (mode, align, 0);
5057 }
5058
5059 /* Set the generally applicable flags on the SYMBOL_REF for EXP.  */
5060
5061 void
5062 default_encode_section_info (tree decl, rtx rtl, int first ATTRIBUTE_UNUSED)
5063 {
5064   rtx symbol;
5065   int flags;
5066
5067   /* Careful not to prod global register variables.  */
5068   if (!MEM_P (rtl))
5069     return;
5070   symbol = XEXP (rtl, 0);
5071   if (GET_CODE (symbol) != SYMBOL_REF)
5072     return;
5073
5074   flags = 0;
5075   if (TREE_CODE (decl) == FUNCTION_DECL)
5076     flags |= SYMBOL_FLAG_FUNCTION;
5077   if (targetm.binds_local_p (decl))
5078     flags |= SYMBOL_FLAG_LOCAL;
5079   if (targetm.in_small_data_p (decl))
5080     flags |= SYMBOL_FLAG_SMALL;
5081   if (TREE_CODE (decl) == VAR_DECL && DECL_THREAD_LOCAL (decl))
5082     flags |= decl_tls_model (decl) << SYMBOL_FLAG_TLS_SHIFT;
5083   /* ??? Why is DECL_EXTERNAL ever set for non-PUBLIC names?  Without
5084      being PUBLIC, the thing *must* be defined in this translation unit.
5085      Prevent this buglet from being propagated into rtl code as well.  */
5086   if (DECL_P (decl) && DECL_EXTERNAL (decl) && TREE_PUBLIC (decl))
5087     flags |= SYMBOL_FLAG_EXTERNAL;
5088
5089   SYMBOL_REF_FLAGS (symbol) = flags;
5090 }
5091
5092 /* By default, we do nothing for encode_section_info, so we need not
5093    do anything but discard the '*' marker.  */
5094
5095 const char *
5096 default_strip_name_encoding (const char *str)
5097 {
5098   return str + (*str == '*');
5099 }
5100
5101 /* Assume ELF-ish defaults, since that's pretty much the most liberal
5102    wrt cross-module name binding.  */
5103
5104 bool
5105 default_binds_local_p (tree exp)
5106 {
5107   return default_binds_local_p_1 (exp, flag_shlib);
5108 }
5109
5110 bool
5111 default_binds_local_p_1 (tree exp, int shlib)
5112 {
5113   bool local_p;
5114
5115   /* A non-decl is an entry in the constant pool.  */
5116   if (!DECL_P (exp))
5117     local_p = true;
5118   /* Static variables are always local.  */
5119   else if (! TREE_PUBLIC (exp))
5120     local_p = true;
5121   /* A variable is local if the user explicitly tells us so.  */
5122   else if (DECL_VISIBILITY_SPECIFIED (exp) && DECL_VISIBILITY (exp) != VISIBILITY_DEFAULT)
5123     local_p = true;
5124   /* Otherwise, variables defined outside this object may not be local.  */
5125   else if (DECL_EXTERNAL (exp))
5126     local_p = false;
5127   /* Linkonce and weak data are never local.  */
5128   else if (DECL_ONE_ONLY (exp) || DECL_WEAK (exp))
5129     local_p = false;
5130   /* If none of the above and visibility is not default, make local.  */
5131   else if (DECL_VISIBILITY (exp) != VISIBILITY_DEFAULT)
5132     local_p = true;
5133   /* If PIC, then assume that any global name can be overridden by
5134      symbols resolved from other modules.  */
5135   else if (shlib)
5136     local_p = false;
5137   /* Uninitialized COMMON variable may be unified with symbols
5138      resolved from other modules.  */
5139   else if (DECL_COMMON (exp)
5140            && (DECL_INITIAL (exp) == NULL
5141                || DECL_INITIAL (exp) == error_mark_node))
5142     local_p = false;
5143   /* Otherwise we're left with initialized (or non-common) global data
5144      which is of necessity defined locally.  */
5145   else
5146     local_p = true;
5147
5148   return local_p;
5149 }
5150
5151 /* Determine whether or not a pointer mode is valid. Assume defaults
5152    of ptr_mode or Pmode - can be overridden.  */
5153 bool
5154 default_valid_pointer_mode (enum machine_mode mode)
5155 {
5156   return (mode == ptr_mode || mode == Pmode);
5157 }
5158
5159 /* Default function to output code that will globalize a label.  A
5160    target must define GLOBAL_ASM_OP or provide it's own function to
5161    globalize a label.  */
5162 #ifdef GLOBAL_ASM_OP
5163 void
5164 default_globalize_label (FILE * stream, const char *name)
5165 {
5166   fputs (GLOBAL_ASM_OP, stream);
5167   assemble_name (stream, name);
5168   putc ('\n', stream);
5169 }
5170 #endif /* GLOBAL_ASM_OP */
5171
5172 /* Default function to output a label for unwind information.  The
5173    default is to do nothing.  A target that needs nonlocal labels for
5174    unwind information must provide its own function to do this.  */
5175 void
5176 default_emit_unwind_label (FILE * stream ATTRIBUTE_UNUSED,
5177                            tree decl ATTRIBUTE_UNUSED,
5178                            int for_eh ATTRIBUTE_UNUSED,
5179                            int empty ATTRIBUTE_UNUSED)
5180 {
5181 }
5182
5183 /* This is how to output an internal numbered label where PREFIX is
5184    the class of label and LABELNO is the number within the class.  */
5185
5186 void
5187 default_internal_label (FILE *stream, const char *prefix,
5188                         unsigned long labelno)
5189 {
5190   char *const buf = alloca (40 + strlen (prefix));
5191   ASM_GENERATE_INTERNAL_LABEL (buf, prefix, labelno);
5192   ASM_OUTPUT_LABEL (stream, buf);
5193 }
5194
5195 /* This is the default behavior at the beginning of a file.  It's
5196    controlled by two other target-hook toggles.  */
5197 void
5198 default_file_start (void)
5199 {
5200   if (targetm.file_start_app_off && !flag_verbose_asm)
5201     fputs (ASM_APP_OFF, asm_out_file);
5202
5203   if (targetm.file_start_file_directive)
5204     output_file_directive (asm_out_file, main_input_filename);
5205 }
5206
5207 /* This is a generic routine suitable for use as TARGET_ASM_FILE_END
5208    which emits a special section directive used to indicate whether or
5209    not this object file needs an executable stack.  This is primarily
5210    a GNU extension to ELF but could be used on other targets.  */
5211
5212 int trampolines_created;
5213
5214 void
5215 file_end_indicate_exec_stack (void)
5216 {
5217   unsigned int flags = SECTION_DEBUG;
5218   if (trampolines_created)
5219     flags |= SECTION_CODE;
5220
5221   named_section_flags (".note.GNU-stack", flags);
5222 }
5223
5224 #include "gt-varasm.h"