gcc/varasm.c

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