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