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