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