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