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