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