gcc/varasm.c

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