gcc/varasm.c

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