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