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