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