gcc/varasm.c

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