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