gcc/varasm.c

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