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