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