gcc/varasm.c

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