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