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