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