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