gcc/varasm.c

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