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