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 "c-tree.h"
  46 #include "ggc.h"
  47 #include "langhooks.h"
  48 #include "tm_p.h"
  49 #include "debug.h"
  50 #include "target.h"
  51
  52 #ifdef XCOFF_DEBUGGING_INFO
  53 #include "xcoffout.h"           /* Needed for external data
  54                                    declarations for e.g. AIX 4.x.  */
  55 #endif
  56
  57 #ifndef TRAMPOLINE_ALIGNMENT
  58 #define TRAMPOLINE_ALIGNMENT FUNCTION_BOUNDARY
  59 #endif
  60
  61 #ifndef ASM_STABS_OP
  62 #define ASM_STABS_OP "\t.stabs\t"
  63 #endif
  64
  65 /* The (assembler) name of the first globally-visible object output.  */
  66 const char *first_global_object_name;
  67 const char *weak_global_object_name;
  68
  69 extern struct obstack permanent_obstack;
  70 #define obstack_chunk_alloc xmalloc
  71
  72 struct addr_const;
  73 struct constant_descriptor;
  74 struct rtx_const;
  75 struct pool_constant;
  76
  77 #define MAX_RTX_HASH_TABLE 61
  78
  79 struct varasm_status
  80 {
  81   /* Hash facility for making memory-constants
  82      from constant rtl-expressions.  It is used on RISC machines
  83      where immediate integer arguments and constant addresses are restricted
  84      so that such constants must be stored in memory.
  85
  86      This pool of constants is reinitialized for each function
  87      so each function gets its own constants-pool that comes right before
  88      it.  */
  89   struct constant_descriptor **x_const_rtx_hash_table;
  90   struct pool_constant **x_const_rtx_sym_hash_table;
  91
  92   /* Pointers to first and last constant in pool.  */
  93   struct pool_constant *x_first_pool, *x_last_pool;
  94
  95   /* Current offset in constant pool (does not include any machine-specific
  96      header).  */
  97   HOST_WIDE_INT x_pool_offset;
  98
  99   /* Chain of all CONST_DOUBLE rtx's constructed for the current function.
 100      They are chained through the CONST_DOUBLE_CHAIN.  */
 101   rtx x_const_double_chain;
 102 };
 103
 104 #define const_rtx_hash_table (cfun->varasm->x_const_rtx_hash_table)
 105 #define const_rtx_sym_hash_table (cfun->varasm->x_const_rtx_sym_hash_table)
 106 #define first_pool (cfun->varasm->x_first_pool)
 107 #define last_pool (cfun->varasm->x_last_pool)
 108 #define pool_offset (cfun->varasm->x_pool_offset)
 109 #define const_double_chain (cfun->varasm->x_const_double_chain)
 110
 111 /* Number for making the label on the next
 112    constant that is stored in memory.  */
 113
 114 int const_labelno;
 115
 116 /* Number for making the label on the next
 117    static variable internal to a function.  */
 118
 119 int var_labelno;
 120
 121 /* Carry information from ASM_DECLARE_OBJECT_NAME
 122    to ASM_FINISH_DECLARE_OBJECT.  */
 123
 124 int size_directive_output;
 125
 126 /* The last decl for which assemble_variable was called,
 127    if it did ASM_DECLARE_OBJECT_NAME.
 128    If the last call to assemble_variable didn't do that,
 129    this holds 0.  */
 130
 131 tree last_assemble_variable_decl;
 132
 133 /* RTX_UNCHANGING_P in a MEM can mean it is stored into, for initialization.
 134    So giving constant the alias set for the type will allow such
 135    initializations to appear to conflict with the load of the constant.  We
 136    avoid this by giving all constants an alias set for just constants.
 137    Since there will be no stores to that alias set, nothing will ever
 138    conflict with them.  */
 139
 140 static HOST_WIDE_INT const_alias_set;
 141
 142 static const char *strip_reg_name       PARAMS ((const char *));
 143 static int contains_pointers_p          PARAMS ((tree));
 144 static void decode_addr_const           PARAMS ((tree, struct addr_const *));
 145 static int const_hash                   PARAMS ((tree));
 146 static int compare_constant             PARAMS ((tree,
 147                                                struct constant_descriptor *));
 148 static const unsigned char *compare_constant_1  PARAMS ((tree, const unsigned char *));
 149 static struct constant_descriptor *record_constant PARAMS ((tree));
 150 static void record_constant_1           PARAMS ((tree));
 151 static tree copy_constant               PARAMS ((tree));
 152 static void output_constant_def_contents  PARAMS ((tree, int, int));
 153 static void decode_rtx_const            PARAMS ((enum machine_mode, rtx,
 154                                                struct rtx_const *));
 155 static int const_hash_rtx               PARAMS ((enum machine_mode, rtx));
 156 static int compare_constant_rtx         PARAMS ((enum machine_mode, rtx,
 157                                                struct constant_descriptor *));
 158 static struct constant_descriptor *record_constant_rtx PARAMS ((enum machine_mode,
 159                                                               rtx));
 160 static struct pool_constant *find_pool_constant PARAMS ((struct function *, rtx));
 161 static void mark_constant_pool          PARAMS ((void));
 162 static void mark_constants              PARAMS ((rtx));
 163 static int mark_constant                PARAMS ((rtx *current_rtx, void *data));
 164 static int output_addressed_constants   PARAMS ((tree));
 165 static void output_after_function_constants PARAMS ((void));
 166 static unsigned HOST_WIDE_INT array_size_for_constructor PARAMS ((tree));
 167 static unsigned min_align               PARAMS ((unsigned, unsigned));
 168 static void output_constructor          PARAMS ((tree, HOST_WIDE_INT,
 169                                                  unsigned int));
 170 static void globalize_decl              PARAMS ((tree));
 171 static void maybe_assemble_visibility   PARAMS ((tree));
 172 static int in_named_entry_eq            PARAMS ((const PTR, const PTR));
 173 static hashval_t in_named_entry_hash    PARAMS ((const PTR));
 174 #ifdef ASM_OUTPUT_BSS
 175 static void asm_output_bss              PARAMS ((FILE *, tree, const char *, int, int));
 176 #endif
 177 #ifdef BSS_SECTION_ASM_OP
 178 #ifdef ASM_OUTPUT_ALIGNED_BSS
 179 static void asm_output_aligned_bss      PARAMS ((FILE *, tree, const char *,
 180                                                  int, int));
 181 #endif
 182 #endif /* BSS_SECTION_ASM_OP */
 183 static void mark_pool_constant          PARAMS ((struct pool_constant *));
 184 static void mark_const_hash_entry       PARAMS ((void *));
 185 static int mark_const_str_htab_1        PARAMS ((void **, void *));
 186 static void mark_const_str_htab         PARAMS ((void *));
 187 static hashval_t const_str_htab_hash    PARAMS ((const void *x));
 188 static int const_str_htab_eq            PARAMS ((const void *x, const void *y));
 189 static void const_str_htab_del          PARAMS ((void *));
 190 static void asm_emit_uninitialised      PARAMS ((tree, const char*, int, int));
 191 static void resolve_unique_section      PARAMS ((tree, int));
 192 \f
 193 static enum in_section { no_section, in_text, in_data, in_named
 194 #ifdef BSS_SECTION_ASM_OP
 195   , in_bss
 196 #endif
 197 #ifdef CTORS_SECTION_ASM_OP
 198   , in_ctors
 199 #endif
 200 #ifdef DTORS_SECTION_ASM_OP
 201   , in_dtors
 202 #endif
 203 #ifdef EXTRA_SECTIONS
 204   , EXTRA_SECTIONS
 205 #endif
 206 } in_section = no_section;
 207
 208 /* Return a non-zero value if DECL has a section attribute.  */
 209 #ifndef IN_NAMED_SECTION
 210 #define IN_NAMED_SECTION(DECL) \
 211   ((TREE_CODE (DECL) == FUNCTION_DECL || TREE_CODE (DECL) == VAR_DECL) \
 212    && DECL_SECTION_NAME (DECL) != NULL_TREE)
 213 #endif
 214
 215 /* Text of section name when in_section == in_named.  */
 216 static const char *in_named_name;
 217
 218 /* Hash table of flags that have been used for a particular named section.  */
 219
 220 struct in_named_entry
 221 {
 222   const char *name;
 223   unsigned int flags;
 224   bool declared;
 225 };
 226
 227 static htab_t in_named_htab;
 228
 229 /* Define functions like text_section for any extra sections.  */
 230 #ifdef EXTRA_SECTION_FUNCTIONS
 231 EXTRA_SECTION_FUNCTIONS
 232 #endif
 233
 234 /* Tell assembler to switch to text section.  */
 235
 236 void
 237 text_section ()
 238 {
 239   if (in_section != in_text)
 240     {
 241 #ifdef TEXT_SECTION
 242       TEXT_SECTION ();
 243 #else
 244       fprintf (asm_out_file, "%s\n", TEXT_SECTION_ASM_OP);
 245 #endif
 246       in_section = in_text;
 247     }
 248 }
 249
 250 /* Tell assembler to switch to data section.  */
 251
 252 void
 253 data_section ()
 254 {
 255   if (in_section != in_data)
 256     {
 257       if (flag_shared_data)
 258         {
 259 #ifdef SHARED_SECTION_ASM_OP
 260           fprintf (asm_out_file, "%s\n", SHARED_SECTION_ASM_OP);
 261 #else
 262           fprintf (asm_out_file, "%s\n", DATA_SECTION_ASM_OP);
 263 #endif
 264         }
 265       else
 266         fprintf (asm_out_file, "%s\n", DATA_SECTION_ASM_OP);
 267
 268       in_section = in_data;
 269     }
 270 }
 271 /* Tell assembler to ALWAYS switch to data section, in case
 272    it's not sure where it is.  */
 273
 274 void
 275 force_data_section ()
 276 {
 277   in_section = no_section;
 278   data_section ();
 279 }
 280
 281 /* Tell assembler to switch to read-only data section.  This is normally
 282    the text section.  */
 283
 284 void
 285 readonly_data_section ()
 286 {
 287 #ifdef READONLY_DATA_SECTION
 288   READONLY_DATA_SECTION ();  /* Note this can call data_section.  */
 289 #else
 290   text_section ();
 291 #endif
 292 }
 293
 294 /* Determine if we're in the text section.  */
 295
 296 int
 297 in_text_section ()
 298 {
 299   return in_section == in_text;
 300 }
 301
 302 /* Determine if we're in the data section.  */
 303
 304 int
 305 in_data_section ()
 306 {
 307   return in_section == in_data;
 308 }
 309
 310 /* Helper routines for maintaining in_named_htab.  */
 311
 312 static int
 313 in_named_entry_eq (p1, p2)
 314      const PTR p1;
 315      const PTR p2;
 316 {
 317   const struct in_named_entry *old = p1;
 318   const char *new = p2;
 319
 320   return strcmp (old->name, new) == 0;
 321 }
 322
 323 static hashval_t
 324 in_named_entry_hash (p)
 325      const PTR p;
 326 {
 327   const struct in_named_entry *old = p;
 328   return htab_hash_string (old->name);
 329 }
 330
 331 /* If SECTION has been seen before as a named section, return the flags
 332    that were used.  Otherwise, return 0.  Note, that 0 is a perfectly valid
 333    set of flags for a section to have, so 0 does not mean that the section
 334    has not been seen.  */
 335
 336 unsigned int
 337 get_named_section_flags (section)
 338      const char *section;
 339 {
 340   struct in_named_entry **slot;
 341
 342   slot = (struct in_named_entry**)
 343     htab_find_slot_with_hash (in_named_htab, section,
 344                               htab_hash_string (section), NO_INSERT);
 345
 346   return slot ? (*slot)->flags : 0;
 347 }
 348
 349 /* Returns true if the section has been declared before.   Sets internal
 350    flag on this section in in_named_hash so subsequent calls on this
 351    section will return false.  */
 352
 353 bool
 354 named_section_first_declaration (name)
 355      const char *name;
 356 {
 357   struct in_named_entry **slot;
 358
 359   slot = (struct in_named_entry**)
 360     htab_find_slot_with_hash (in_named_htab, name,
 361                               htab_hash_string (name), NO_INSERT);
 362   if (! (*slot)->declared)
 363     {
 364       (*slot)->declared = true;
 365       return true;
 366     }
 367   else
 368     {
 369       return false;
 370     }
 371 }
 372
 373
 374 /* Record FLAGS for SECTION.  If SECTION was previously recorded with a
 375    different set of flags, return false.  */
 376
 377 bool
 378 set_named_section_flags (section, flags)
 379      const char *section;
 380      unsigned int flags;
 381 {
 382   struct in_named_entry **slot, *entry;
 383
 384   slot = (struct in_named_entry**)
 385     htab_find_slot_with_hash (in_named_htab, section,
 386                               htab_hash_string (section), INSERT);
 387   entry = *slot;
 388
 389   if (!entry)
 390     {
 391       entry = (struct in_named_entry *) xmalloc (sizeof (*entry));
 392       *slot = entry;
 393       entry->name = ggc_strdup (section);
 394       entry->flags = flags;
 395       entry->declared = false;
 396     }
 397   else if (entry->flags != flags)
 398     return false;
 399
 400   return true;
 401 }
 402
 403 /* Tell assembler to change to section NAME with attributes FLAGS.  */
 404
 405 void
 406 named_section_flags (name, flags)
 407      const char *name;
 408      unsigned int flags;
 409 {
 410   if (in_section != in_named || strcmp (name, in_named_name) != 0)
 411     {
 412       if (! set_named_section_flags (name, flags))
 413         abort ();
 414
 415       (* targetm.asm_out.named_section) (name, flags);
 416
 417       if (flags & SECTION_FORGET)
 418         in_section = no_section;
 419       else
 420         {
 421           in_named_name = ggc_strdup (name);
 422           in_section = in_named;
 423         }
 424     }
 425 }
 426
 427 /* Tell assembler to change to section NAME for DECL.
 428    If DECL is NULL, just switch to section NAME.
 429    If NAME is NULL, get the name from DECL.
 430    If RELOC is 1, the initializer for DECL contains relocs.  */
 431
 432 void
 433 named_section (decl, name, reloc)
 434      tree decl;
 435      const char *name;
 436      int reloc;
 437 {
 438   unsigned int flags;
 439
 440   if (decl != NULL_TREE && !DECL_P (decl))
 441     abort ();
 442   if (name == NULL)
 443     name = TREE_STRING_POINTER (DECL_SECTION_NAME (decl));
 444
 445   flags = (* targetm.section_type_flags) (decl, name, reloc);
 446
 447   /* Sanity check user variables for flag changes.  Non-user
 448      section flag changes will abort in named_section_flags.
 449      However, don't complain if SECTION_OVERRIDE is set.
 450      We trust that the setter knows that it is safe to ignore
 451      the default flags for this decl.  */
 452   if (decl && ! set_named_section_flags (name, flags))
 453     {
 454       flags = get_named_section_flags (name);
 455       if ((flags & SECTION_OVERRIDE) == 0)
 456         error_with_decl (decl, "%s causes a section type conflict");
 457     }
 458
 459   named_section_flags (name, flags);
 460 }
 461
 462 /* If required, set DECL_SECTION_NAME to a unique name.  */
 463
 464 static void
 465 resolve_unique_section (decl, reloc)
 466      tree decl;
 467      int reloc ATTRIBUTE_UNUSED;
 468 {
 469   if (DECL_SECTION_NAME (decl) == NULL_TREE
 470       && (flag_function_sections
 471           || (targetm.have_named_sections
 472               && DECL_ONE_ONLY (decl))))
 473     UNIQUE_SECTION (decl, reloc);
 474 }
 475
 476 #ifdef BSS_SECTION_ASM_OP
 477
 478 /* Tell the assembler to switch to the bss section.  */
 479
 480 void
 481 bss_section ()
 482 {
 483   if (in_section != in_bss)
 484     {
 485 #ifdef SHARED_BSS_SECTION_ASM_OP
 486       if (flag_shared_data)
 487         fprintf (asm_out_file, "%s\n", SHARED_BSS_SECTION_ASM_OP);
 488       else
 489 #endif
 490         fprintf (asm_out_file, "%s\n", BSS_SECTION_ASM_OP);
 491
 492       in_section = in_bss;
 493     }
 494 }
 495
 496 #ifdef ASM_OUTPUT_BSS
 497
 498 /* Utility function for ASM_OUTPUT_BSS for targets to use if
 499    they don't support alignments in .bss.
 500    ??? It is believed that this function will work in most cases so such
 501    support is localized here.  */
 502
 503 static void
 504 asm_output_bss (file, decl, name, size, rounded)
 505      FILE *file;
 506      tree decl ATTRIBUTE_UNUSED;
 507      const char *name;
 508      int size ATTRIBUTE_UNUSED, rounded;
 509 {
 510   ASM_GLOBALIZE_LABEL (file, name);
 511   bss_section ();
 512 #ifdef ASM_DECLARE_OBJECT_NAME
 513   last_assemble_variable_decl = decl;
 514   ASM_DECLARE_OBJECT_NAME (file, name, decl);
 515 #else
 516   /* Standard thing is just output label for the object.  */
 517   ASM_OUTPUT_LABEL (file, name);
 518 #endif /* ASM_DECLARE_OBJECT_NAME */
 519   ASM_OUTPUT_SKIP (file, rounded);
 520 }
 521
 522 #endif
 523
 524 #ifdef ASM_OUTPUT_ALIGNED_BSS
 525
 526 /* Utility function for targets to use in implementing
 527    ASM_OUTPUT_ALIGNED_BSS.
 528    ??? It is believed that this function will work in most cases so such
 529    support is localized here.  */
 530
 531 static void
 532 asm_output_aligned_bss (file, decl, name, size, align)
 533      FILE *file;
 534      tree decl ATTRIBUTE_UNUSED;
 535      const char *name;
 536      int size, align;
 537 {
 538   ASM_GLOBALIZE_LABEL (file, name);
 539   bss_section ();
 540   ASM_OUTPUT_ALIGN (file, floor_log2 (align / BITS_PER_UNIT));
 541 #ifdef ASM_DECLARE_OBJECT_NAME
 542   last_assemble_variable_decl = decl;
 543   ASM_DECLARE_OBJECT_NAME (file, name, decl);
 544 #else
 545   /* Standard thing is just output label for the object.  */
 546   ASM_OUTPUT_LABEL (file, name);
 547 #endif /* ASM_DECLARE_OBJECT_NAME */
 548   ASM_OUTPUT_SKIP (file, size ? size : 1);
 549 }
 550
 551 #endif
 552
 553 #endif /* BSS_SECTION_ASM_OP */
 554
 555 /* Switch to the section for function DECL.
 556
 557    If DECL is NULL_TREE, switch to the text section.
 558    ??? It's not clear that we will ever be passed NULL_TREE, but it's
 559    safer to handle it.  */
 560
 561 void
 562 function_section (decl)
 563      tree decl;
 564 {
 565   if (decl != NULL_TREE
 566       && DECL_SECTION_NAME (decl) != NULL_TREE)
 567     named_section (decl, (char *) 0, 0);
 568   else
 569     text_section ();
 570 }
 571
 572 /* Switch to section for variable DECL.
 573
 574    RELOC is the `reloc' argument to SELECT_SECTION.  */
 575
 576 void
 577 variable_section (decl, reloc)
 578      tree decl;
 579      int reloc;
 580 {
 581   if (IN_NAMED_SECTION (decl))
 582     named_section (decl, NULL, reloc);
 583   else
 584     {
 585       /* C++ can have const variables that get initialized from constructors,
 586          and thus can not be in a readonly section.  We prevent this by
 587          verifying that the initial value is constant for objects put in a
 588          readonly section.
 589
 590          error_mark_node is used by the C front end to indicate that the
 591          initializer has not been seen yet.  In this case, we assume that
 592          the initializer must be constant.
 593
 594          C++ uses error_mark_node for variables that have complicated
 595          initializers, but these variables go in BSS so we won't be called
 596          for them.  */
 597
 598 #ifdef SELECT_SECTION
 599       SELECT_SECTION (decl, reloc, DECL_ALIGN (decl));
 600 #else
 601       if (DECL_READONLY_SECTION (decl, reloc))
 602         readonly_data_section ();
 603       else
 604         data_section ();
 605 #endif
 606     }
 607 }
 608
 609 /* Tell assembler to switch to the section for the exception handling
 610    table.  */
 611
 612 void
 613 default_exception_section ()
 614 {
 615   if (targetm.have_named_sections)
 616     named_section (NULL_TREE, ".gcc_except_table", 0);
 617   else if (flag_pic)
 618     data_section ();
 619   else
 620     readonly_data_section ();
 621 }
 622
 623 /* Tell assembler to switch to the section for string merging.  */
 624
 625 void
 626 mergeable_string_section (decl, align, flags)
 627   tree decl ATTRIBUTE_UNUSED;
 628   unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED;
 629   unsigned int flags ATTRIBUTE_UNUSED;
 630 {
 631 #ifdef HAVE_GAS_SHF_MERGE
 632   if (flag_merge_constants
 633       && TREE_CODE (decl) == STRING_CST
 634       && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
 635       && align <= 256
 636       && TREE_STRING_LENGTH (decl) >= int_size_in_bytes (TREE_TYPE (decl)))
 637     {
 638       enum machine_mode mode;
 639       unsigned int modesize;
 640       const char *str;
 641       int i, j, len, unit;
 642       char name[30];
 643
 644       mode = TYPE_MODE (TREE_TYPE (TREE_TYPE (decl)));
 645       modesize = GET_MODE_BITSIZE (mode);
 646       if (modesize >= 8 && modesize <= 256
 647           && (modesize & (modesize - 1)) == 0)
 648         {
 649           if (align < modesize)
 650             align = modesize;
 651
 652           str = TREE_STRING_POINTER (decl);
 653           len = TREE_STRING_LENGTH (decl);
 654           unit = GET_MODE_SIZE (mode);
 655
 656           /* Check for embedded NUL characters.  */
 657           for (i = 0; i < len; i += unit)
 658             {
 659               for (j = 0; j < unit; j++)
 660                 if (str [i + j] != '\0')
 661                   break;
 662               if (j == unit)
 663                 break;
 664             }
 665           if (i == len - unit)
 666             {
 667               sprintf (name, ".rodata.str%d.%d", modesize / 8,
 668                        (int) (align / 8));
 669               flags |= (modesize / 8) | SECTION_MERGE | SECTION_STRINGS;
 670               if (!i && modesize < align)
 671                 {
 672                   /* A "" string with requested alignment greater than
 673                      character size might cause a problem:
 674                      if some other string required even bigger
 675                      alignment than "", then linker might think the
 676                      "" is just part of padding after some other string
 677                      and not put it into the hash table initially.
 678                      But this means "" could have smaller alignment
 679                      than requested.  */
 680 #ifdef ASM_OUTPUT_SECTION_START
 681                   named_section_flags (name, flags);
 682                   ASM_OUTPUT_SECTION_START (asm_out_file);
 683 #else
 684                   readonly_data_section ();
 685 #endif
 686                   return;
 687                 }
 688
 689               named_section_flags (name, flags);
 690               return;
 691             }
 692         }
 693     }
 694 #endif
 695   readonly_data_section ();
 696 }
 697
 698 /* Tell assembler to switch to the section for constant merging.  */
 699
 700 void
 701 mergeable_constant_section (mode, align, flags)
 702   enum machine_mode mode ATTRIBUTE_UNUSED;
 703   unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED;
 704   unsigned int flags ATTRIBUTE_UNUSED;
 705 {
 706 #ifdef HAVE_GAS_SHF_MERGE
 707   unsigned int modesize = GET_MODE_BITSIZE (mode);
 708
 709   if (flag_merge_constants
 710       && mode != VOIDmode
 711       && mode != BLKmode
 712       && modesize <= align
 713       && align >= 8
 714       && align <= 256
 715       && (align & (align - 1)) == 0)
 716     {
 717       char name[24];
 718
 719       sprintf (name, ".rodata.cst%d", (int) (align / 8));
 720       flags |= (align / 8) | SECTION_MERGE;
 721       named_section_flags (name, flags);
 722       return;
 723     }
 724 #endif
 725   readonly_data_section ();
 726 }
 727 \f
 728 /* Given NAME, a putative register name, discard any customary prefixes.  */
 729
 730 static const char *
 731 strip_reg_name (name)
 732   const char *name;
 733 {
 734 #ifdef REGISTER_PREFIX
 735   if (!strncmp (name, REGISTER_PREFIX, strlen (REGISTER_PREFIX)))
 736     name += strlen (REGISTER_PREFIX);
 737 #endif
 738   if (name[0] == '%' || name[0] == '#')
 739     name++;
 740   return name;
 741 }
 742 \f
 743 /* Decode an `asm' spec for a declaration as a register name.
 744    Return the register number, or -1 if nothing specified,
 745    or -2 if the ASMSPEC is not `cc' or `memory' and is not recognized,
 746    or -3 if ASMSPEC is `cc' and is not recognized,
 747    or -4 if ASMSPEC is `memory' and is not recognized.
 748    Accept an exact spelling or a decimal number.
 749    Prefixes such as % are optional.  */
 750
 751 int
 752 decode_reg_name (asmspec)
 753   const char *asmspec;
 754 {
 755   if (asmspec != 0)
 756     {
 757       int i;
 758
 759       /* Get rid of confusing prefixes.  */
 760       asmspec = strip_reg_name (asmspec);
 761
 762       /* Allow a decimal number as a "register name".  */
 763       for (i = strlen (asmspec) - 1; i >= 0; i--)
 764         if (! ISDIGIT (asmspec[i]))
 765           break;
 766       if (asmspec[0] != 0 && i < 0)
 767         {
 768           i = atoi (asmspec);
 769           if (i < FIRST_PSEUDO_REGISTER && i >= 0)
 770             return i;
 771           else
 772             return -2;
 773         }
 774
 775       for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
 776         if (reg_names[i][0]
 777             && ! strcmp (asmspec, strip_reg_name (reg_names[i])))
 778           return i;
 779
 780 #ifdef ADDITIONAL_REGISTER_NAMES
 781       {
 782         static const struct { const char *const name; const int number; } table[]
 783           = ADDITIONAL_REGISTER_NAMES;
 784
 785         for (i = 0; i < (int) ARRAY_SIZE (table); i++)
 786           if (! strcmp (asmspec, table[i].name))
 787             return table[i].number;
 788       }
 789 #endif /* ADDITIONAL_REGISTER_NAMES */
 790
 791       if (!strcmp (asmspec, "memory"))
 792         return -4;
 793
 794       if (!strcmp (asmspec, "cc"))
 795         return -3;
 796
 797       return -2;
 798     }
 799
 800   return -1;
 801 }
 802 \f
 803 /* Create the DECL_RTL for a VAR_DECL or FUNCTION_DECL.  DECL should
 804    have static storage duration.  In other words, it should not be an
 805    automatic variable, including PARM_DECLs.
 806
 807    There is, however, one exception: this function handles variables
 808    explicitly placed in a particular register by the user.
 809
 810    ASMSPEC, if not 0, is the string which the user specified as the
 811    assembler symbol name.
 812
 813    This is never called for PARM_DECL nodes.  */
 814
 815 void
 816 make_decl_rtl (decl, asmspec)
 817      tree decl;
 818      const char *asmspec;
 819 {
 820   int top_level = (DECL_CONTEXT (decl) == NULL_TREE);
 821   const char *name = 0;
 822   const char *new_name = 0;
 823   int reg_number;
 824   rtx x;
 825
 826   /* Check that we are not being given an automatic variable.  */
 827   /* A weak alias has TREE_PUBLIC set but not the other bits.  */
 828   if (TREE_CODE (decl) == PARM_DECL
 829       || TREE_CODE (decl) == RESULT_DECL
 830       || (TREE_CODE (decl) == VAR_DECL
 831           && !TREE_STATIC (decl)
 832           && !TREE_PUBLIC (decl)
 833           && !DECL_EXTERNAL (decl)
 834           && !DECL_REGISTER (decl)))
 835     abort ();
 836   /* And that we were not given a type or a label.  */
 837   else if (TREE_CODE (decl) == TYPE_DECL
 838            || TREE_CODE (decl) == LABEL_DECL)
 839     abort ();
 840
 841   /* For a duplicate declaration, we can be called twice on the
 842      same DECL node.  Don't discard the RTL already made.  */
 843   if (DECL_RTL_SET_P (decl))
 844     {
 845       /* If the old RTL had the wrong mode, fix the mode.  */
 846       if (GET_MODE (DECL_RTL (decl)) != DECL_MODE (decl))
 847         SET_DECL_RTL (decl, adjust_address_nv (DECL_RTL (decl),
 848                                                DECL_MODE (decl), 0));
 849
 850       /* ??? Another way to do this would be to do what halfpic.c does
 851          and maintain a hashed table of such critters.  */
 852       /* Let the target reassign the RTL if it wants.
 853          This is necessary, for example, when one machine specific
 854          decl attribute overrides another.  */
 855 #ifdef ENCODE_SECTION_INFO
 856       ENCODE_SECTION_INFO (decl, false);
 857 #endif
 858       return;
 859     }
 860
 861   new_name = name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
 862
 863   reg_number = decode_reg_name (asmspec);
 864   if (reg_number == -2)
 865     {
 866       /* ASMSPEC is given, and not the name of a register.  Mark the
 867          name with a star so assemble_name won't munge it.  */
 868       char *starred = alloca (strlen (asmspec) + 2);
 869       starred[0] = '*';
 870       strcpy (starred + 1, asmspec);
 871       new_name = starred;
 872     }
 873
 874   if (TREE_CODE (decl) != FUNCTION_DECL && DECL_REGISTER (decl))
 875     {
 876       /* First detect errors in declaring global registers.  */
 877       if (reg_number == -1)
 878         error_with_decl (decl, "register name not specified for `%s'");
 879       else if (reg_number < 0)
 880         error_with_decl (decl, "invalid register name for `%s'");
 881       else if (TYPE_MODE (TREE_TYPE (decl)) == BLKmode)
 882         error_with_decl (decl,
 883                          "data type of `%s' isn't suitable for a register");
 884       else if (! HARD_REGNO_MODE_OK (reg_number, TYPE_MODE (TREE_TYPE (decl))))
 885         error_with_decl (decl,
 886                          "register specified for `%s' isn't suitable for data type");
 887       /* Now handle properly declared static register variables.  */
 888       else
 889         {
 890           int nregs;
 891
 892           if (DECL_INITIAL (decl) != 0 && TREE_STATIC (decl))
 893             {
 894               DECL_INITIAL (decl) = 0;
 895               error ("global register variable has initial value");
 896             }
 897           if (TREE_THIS_VOLATILE (decl))
 898             warning ("volatile register variables don't work as you might wish");
 899
 900           /* If the user specified one of the eliminables registers here,
 901              e.g., FRAME_POINTER_REGNUM, we don't want to get this variable
 902              confused with that register and be eliminated.  This usage is
 903              somewhat suspect...  */
 904
 905           SET_DECL_RTL (decl, gen_rtx_raw_REG (DECL_MODE (decl), reg_number));
 906           ORIGINAL_REGNO (DECL_RTL (decl)) = reg_number;
 907           REG_USERVAR_P (DECL_RTL (decl)) = 1;
 908
 909           if (TREE_STATIC (decl))
 910             {
 911               /* Make this register global, so not usable for anything
 912                  else.  */
 913 #ifdef ASM_DECLARE_REGISTER_GLOBAL
 914               ASM_DECLARE_REGISTER_GLOBAL (asm_out_file, decl, reg_number, name);
 915 #endif
 916               nregs = HARD_REGNO_NREGS (reg_number, DECL_MODE (decl));
 917               while (nregs > 0)
 918                 globalize_reg (reg_number + --nregs);
 919             }
 920
 921           /* As a register variable, it has no section.  */
 922           return;
 923         }
 924     }
 925
 926   /* Now handle ordinary static variables and functions (in memory).
 927      Also handle vars declared register invalidly.  */
 928
 929   if (reg_number >= 0 || reg_number == -3)
 930     error_with_decl (decl,
 931                      "register name given for non-register variable `%s'");
 932
 933   /* Specifying a section attribute on a variable forces it into a
 934      non-.bss section, and thus it cannot be common.  */
 935   if (TREE_CODE (decl) == VAR_DECL
 936       && DECL_SECTION_NAME (decl) != NULL_TREE
 937       && DECL_INITIAL (decl) == NULL_TREE
 938       && DECL_COMMON (decl))
 939     DECL_COMMON (decl) = 0;
 940
 941   /* Can't use just the variable's own name for a variable
 942      whose scope is less than the whole file, unless it's a member
 943      of a local class (which will already be unambiguous).
 944      Concatenate a distinguishing number.  */
 945   if (!top_level && !TREE_PUBLIC (decl)
 946       && ! (DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl)))
 947       && asmspec == 0
 948       && name == IDENTIFIER_POINTER (DECL_NAME (decl)))
 949     {
 950       char *label;
 951
 952       ASM_FORMAT_PRIVATE_NAME (label, name, var_labelno);
 953       var_labelno++;
 954       new_name = label;
 955     }
 956
 957   if (name != new_name)
 958     {
 959       SET_DECL_ASSEMBLER_NAME (decl, get_identifier (new_name));
 960       name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
 961     }
 962
 963   /* If this variable is to be treated as volatile, show its
 964      tree node has side effects.  */
 965   if ((flag_volatile_global && TREE_CODE (decl) == VAR_DECL
 966        && TREE_PUBLIC (decl))
 967       || ((flag_volatile_static && TREE_CODE (decl) == VAR_DECL
 968            && (TREE_PUBLIC (decl) || TREE_STATIC (decl)))))
 969     TREE_SIDE_EFFECTS (decl) = 1;
 970
 971   x = gen_rtx_MEM (DECL_MODE (decl), gen_rtx_SYMBOL_REF (Pmode, name));
 972   SYMBOL_REF_WEAK (XEXP (x, 0)) = DECL_WEAK (decl);
 973   if (TREE_CODE (decl) != FUNCTION_DECL)
 974     set_mem_attributes (x, decl, 1);
 975   SET_DECL_RTL (decl, x);
 976
 977   /* Optionally set flags or add text to the name to record information
 978      such as that it is a function name.
 979      If the name is changed, the macro ASM_OUTPUT_LABELREF
 980      will have to know how to strip this information.  */
 981 #ifdef ENCODE_SECTION_INFO
 982   ENCODE_SECTION_INFO (decl, true);
 983 #endif
 984 }
 985
 986 /* Make the rtl for variable VAR be volatile.
 987    Use this only for static variables.  */
 988
 989 void
 990 make_var_volatile (var)
 991      tree var;
 992 {
 993   if (GET_CODE (DECL_RTL (var)) != MEM)
 994     abort ();
 995
 996   MEM_VOLATILE_P (DECL_RTL (var)) = 1;
 997 }
 998 \f
 999 /* Output alignment directive to align for constant expression EXP.  */
1000
1001 void
1002 assemble_constant_align (exp)
1003      tree exp;
1004 {
1005   int align;
1006
1007   /* Align the location counter as required by EXP's data type.  */
1008   align = TYPE_ALIGN (TREE_TYPE (exp));
1009 #ifdef CONSTANT_ALIGNMENT
1010   align = CONSTANT_ALIGNMENT (exp, align);
1011 #endif
1012
1013   if (align > BITS_PER_UNIT)
1014     {
1015       ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
1016     }
1017 }
1018
1019 /* Output a string of literal assembler code
1020    for an `asm' keyword used between functions.  */
1021
1022 void
1023 assemble_asm (string)
1024      tree string;
1025 {
1026   app_enable ();
1027
1028   if (TREE_CODE (string) == ADDR_EXPR)
1029     string = TREE_OPERAND (string, 0);
1030
1031   fprintf (asm_out_file, "\t%s\n", TREE_STRING_POINTER (string));
1032 }
1033
1034 /* Record an element in the table of global destructors.  SYMBOL is
1035    a SYMBOL_REF of the function to be called; PRIORITY is a number
1036    between 0 and MAX_INIT_PRIORITY.  */
1037
1038 void
1039 default_stabs_asm_out_destructor (symbol, priority)
1040      rtx symbol;
1041      int priority ATTRIBUTE_UNUSED;
1042 {
1043   /* Tell GNU LD that this is part of the static destructor set.
1044      This will work for any system that uses stabs, most usefully
1045      aout systems.  */
1046   fprintf (asm_out_file, "%s\"___DTOR_LIST__\",22,0,0,", ASM_STABS_OP);
1047   assemble_name (asm_out_file, XSTR (symbol, 0));
1048   fputc ('\n', asm_out_file);
1049 }
1050
1051 void
1052 default_named_section_asm_out_destructor (symbol, priority)
1053      rtx symbol;
1054      int priority;
1055 {
1056   const char *section = ".dtors";
1057   char buf[16];
1058
1059   /* ??? This only works reliably with the GNU linker.  */
1060   if (priority != DEFAULT_INIT_PRIORITY)
1061     {
1062       sprintf (buf, ".dtors.%.5u",
1063                /* Invert the numbering so the linker puts us in the proper
1064                   order; constructors are run from right to left, and the
1065                   linker sorts in increasing order.  */
1066                MAX_INIT_PRIORITY - priority);
1067       section = buf;
1068     }
1069
1070   named_section_flags (section, SECTION_WRITE);
1071   assemble_align (POINTER_SIZE);
1072   assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1073 }
1074
1075 #ifdef DTORS_SECTION_ASM_OP
1076 void
1077 dtors_section ()
1078 {
1079   if (in_section != in_dtors)
1080     {
1081       in_section = in_dtors;
1082       fputs (DTORS_SECTION_ASM_OP, asm_out_file);
1083       fputc ('\n', asm_out_file);
1084     }
1085 }
1086
1087 void
1088 default_dtor_section_asm_out_destructor (symbol, priority)
1089      rtx symbol;
1090      int priority ATTRIBUTE_UNUSED;
1091 {
1092   dtors_section ();
1093   assemble_align (POINTER_SIZE);
1094   assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1095 }
1096 #endif
1097
1098 /* Likewise for global constructors.  */
1099
1100 void
1101 default_stabs_asm_out_constructor (symbol, priority)
1102      rtx symbol;
1103      int priority ATTRIBUTE_UNUSED;
1104 {
1105   /* Tell GNU LD that this is part of the static destructor set.
1106      This will work for any system that uses stabs, most usefully
1107      aout systems.  */
1108   fprintf (asm_out_file, "%s\"___CTOR_LIST__\",22,0,0,", ASM_STABS_OP);
1109   assemble_name (asm_out_file, XSTR (symbol, 0));
1110   fputc ('\n', asm_out_file);
1111 }
1112
1113 void
1114 default_named_section_asm_out_constructor (symbol, priority)
1115      rtx symbol;
1116      int priority;
1117 {
1118   const char *section = ".ctors";
1119   char buf[16];
1120
1121   /* ??? This only works reliably with the GNU linker.  */
1122   if (priority != DEFAULT_INIT_PRIORITY)
1123     {
1124       sprintf (buf, ".ctors.%.5u",
1125                /* Invert the numbering so the linker puts us in the proper
1126                   order; constructors are run from right to left, and the
1127                   linker sorts in increasing order.  */
1128                MAX_INIT_PRIORITY - priority);
1129       section = buf;
1130     }
1131
1132   named_section_flags (section, SECTION_WRITE);
1133   assemble_align (POINTER_SIZE);
1134   assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1135 }
1136
1137 #ifdef CTORS_SECTION_ASM_OP
1138 void
1139 ctors_section ()
1140 {
1141   if (in_section != in_ctors)
1142     {
1143       in_section = in_ctors;
1144       fputs (CTORS_SECTION_ASM_OP, asm_out_file);
1145       fputc ('\n', asm_out_file);
1146     }
1147 }
1148
1149 void
1150 default_ctor_section_asm_out_constructor (symbol, priority)
1151      rtx symbol;
1152      int priority ATTRIBUTE_UNUSED;
1153 {
1154   ctors_section ();
1155   assemble_align (POINTER_SIZE);
1156   assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1157 }
1158 #endif
1159 \f
1160 /* CONSTANT_POOL_BEFORE_FUNCTION may be defined as an expression with
1161    a non-zero value if the constant pool should be output before the
1162    start of the function, or a zero value if the pool should output
1163    after the end of the function.  The default is to put it before the
1164    start.  */
1165
1166 #ifndef CONSTANT_POOL_BEFORE_FUNCTION
1167 #define CONSTANT_POOL_BEFORE_FUNCTION 1
1168 #endif
1169
1170 /* Output assembler code for the constant pool of a function and associated
1171    with defining the name of the function.  DECL describes the function.
1172    NAME is the function's name.  For the constant pool, we use the current
1173    constant pool data.  */
1174
1175 void
1176 assemble_start_function (decl, fnname)
1177      tree decl;
1178      const char *fnname;
1179 {
1180   int align;
1181
1182   /* The following code does not need preprocessing in the assembler.  */
1183
1184   app_disable ();
1185
1186   if (CONSTANT_POOL_BEFORE_FUNCTION)
1187     output_constant_pool (fnname, decl);
1188
1189   resolve_unique_section (decl, 0);
1190   function_section (decl);
1191
1192   /* Tell assembler to move to target machine's alignment for functions.  */
1193   align = floor_log2 (FUNCTION_BOUNDARY / BITS_PER_UNIT);
1194   if (align > 0)
1195     {
1196       ASM_OUTPUT_ALIGN (asm_out_file, align);
1197     }
1198
1199   /* Handle a user-specified function alignment.
1200      Note that we still need to align to FUNCTION_BOUNDARY, as above,
1201      because ASM_OUTPUT_MAX_SKIP_ALIGN might not do any alignment at all.  */
1202   if (align_functions_log > align)
1203     {
1204 #ifdef ASM_OUTPUT_MAX_SKIP_ALIGN
1205       ASM_OUTPUT_MAX_SKIP_ALIGN (asm_out_file,
1206                                  align_functions_log, align_functions-1);
1207 #else
1208       ASM_OUTPUT_ALIGN (asm_out_file, align_functions_log);
1209 #endif
1210     }
1211
1212 #ifdef ASM_OUTPUT_FUNCTION_PREFIX
1213   ASM_OUTPUT_FUNCTION_PREFIX (asm_out_file, fnname);
1214 #endif
1215
1216   (*debug_hooks->begin_function) (decl);
1217
1218   /* Make function name accessible from other files, if appropriate.  */
1219
1220   if (TREE_PUBLIC (decl))
1221     {
1222       if (! first_global_object_name)
1223         {
1224           const char *p;
1225           char *name;
1226
1227           STRIP_NAME_ENCODING (p, fnname);
1228           name = permalloc (strlen (p) + 1);
1229           strcpy (name, p);
1230
1231           if (! DECL_WEAK (decl) && ! DECL_ONE_ONLY (decl))
1232             first_global_object_name = name;
1233           else
1234             weak_global_object_name = name;
1235         }
1236
1237       globalize_decl (decl);
1238
1239       maybe_assemble_visibility (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   if (TREE_PUBLIC (decl))
1594     maybe_assemble_visibility (decl);
1595
1596   /* Output any data that we will need to use the address of.  */
1597   if (DECL_INITIAL (decl) == error_mark_node)
1598     reloc = contains_pointers_p (TREE_TYPE (decl)) ? 3 : 0;
1599   else if (DECL_INITIAL (decl))
1600     reloc = output_addressed_constants (DECL_INITIAL (decl));
1601   resolve_unique_section (decl, reloc);
1602
1603   /* Handle uninitialized definitions.  */
1604
1605   if ((DECL_INITIAL (decl) == 0 || DECL_INITIAL (decl) == error_mark_node
1606 #if defined ASM_EMIT_BSS
1607        || (flag_zero_initialized_in_bss
1608            && initializer_zerop (DECL_INITIAL (decl)))
1609 #endif
1610        )
1611       /* If the target can't output uninitialized but not common global data
1612          in .bss, then we have to use .data.  */
1613 #if ! defined ASM_EMIT_BSS
1614       && DECL_COMMON (decl)
1615 #endif
1616       && DECL_SECTION_NAME (decl) == NULL_TREE
1617       && ! dont_output_data)
1618     {
1619       unsigned HOST_WIDE_INT size = tree_low_cst (DECL_SIZE_UNIT (decl), 1);
1620       unsigned HOST_WIDE_INT rounded = size;
1621
1622       /* Don't allocate zero bytes of common,
1623          since that means "undefined external" in the linker.  */
1624       if (size == 0)
1625         rounded = 1;
1626
1627       /* Round size up to multiple of BIGGEST_ALIGNMENT bits
1628          so that each uninitialized object starts on such a boundary.  */
1629       rounded += (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1;
1630       rounded = (rounded / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
1631                  * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
1632
1633 /* Don't continue this line--convex cc version 4.1 would lose.  */
1634 #if !defined(ASM_OUTPUT_ALIGNED_COMMON) && !defined(ASM_OUTPUT_ALIGNED_DECL_COMMON) && !defined(ASM_OUTPUT_ALIGNED_BSS)
1635       if ((unsigned HOST_WIDE_INT) DECL_ALIGN (decl) / BITS_PER_UNIT > rounded)
1636          warning_with_decl
1637            (decl, "requested alignment for %s is greater than implemented alignment of %d",rounded);
1638 #endif
1639
1640       asm_emit_uninitialised (decl, name, size, rounded);
1641
1642       return;
1643     }
1644
1645   /* Handle initialized definitions.
1646      Also handle uninitialized global definitions if -fno-common and the
1647      target doesn't support ASM_OUTPUT_BSS.  */
1648
1649   /* First make the assembler name(s) global if appropriate.  */
1650   if (TREE_PUBLIC (decl) && DECL_NAME (decl))
1651     globalize_decl (decl);
1652
1653   /* Switch to the appropriate section.  */
1654   variable_section (decl, reloc);
1655
1656   /* dbxout.c needs to know this.  */
1657   if (in_text_section ())
1658     DECL_IN_TEXT_SECTION (decl) = 1;
1659
1660   /* Output the alignment of this data.  */
1661   if (align > BITS_PER_UNIT)
1662     {
1663       ASM_OUTPUT_ALIGN (asm_out_file,
1664                         floor_log2 (DECL_ALIGN (decl) / BITS_PER_UNIT));
1665     }
1666
1667   /* Do any machine/system dependent processing of the object.  */
1668 #ifdef ASM_DECLARE_OBJECT_NAME
1669   last_assemble_variable_decl = decl;
1670   ASM_DECLARE_OBJECT_NAME (asm_out_file, name, decl);
1671 #else
1672   /* Standard thing is just output label for the object.  */
1673   ASM_OUTPUT_LABEL (asm_out_file, name);
1674 #endif /* ASM_DECLARE_OBJECT_NAME */
1675
1676   if (!dont_output_data)
1677     {
1678       if (DECL_INITIAL (decl) && DECL_INITIAL (decl) != error_mark_node)
1679         /* Output the actual data.  */
1680         output_constant (DECL_INITIAL (decl),
1681                          tree_low_cst (DECL_SIZE_UNIT (decl), 1),
1682                          align);
1683       else
1684         /* Leave space for it.  */
1685         assemble_zeros (tree_low_cst (DECL_SIZE_UNIT (decl), 1));
1686     }
1687 }
1688
1689 /* Return 1 if type TYPE contains any pointers.  */
1690
1691 static int
1692 contains_pointers_p (type)
1693      tree type;
1694 {
1695   switch (TREE_CODE (type))
1696     {
1697     case POINTER_TYPE:
1698     case REFERENCE_TYPE:
1699       /* I'm not sure whether OFFSET_TYPE needs this treatment,
1700          so I'll play safe and return 1.  */
1701     case OFFSET_TYPE:
1702       return 1;
1703
1704     case RECORD_TYPE:
1705     case UNION_TYPE:
1706     case QUAL_UNION_TYPE:
1707       {
1708         tree fields;
1709         /* For a type that has fields, see if the fields have pointers.  */
1710         for (fields = TYPE_FIELDS (type); fields; fields = TREE_CHAIN (fields))
1711           if (TREE_CODE (fields) == FIELD_DECL
1712               && contains_pointers_p (TREE_TYPE (fields)))
1713             return 1;
1714         return 0;
1715       }
1716
1717     case ARRAY_TYPE:
1718       /* An array type contains pointers if its element type does.  */
1719       return contains_pointers_p (TREE_TYPE (type));
1720
1721     default:
1722       return 0;
1723     }
1724 }
1725
1726 /* Output something to declare an external symbol to the assembler.
1727    (Most assemblers don't need this, so we normally output nothing.)
1728    Do nothing if DECL is not external.  */
1729
1730 void
1731 assemble_external (decl)
1732      tree decl ATTRIBUTE_UNUSED;
1733 {
1734   /* Because most platforms do not define ASM_OUTPUT_EXTERNAL, the
1735      main body of this code is only rarely exercised.  To provide some
1736      testing, on all platforms, we make sure that the ASM_OUT_FILE is
1737      open.  If it's not, we should not be calling this function.  */
1738   if (!asm_out_file)
1739     abort ();
1740
1741 #ifdef ASM_OUTPUT_EXTERNAL
1742   if (DECL_P (decl) && DECL_EXTERNAL (decl) && TREE_PUBLIC (decl))
1743     {
1744       rtx rtl = DECL_RTL (decl);
1745
1746       if (GET_CODE (rtl) == MEM && GET_CODE (XEXP (rtl, 0)) == SYMBOL_REF
1747           && ! SYMBOL_REF_USED (XEXP (rtl, 0)))
1748         {
1749           /* Some systems do require some output.  */
1750           SYMBOL_REF_USED (XEXP (rtl, 0)) = 1;
1751           ASM_OUTPUT_EXTERNAL (asm_out_file, decl, XSTR (XEXP (rtl, 0), 0));
1752         }
1753     }
1754 #endif
1755 }
1756
1757 /* Similar, for calling a library function FUN.  */
1758
1759 void
1760 assemble_external_libcall (fun)
1761      rtx fun ATTRIBUTE_UNUSED;
1762 {
1763 #ifdef ASM_OUTPUT_EXTERNAL_LIBCALL
1764   /* Declare library function name external when first used, if nec.  */
1765   if (! SYMBOL_REF_USED (fun))
1766     {
1767       SYMBOL_REF_USED (fun) = 1;
1768       ASM_OUTPUT_EXTERNAL_LIBCALL (asm_out_file, fun);
1769     }
1770 #endif
1771 }
1772
1773 /* Declare the label NAME global.  */
1774
1775 void
1776 assemble_global (name)
1777      const char *name ATTRIBUTE_UNUSED;
1778 {
1779   ASM_GLOBALIZE_LABEL (asm_out_file, name);
1780 }
1781
1782 /* Assemble a label named NAME.  */
1783
1784 void
1785 assemble_label (name)
1786      const char *name;
1787 {
1788   ASM_OUTPUT_LABEL (asm_out_file, name);
1789 }
1790
1791 /* Output to FILE a reference to the assembler name of a C-level name NAME.
1792    If NAME starts with a *, the rest of NAME is output verbatim.
1793    Otherwise NAME is transformed in an implementation-defined way
1794    (usually by the addition of an underscore).
1795    Many macros in the tm file are defined to call this function.  */
1796
1797 void
1798 assemble_name (file, name)
1799      FILE *file;
1800      const char *name;
1801 {
1802   const char *real_name;
1803   tree id;
1804
1805   STRIP_NAME_ENCODING (real_name, name);
1806
1807   id = maybe_get_identifier (real_name);
1808   if (id)
1809     TREE_SYMBOL_REFERENCED (id) = 1;
1810
1811   if (name[0] == '*')
1812     fputs (&name[1], file);
1813   else
1814     ASM_OUTPUT_LABELREF (file, name);
1815 }
1816
1817 /* Allocate SIZE bytes writable static space with a gensym name
1818    and return an RTX to refer to its address.  */
1819
1820 rtx
1821 assemble_static_space (size)
1822      int size;
1823 {
1824   char name[12];
1825   const char *namestring;
1826   rtx x;
1827
1828 #if 0
1829   if (flag_shared_data)
1830     data_section ();
1831 #endif
1832
1833   ASM_GENERATE_INTERNAL_LABEL (name, "LF", const_labelno);
1834   ++const_labelno;
1835   namestring = ggc_strdup (name);
1836
1837   x = gen_rtx_SYMBOL_REF (Pmode, namestring);
1838
1839 #ifdef ASM_OUTPUT_ALIGNED_DECL_LOCAL
1840   ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file, NULL_TREE, name, size,
1841                                  BIGGEST_ALIGNMENT);
1842 #else
1843 #ifdef ASM_OUTPUT_ALIGNED_LOCAL
1844   ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, BIGGEST_ALIGNMENT);
1845 #else
1846   {
1847     /* Round size up to multiple of BIGGEST_ALIGNMENT bits
1848        so that each uninitialized object starts on such a boundary.  */
1849     /* Variable `rounded' might or might not be used in ASM_OUTPUT_LOCAL.  */
1850     int rounded ATTRIBUTE_UNUSED
1851       = ((size + (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1)
1852          / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
1853          * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
1854     ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
1855   }
1856 #endif
1857 #endif
1858   return x;
1859 }
1860
1861 /* Assemble the static constant template for function entry trampolines.
1862    This is done at most once per compilation.
1863    Returns an RTX for the address of the template.  */
1864
1865 #ifdef TRAMPOLINE_TEMPLATE
1866 rtx
1867 assemble_trampoline_template ()
1868 {
1869   char label[256];
1870   const char *name;
1871   int align;
1872
1873   /* By default, put trampoline templates in read-only data section.  */
1874
1875 #ifdef TRAMPOLINE_SECTION
1876   TRAMPOLINE_SECTION ();
1877 #else
1878   readonly_data_section ();
1879 #endif
1880
1881   /* Write the assembler code to define one.  */
1882   align = floor_log2 (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT);
1883   if (align > 0)
1884     {
1885       ASM_OUTPUT_ALIGN (asm_out_file, align);
1886     }
1887
1888   ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LTRAMP", 0);
1889   TRAMPOLINE_TEMPLATE (asm_out_file);
1890
1891   /* Record the rtl to refer to it.  */
1892   ASM_GENERATE_INTERNAL_LABEL (label, "LTRAMP", 0);
1893   name = ggc_strdup (label);
1894   return gen_rtx_SYMBOL_REF (Pmode, name);
1895 }
1896 #endif
1897 \f
1898 /* A and B are either alignments or offsets.  Return the minimum alignment
1899    that may be assumed after adding the two together.  */
1900
1901 static inline unsigned
1902 min_align (a, b)
1903      unsigned int a, b;
1904 {
1905   return (a | b) & -(a | b);
1906 }
1907
1908 /* Return the assembler directive for creating a given kind of integer
1909    object.  SIZE is the number of bytes in the object and ALIGNED_P
1910    indicates whether it is known to be aligned.  Return NULL if the
1911    assembly dialect has no such directive.
1912
1913    The returned string should be printed at the start of a new line and
1914    be followed immediately by the object's initial value.  */
1915
1916 const char *
1917 integer_asm_op (size, aligned_p)
1918      int size;
1919      int aligned_p;
1920 {
1921   struct asm_int_op *ops;
1922
1923   if (aligned_p)
1924     ops = &targetm.asm_out.aligned_op;
1925   else
1926     ops = &targetm.asm_out.unaligned_op;
1927
1928   switch (size)
1929     {
1930     case 1:
1931       return targetm.asm_out.byte_op;
1932     case 2:
1933       return ops->hi;
1934     case 4:
1935       return ops->si;
1936     case 8:
1937       return ops->di;
1938     case 16:
1939       return ops->ti;
1940     default:
1941       return NULL;
1942     }
1943 }
1944
1945 /* Use directive OP to assemble an integer object X.  Print OP at the
1946    start of the line, followed immediately by the value of X.  */
1947
1948 void
1949 assemble_integer_with_op (op, x)
1950      const char *op;
1951      rtx x;
1952 {
1953   fputs (op, asm_out_file);
1954   output_addr_const (asm_out_file, x);
1955   fputc ('\n', asm_out_file);
1956 }
1957
1958 /* The default implementation of the asm_out.integer target hook.  */
1959
1960 bool
1961 default_assemble_integer (x, size, aligned_p)
1962      rtx x ATTRIBUTE_UNUSED;
1963      unsigned int size ATTRIBUTE_UNUSED;
1964      int aligned_p ATTRIBUTE_UNUSED;
1965 {
1966   const char *op = integer_asm_op (size, aligned_p);
1967   return op && (assemble_integer_with_op (op, x), true);
1968 }
1969
1970 /* Assemble the integer constant X into an object of SIZE bytes.  ALIGN is
1971    the alignment of the integer in bits.  Return 1 if we were able to output
1972    the constant, otherwise 0.  If FORCE is non-zero, abort if we can't output
1973    the constant.  */
1974
1975 bool
1976 assemble_integer (x, size, align, force)
1977      rtx x;
1978      unsigned int size;
1979      unsigned int align;
1980      int force;
1981 {
1982   int aligned_p;
1983
1984   aligned_p = (align >= MIN (size * BITS_PER_UNIT, BIGGEST_ALIGNMENT));
1985
1986   /* See if the target hook can handle this kind of object.  */
1987   if ((*targetm.asm_out.integer) (x, size, aligned_p))
1988     return true;
1989
1990   /* If the object is a multi-byte one, try splitting it up.  Split
1991      it into words it if is multi-word, otherwise split it into bytes.  */
1992   if (size > 1)
1993     {
1994       enum machine_mode omode, imode;
1995       unsigned int subalign;
1996       unsigned int subsize, i;
1997
1998       subsize = size > UNITS_PER_WORD? UNITS_PER_WORD : 1;
1999       subalign = MIN (align, subsize * BITS_PER_UNIT);
2000       omode = mode_for_size (subsize * BITS_PER_UNIT, MODE_INT, 0);
2001       imode = mode_for_size (size * BITS_PER_UNIT, MODE_INT, 0);
2002
2003       for (i = 0; i < size; i += subsize)
2004         {
2005           rtx partial = simplify_subreg (omode, x, imode, i);
2006           if (!partial || !assemble_integer (partial, subsize, subalign, 0))
2007             break;
2008         }
2009       if (i == size)
2010         return true;
2011
2012       /* If we've printed some of it, but not all of it, there's no going
2013          back now.  */
2014       if (i > 0)
2015         abort ();
2016     }
2017
2018   if (force)
2019     abort ();
2020
2021   return false;
2022 }
2023 \f
2024 void
2025 assemble_real (d, mode, align)
2026      REAL_VALUE_TYPE d;
2027      enum machine_mode mode;
2028      unsigned int align;
2029 {
2030   long data[4];
2031   long l;
2032   unsigned int nalign = min_align (align, 32);
2033
2034   switch (BITS_PER_UNIT)
2035     {
2036     case 8:
2037       switch (mode)
2038         {
2039         case SFmode:
2040           REAL_VALUE_TO_TARGET_SINGLE (d, l);
2041           assemble_integer (GEN_INT (l), 4, align, 1);
2042           break;
2043         case DFmode:
2044           REAL_VALUE_TO_TARGET_DOUBLE (d, data);
2045           assemble_integer (GEN_INT (data[0]), 4, align, 1);
2046           assemble_integer (GEN_INT (data[1]), 4, nalign, 1);
2047           break;
2048         case XFmode:
2049           REAL_VALUE_TO_TARGET_LONG_DOUBLE (d, data);
2050           assemble_integer (GEN_INT (data[0]), 4, align, 1);
2051           assemble_integer (GEN_INT (data[1]), 4, nalign, 1);
2052           assemble_integer (GEN_INT (data[2]), 4, nalign, 1);
2053           break;
2054         case TFmode:
2055           REAL_VALUE_TO_TARGET_LONG_DOUBLE (d, data);
2056           assemble_integer (GEN_INT (data[0]), 4, align, 1);
2057           assemble_integer (GEN_INT (data[1]), 4, nalign, 1);
2058           assemble_integer (GEN_INT (data[2]), 4, nalign, 1);
2059           assemble_integer (GEN_INT (data[3]), 4, nalign, 1);
2060           break;
2061         default:
2062           abort ();
2063         }
2064       break;
2065
2066     case 16:
2067       switch (mode)
2068         {
2069         case HFmode:
2070           REAL_VALUE_TO_TARGET_SINGLE (d, l);
2071           assemble_integer (GEN_INT (l), 2, align, 1);
2072           break;
2073         case TQFmode:
2074           REAL_VALUE_TO_TARGET_DOUBLE (d, data);
2075           assemble_integer (GEN_INT (data[0]), 2, align, 1);
2076           assemble_integer (GEN_INT (data[1]), 1, nalign, 1);
2077           break;
2078         default:
2079           abort ();
2080         }
2081       break;
2082
2083     case 32:
2084       switch (mode)
2085         {
2086         case QFmode:
2087           REAL_VALUE_TO_TARGET_SINGLE (d, l);
2088           assemble_integer (GEN_INT (l), 1, align, 1);
2089           break;
2090         case HFmode:
2091           REAL_VALUE_TO_TARGET_DOUBLE (d, data);
2092           assemble_integer (GEN_INT (data[0]), 1, align, 1);
2093           assemble_integer (GEN_INT (data[1]), 1, nalign, 1);
2094           break;
2095         default:
2096           abort ();
2097         }
2098       break;
2099
2100     default:
2101       abort ();
2102     }
2103 }
2104 \f
2105 /* Here we combine duplicate floating constants to make
2106    CONST_DOUBLE rtx's, and force those out to memory when necessary.  */
2107
2108 /* Return a CONST_DOUBLE or CONST_INT for a value specified as a pair of ints.
2109    For an integer, I0 is the low-order word and I1 is the high-order word.
2110    For a real number, I0 is the word with the low address
2111    and I1 is the word with the high address.  */
2112
2113 rtx
2114 immed_double_const (i0, i1, mode)
2115      HOST_WIDE_INT i0, i1;
2116      enum machine_mode mode;
2117 {
2118   rtx r;
2119
2120   if (GET_MODE_CLASS (mode) == MODE_INT
2121       || GET_MODE_CLASS (mode) == MODE_PARTIAL_INT)
2122     {
2123       /* We clear out all bits that don't belong in MODE, unless they and our
2124          sign bit are all one.  So we get either a reasonable negative value
2125          or a reasonable unsigned value for this mode.  */
2126       int width = GET_MODE_BITSIZE (mode);
2127       if (width < HOST_BITS_PER_WIDE_INT
2128           && ((i0 & ((HOST_WIDE_INT) (-1) << (width - 1)))
2129               != ((HOST_WIDE_INT) (-1) << (width - 1))))
2130         i0 &= ((HOST_WIDE_INT) 1 << width) - 1, i1 = 0;
2131       else if (width == HOST_BITS_PER_WIDE_INT
2132                && ! (i1 == ~0 && i0 < 0))
2133         i1 = 0;
2134       else if (width > 2 * HOST_BITS_PER_WIDE_INT)
2135         /* We cannot represent this value as a constant.  */
2136         abort ();
2137
2138       /* If this would be an entire word for the target, but is not for
2139          the host, then sign-extend on the host so that the number will look
2140          the same way on the host that it would on the target.
2141
2142          For example, when building a 64 bit alpha hosted 32 bit sparc
2143          targeted compiler, then we want the 32 bit unsigned value -1 to be
2144          represented as a 64 bit value -1, and not as 0x00000000ffffffff.
2145          The later confuses the sparc backend.  */
2146
2147       if (width < HOST_BITS_PER_WIDE_INT
2148           && (i0 & ((HOST_WIDE_INT) 1 << (width - 1))))
2149         i0 |= ((HOST_WIDE_INT) (-1) << width);
2150
2151       /* If MODE fits within HOST_BITS_PER_WIDE_INT, always use a CONST_INT.
2152
2153          ??? Strictly speaking, this is wrong if we create a CONST_INT
2154          for a large unsigned constant with the size of MODE being
2155          HOST_BITS_PER_WIDE_INT and later try to interpret that constant in a
2156          wider mode.  In that case we will mis-interpret it as a negative
2157          number.
2158
2159          Unfortunately, the only alternative is to make a CONST_DOUBLE
2160          for any constant in any mode if it is an unsigned constant larger
2161          than the maximum signed integer in an int on the host.  However,
2162          doing this will break everyone that always expects to see a CONST_INT
2163          for SImode and smaller.
2164
2165          We have always been making CONST_INTs in this case, so nothing new
2166          is being broken.  */
2167
2168       if (width <= HOST_BITS_PER_WIDE_INT)
2169         i1 = (i0 < 0) ? ~(HOST_WIDE_INT) 0 : 0;
2170
2171       /* If this integer fits in one word, return a CONST_INT.  */
2172       if ((i1 == 0 && i0 >= 0)
2173           || (i1 == ~0 && i0 < 0))
2174         return GEN_INT (i0);
2175
2176       /* We use VOIDmode for integers.  */
2177       mode = VOIDmode;
2178     }
2179
2180   /* Search the chain for an existing CONST_DOUBLE with the right value.
2181      If one is found, return it.  */
2182   if (cfun != 0)
2183     for (r = const_double_chain; r; r = CONST_DOUBLE_CHAIN (r))
2184       if (CONST_DOUBLE_LOW (r) == i0 && CONST_DOUBLE_HIGH (r) == i1
2185           && GET_MODE (r) == mode)
2186         return r;
2187
2188   /* No; make a new one and add it to the chain.  */
2189   r = gen_rtx_CONST_DOUBLE (mode, i0, i1);
2190
2191   /* Don't touch const_double_chain if not inside any function.  */
2192   if (current_function_decl != 0)
2193     {
2194       CONST_DOUBLE_CHAIN (r) = const_double_chain;
2195       const_double_chain = r;
2196     }
2197
2198   return r;
2199 }
2200
2201 /* Return a CONST_DOUBLE for a specified `double' value
2202    and machine mode.  */
2203
2204 rtx
2205 immed_real_const_1 (d, mode)
2206      REAL_VALUE_TYPE d;
2207      enum machine_mode mode;
2208 {
2209   rtx r;
2210
2211   /* Detect special cases.  Check for NaN first, because some ports
2212      (specifically the i386) do not emit correct ieee-fp code by default, and
2213      thus will generate a core dump here if we pass a NaN to REAL_VALUES_EQUAL
2214      and if REAL_VALUES_EQUAL does a floating point comparison.  */
2215   if (! REAL_VALUE_ISNAN (d) && REAL_VALUES_IDENTICAL (dconst0, d))
2216     return CONST0_RTX (mode);
2217   else if (! REAL_VALUE_ISNAN (d) && REAL_VALUES_EQUAL (dconst1, d))
2218     return CONST1_RTX (mode);
2219   else if (! REAL_VALUE_ISNAN (d) && REAL_VALUES_EQUAL (dconst2, d))
2220     return CONST2_RTX (mode);
2221
2222   if (sizeof (REAL_VALUE_TYPE) == sizeof (HOST_WIDE_INT))
2223     return immed_double_const (d.r[0], 0, mode);
2224   if (sizeof (REAL_VALUE_TYPE) == 2 * sizeof (HOST_WIDE_INT))
2225     return immed_double_const (d.r[0], d.r[1], mode);
2226
2227   /* The rest of this function handles the case where
2228      a float value requires more than 2 ints of space.
2229      It will be deleted as dead code on machines that don't need it.  */
2230
2231   /* Search the chain for an existing CONST_DOUBLE with the right value.
2232      If one is found, return it.  */
2233   if (cfun != 0)
2234     for (r = const_double_chain; r; r = CONST_DOUBLE_CHAIN (r))
2235       if (! memcmp ((char *) &CONST_DOUBLE_LOW (r), (char *) &d, sizeof d)
2236           && GET_MODE (r) == mode)
2237         return r;
2238
2239   /* No; make a new one and add it to the chain.
2240
2241      We may be called by an optimizer which may be discarding any memory
2242      allocated during its processing (such as combine and loop).  However,
2243      we will be leaving this constant on the chain, so we cannot tolerate
2244      freed memory.  */
2245   r = rtx_alloc (CONST_DOUBLE);
2246   PUT_MODE (r, mode);
2247   memcpy ((char *) &CONST_DOUBLE_LOW (r), (char *) &d, sizeof d);
2248
2249   /* If we aren't inside a function, don't put r on the
2250      const_double_chain.  */
2251   if (current_function_decl != 0)
2252     {
2253       CONST_DOUBLE_CHAIN (r) = const_double_chain;
2254       const_double_chain = r;
2255     }
2256   else
2257     CONST_DOUBLE_CHAIN (r) = NULL_RTX;
2258
2259   return r;
2260 }
2261
2262 /* Return a CONST_DOUBLE rtx for a value specified by EXP,
2263    which must be a REAL_CST tree node.  */
2264
2265 rtx
2266 immed_real_const (exp)
2267      tree exp;
2268 {
2269   return immed_real_const_1 (TREE_REAL_CST (exp), TYPE_MODE (TREE_TYPE (exp)));
2270 }
2271
2272 /* At the end of a function, forget the memory-constants
2273    previously made for CONST_DOUBLEs.  Mark them as not on real_constant_chain.
2274    Also clear out real_constant_chain and clear out all the chain-pointers.  */
2275
2276 void
2277 clear_const_double_mem ()
2278 {
2279   rtx r, next;
2280
2281   for (r = const_double_chain; r; r = next)
2282     {
2283       next = CONST_DOUBLE_CHAIN (r);
2284       CONST_DOUBLE_CHAIN (r) = 0;
2285     }
2286   const_double_chain = 0;
2287 }
2288 \f
2289 /* Given an expression EXP with a constant value,
2290    reduce it to the sum of an assembler symbol and an integer.
2291    Store them both in the structure *VALUE.
2292    Abort if EXP does not reduce.  */
2293
2294 struct addr_const
2295 {
2296   rtx base;
2297   HOST_WIDE_INT offset;
2298 };
2299
2300 static void
2301 decode_addr_const (exp, value)
2302      tree exp;
2303      struct addr_const *value;
2304 {
2305   tree target = TREE_OPERAND (exp, 0);
2306   int offset = 0;
2307   rtx x;
2308
2309   while (1)
2310     {
2311       if (TREE_CODE (target) == COMPONENT_REF
2312           && host_integerp (byte_position (TREE_OPERAND (target, 1)), 0))
2313
2314         {
2315           offset += int_byte_position (TREE_OPERAND (target, 1));
2316           target = TREE_OPERAND (target, 0);
2317         }
2318       else if (TREE_CODE (target) == ARRAY_REF
2319                || TREE_CODE (target) == ARRAY_RANGE_REF)
2320         {
2321           offset += (tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (target)), 1)
2322                      * tree_low_cst (TREE_OPERAND (target, 1), 0));
2323           target = TREE_OPERAND (target, 0);
2324         }
2325       else
2326         break;
2327     }
2328
2329   switch (TREE_CODE (target))
2330     {
2331     case VAR_DECL:
2332     case FUNCTION_DECL:
2333       x = DECL_RTL (target);
2334       break;
2335
2336     case LABEL_DECL:
2337       x = gen_rtx_MEM (FUNCTION_MODE,
2338                        gen_rtx_LABEL_REF (VOIDmode,
2339                                           label_rtx (TREE_OPERAND (exp, 0))));
2340       break;
2341
2342     case REAL_CST:
2343     case STRING_CST:
2344     case COMPLEX_CST:
2345     case CONSTRUCTOR:
2346     case INTEGER_CST:
2347       /* This constant should have been output already, but we can't simply
2348          use TREE_CST_RTL since INTEGER_CST doesn't have one.  */
2349       x = output_constant_def (target, 1);
2350       break;
2351
2352     default:
2353       abort ();
2354     }
2355
2356   if (GET_CODE (x) != MEM)
2357     abort ();
2358   x = XEXP (x, 0);
2359
2360   value->base = x;
2361   value->offset = offset;
2362 }
2363 \f
2364 /* We do RTX_UNSPEC + XINT (blah), so nothing can go after RTX_UNSPEC.  */
2365 enum kind { RTX_UNKNOWN, RTX_DOUBLE, RTX_INT, RTX_VECTOR, RTX_UNSPEC };
2366 struct rtx_const
2367 {
2368   ENUM_BITFIELD(kind) kind : 16;
2369   ENUM_BITFIELD(machine_mode) mode : 16;
2370   union {
2371     REAL_VALUE_TYPE du;
2372     struct addr_const addr;
2373     struct {HOST_WIDE_INT high, low;} di;
2374
2375     /* The max vector size we have is 8 wide.  This should be enough.  */
2376     HOST_WIDE_INT veclo[16];
2377     HOST_WIDE_INT vechi[16];
2378   } un;
2379 };
2380
2381 /* Uniquize all constants that appear in memory.
2382    Each constant in memory thus far output is recorded
2383    in `const_hash_table' with a `struct constant_descriptor'
2384    that contains a polish representation of the value of
2385    the constant.
2386
2387    We cannot store the trees in the hash table
2388    because the trees may be temporary.  */
2389
2390 struct constant_descriptor
2391 {
2392   struct constant_descriptor *next;
2393   const char *label;
2394   rtx rtl;
2395   /* Make sure the data is reasonably aligned.  */
2396   union
2397   {
2398     unsigned char contents[1];
2399 #ifdef HAVE_LONG_DOUBLE
2400     long double d;
2401 #else
2402     double d;
2403 #endif
2404   } u;
2405 };
2406
2407 #define HASHBITS 30
2408 #define MAX_HASH_TABLE 1009
2409 static struct constant_descriptor *const_hash_table[MAX_HASH_TABLE];
2410
2411 /* We maintain a hash table of STRING_CST values.  Unless we are asked to force
2412    out a string constant, we defer output of the constants until we know
2413    they are actually used.  This will be if something takes its address or if
2414    there is a usage of the string in the RTL of a function.  */
2415
2416 #define STRHASH(x) ((hashval_t) ((long) (x) >> 3))
2417
2418 struct deferred_string
2419 {
2420   const char *label;
2421   tree exp;
2422   int labelno;
2423 };
2424
2425 static htab_t const_str_htab;
2426
2427 /* Mark a const_hash_table descriptor for GC.  */
2428
2429 static void
2430 mark_const_hash_entry (ptr)
2431      void *ptr;
2432 {
2433   struct constant_descriptor *desc = * (struct constant_descriptor **) ptr;
2434
2435   while (desc)
2436     {
2437       ggc_mark_rtx (desc->rtl);
2438       desc = desc->next;
2439     }
2440 }
2441
2442 /* Mark the hash-table element X (which is really a pointer to an
2443    struct deferred_string *).  */
2444
2445 static int
2446 mark_const_str_htab_1 (x, data)
2447      void **x;
2448      void *data ATTRIBUTE_UNUSED;
2449 {
2450   ggc_mark_tree (((struct deferred_string *) *x)->exp);
2451   return 1;
2452 }
2453
2454 /* Mark a const_str_htab for GC.  */
2455
2456 static void
2457 mark_const_str_htab (htab)
2458      void *htab;
2459 {
2460   htab_traverse (*((htab_t *) htab), mark_const_str_htab_1, NULL);
2461 }
2462
2463 /* Returns a hash code for X (which is a really a
2464    struct deferred_string *).  */
2465
2466 static hashval_t
2467 const_str_htab_hash (x)
2468      const void *x;
2469 {
2470   return STRHASH (((const struct deferred_string *) x)->label);
2471 }
2472
2473 /* Returns non-zero if the value represented by X (which is really a
2474    struct deferred_string *) is the same as that given by Y
2475    (which is really a char *).  */
2476
2477 static int
2478 const_str_htab_eq (x, y)
2479      const void *x;
2480      const void *y;
2481 {
2482   return (((const struct deferred_string *) x)->label == (const char *) y);
2483 }
2484
2485 /* Delete the hash table entry dfsp.  */
2486
2487 static void
2488 const_str_htab_del (dfsp)
2489     void *dfsp;
2490 {
2491   free (dfsp);
2492 }
2493
2494 /* Compute a hash code for a constant expression.  */
2495
2496 static int
2497 const_hash (exp)
2498      tree exp;
2499 {
2500   const char *p;
2501   int len, hi, i;
2502   enum tree_code code = TREE_CODE (exp);
2503
2504   /* Either set P and LEN to the address and len of something to hash and
2505      exit the switch or return a value.  */
2506
2507   switch (code)
2508     {
2509     case INTEGER_CST:
2510       p = (char *) &TREE_INT_CST (exp);
2511       len = sizeof TREE_INT_CST (exp);
2512       break;
2513
2514     case REAL_CST:
2515       p = (char *) &TREE_REAL_CST (exp);
2516       len = sizeof TREE_REAL_CST (exp);
2517       break;
2518
2519     case STRING_CST:
2520       p = TREE_STRING_POINTER (exp);
2521       len = TREE_STRING_LENGTH (exp);
2522       break;
2523
2524     case COMPLEX_CST:
2525       return (const_hash (TREE_REALPART (exp)) * 5
2526               + const_hash (TREE_IMAGPART (exp)));
2527
2528     case CONSTRUCTOR:
2529       if (TREE_CODE (TREE_TYPE (exp)) == SET_TYPE)
2530         {
2531           char *tmp;
2532
2533           len = int_size_in_bytes (TREE_TYPE (exp));
2534           tmp = (char *) alloca (len);
2535           get_set_constructor_bytes (exp, (unsigned char *) tmp, len);
2536           p = tmp;
2537           break;
2538         }
2539       else
2540         {
2541           tree link;
2542
2543           /* For record type, include the type in the hashing.
2544              We do not do so for array types
2545              because (1) the sizes of the elements are sufficient
2546              and (2) distinct array types can have the same constructor.
2547              Instead, we include the array size because the constructor could
2548              be shorter.  */
2549           if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
2550             hi = ((unsigned long) TREE_TYPE (exp) & ((1 << HASHBITS) - 1))
2551               % MAX_HASH_TABLE;
2552           else
2553             hi = ((5 + int_size_in_bytes (TREE_TYPE (exp)))
2554                   & ((1 << HASHBITS) - 1)) % MAX_HASH_TABLE;
2555
2556           for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
2557             if (TREE_VALUE (link))
2558               hi
2559                 = (hi * 603 + const_hash (TREE_VALUE (link))) % MAX_HASH_TABLE;
2560
2561           return hi;
2562         }
2563
2564     case ADDR_EXPR:
2565       {
2566         struct addr_const value;
2567
2568         decode_addr_const (exp, &value);
2569         if (GET_CODE (value.base) == SYMBOL_REF)
2570           {
2571             /* Don't hash the address of the SYMBOL_REF;
2572                only use the offset and the symbol name.  */
2573             hi = value.offset;
2574             p = XSTR (value.base, 0);
2575             for (i = 0; p[i] != 0; i++)
2576               hi = ((hi * 613) + (unsigned) (p[i]));
2577           }
2578         else if (GET_CODE (value.base) == LABEL_REF)
2579           hi = value.offset + CODE_LABEL_NUMBER (XEXP (value.base, 0)) * 13;
2580         else
2581           abort ();
2582
2583         hi &= (1 << HASHBITS) - 1;
2584         hi %= MAX_HASH_TABLE;
2585       }
2586       return hi;
2587
2588     case PLUS_EXPR:
2589     case MINUS_EXPR:
2590       return (const_hash (TREE_OPERAND (exp, 0)) * 9
2591               + const_hash (TREE_OPERAND (exp, 1)));
2592
2593     case NOP_EXPR:
2594     case CONVERT_EXPR:
2595     case NON_LVALUE_EXPR:
2596       return const_hash (TREE_OPERAND (exp, 0)) * 7 + 2;
2597
2598     default:
2599       /* A language specific constant. Just hash the code.  */
2600       return (int) code % MAX_HASH_TABLE;
2601     }
2602
2603   /* Compute hashing function */
2604   hi = len;
2605   for (i = 0; i < len; i++)
2606     hi = ((hi * 613) + (unsigned) (p[i]));
2607
2608   hi &= (1 << HASHBITS) - 1;
2609   hi %= MAX_HASH_TABLE;
2610   return hi;
2611 }
2612 \f
2613 /* Compare a constant expression EXP with a constant-descriptor DESC.
2614    Return 1 if DESC describes a constant with the same value as EXP.  */
2615
2616 static int
2617 compare_constant (exp, desc)
2618      tree exp;
2619      struct constant_descriptor *desc;
2620 {
2621   return 0 != compare_constant_1 (exp, desc->u.contents);
2622 }
2623
2624 /* Compare constant expression EXP with a substring P of a constant descriptor.
2625    If they match, return a pointer to the end of the substring matched.
2626    If they do not match, return 0.
2627
2628    Since descriptors are written in polish prefix notation,
2629    this function can be used recursively to test one operand of EXP
2630    against a subdescriptor, and if it succeeds it returns the
2631    address of the subdescriptor for the next operand.  */
2632
2633 static const unsigned char *
2634 compare_constant_1 (exp, p)
2635      tree exp;
2636      const unsigned char *p;
2637 {
2638   const unsigned char *strp;
2639   int len;
2640   enum tree_code code = TREE_CODE (exp);
2641
2642   if (code != (enum tree_code) *p++)
2643     return 0;
2644
2645   /* Either set STRP, P and LEN to pointers and length to compare and exit the
2646      switch, or return the result of the comparison.  */
2647
2648   switch (code)
2649     {
2650     case INTEGER_CST:
2651       /* Integer constants are the same only if the same width of type.  */
2652       if (*p++ != TYPE_PRECISION (TREE_TYPE (exp)))
2653         return 0;
2654
2655       strp = (unsigned char *) &TREE_INT_CST (exp);
2656       len = sizeof TREE_INT_CST (exp);
2657       break;
2658
2659     case REAL_CST:
2660       /* Real constants are the same only if the same width of type.  */
2661       if (*p++ != TYPE_PRECISION (TREE_TYPE (exp)))
2662         return 0;
2663
2664       strp = (unsigned char *) &TREE_REAL_CST (exp);
2665       len = sizeof TREE_REAL_CST (exp);
2666       break;
2667
2668     case STRING_CST:
2669       if (flag_writable_strings)
2670         return 0;
2671
2672       if ((enum machine_mode) *p++ != TYPE_MODE (TREE_TYPE (exp)))
2673         return 0;
2674
2675       strp = (const unsigned char *) TREE_STRING_POINTER (exp);
2676       len = TREE_STRING_LENGTH (exp);
2677       if (memcmp ((char *) &TREE_STRING_LENGTH (exp), p,
2678                   sizeof TREE_STRING_LENGTH (exp)))
2679         return 0;
2680
2681       p += sizeof TREE_STRING_LENGTH (exp);
2682       break;
2683
2684     case COMPLEX_CST:
2685       p = compare_constant_1 (TREE_REALPART (exp), p);
2686       if (p == 0)
2687         return 0;
2688
2689       return compare_constant_1 (TREE_IMAGPART (exp), p);
2690
2691     case CONSTRUCTOR:
2692       if (TREE_CODE (TREE_TYPE (exp)) == SET_TYPE)
2693         {
2694           int xlen = len = int_size_in_bytes (TREE_TYPE (exp));
2695           unsigned char *tmp = (unsigned char *) alloca (len);
2696
2697           get_set_constructor_bytes (exp, tmp, len);
2698           strp = (unsigned char *) tmp;
2699           if (memcmp ((char *) &xlen, p, sizeof xlen))
2700             return 0;
2701
2702           p += sizeof xlen;
2703           break;
2704         }
2705       else
2706         {
2707           tree link;
2708           int length = list_length (CONSTRUCTOR_ELTS (exp));
2709           tree type;
2710           enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
2711           int have_purpose = 0;
2712
2713           for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
2714             if (TREE_PURPOSE (link))
2715               have_purpose = 1;
2716
2717           if (memcmp ((char *) &length, p, sizeof length))
2718             return 0;
2719
2720           p += sizeof length;
2721
2722           /* For record constructors, insist that the types match.
2723              For arrays, just verify both constructors are for arrays.
2724              Then insist that either both or none have any TREE_PURPOSE
2725              values.  */
2726           if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
2727             type = TREE_TYPE (exp);
2728           else
2729             type = 0;
2730
2731           if (memcmp ((char *) &type, p, sizeof type))
2732             return 0;
2733
2734           if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
2735             {
2736               if (memcmp ((char *) &mode, p, sizeof mode))
2737                 return 0;
2738
2739               p += sizeof mode;
2740             }
2741
2742           p += sizeof type;
2743
2744           if (memcmp ((char *) &have_purpose, p, sizeof have_purpose))
2745             return 0;
2746
2747           p += sizeof have_purpose;
2748
2749           /* For arrays, insist that the size in bytes match.  */
2750           if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
2751             {
2752               HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (exp));
2753
2754               if (memcmp ((char *) &size, p, sizeof size))
2755                 return 0;
2756
2757               p += sizeof size;
2758             }
2759
2760           for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
2761             {
2762               if (TREE_VALUE (link))
2763                 {
2764                   if ((p = compare_constant_1 (TREE_VALUE (link), p)) == 0)
2765                     return 0;
2766                 }
2767               else
2768                 {
2769                   tree zero = 0;
2770
2771                   if (memcmp ((char *) &zero, p, sizeof zero))
2772                     return 0;
2773
2774                   p += sizeof zero;
2775                 }
2776
2777               if (TREE_PURPOSE (link)
2778                   && TREE_CODE (TREE_PURPOSE (link)) == FIELD_DECL)
2779                 {
2780                   if (memcmp ((char *) &TREE_PURPOSE (link), p,
2781                             sizeof TREE_PURPOSE (link)))
2782                     return 0;
2783
2784                   p += sizeof TREE_PURPOSE (link);
2785                 }
2786               else if (TREE_PURPOSE (link))
2787                 {
2788                   if ((p = compare_constant_1 (TREE_PURPOSE (link), p)) == 0)
2789                     return 0;
2790                 }
2791               else if (have_purpose)
2792                 {
2793                   int zero = 0;
2794
2795                   if (memcmp ((char *) &zero, p, sizeof zero))
2796                     return 0;
2797
2798                   p += sizeof zero;
2799                 }
2800             }
2801
2802           return p;
2803         }
2804
2805     case ADDR_EXPR:
2806       {
2807         struct addr_const value;
2808
2809         decode_addr_const (exp, &value);
2810         strp = (unsigned char *) &value.offset;
2811         len = sizeof value.offset;
2812         /* Compare the offset.  */
2813         while (--len >= 0)
2814           if (*p++ != *strp++)
2815             return 0;
2816
2817         /* Compare symbol name.  */
2818         strp = (const unsigned char *) XSTR (value.base, 0);
2819         len = strlen ((const char *) strp) + 1;
2820       }
2821       break;
2822
2823     case PLUS_EXPR:
2824     case MINUS_EXPR:
2825     case RANGE_EXPR:
2826       p = compare_constant_1 (TREE_OPERAND (exp, 0), p);
2827       if (p == 0)
2828         return 0;
2829
2830       return compare_constant_1 (TREE_OPERAND (exp, 1), p);
2831
2832     case NOP_EXPR:
2833     case CONVERT_EXPR:
2834     case NON_LVALUE_EXPR:
2835       return compare_constant_1 (TREE_OPERAND (exp, 0), p);
2836
2837     default:
2838       {
2839         tree new = (*lang_hooks.expand_constant) (exp);
2840
2841         if (new != exp)
2842           return compare_constant_1 (new, p);
2843         else
2844           return 0;
2845       }
2846     }
2847
2848   /* Compare constant contents.  */
2849   while (--len >= 0)
2850     if (*p++ != *strp++)
2851       return 0;
2852
2853   return p;
2854 }
2855 \f
2856 /* Construct a constant descriptor for the expression EXP.
2857    It is up to the caller to enter the descriptor in the hash table.  */
2858
2859 static struct constant_descriptor *
2860 record_constant (exp)
2861      tree exp;
2862 {
2863   struct constant_descriptor *next = 0;
2864   char *label = 0;
2865   rtx rtl = 0;
2866   int pad;
2867
2868   /* Make a struct constant_descriptor.  The first three pointers will
2869      be filled in later.  Here we just leave space for them.  */
2870
2871   obstack_grow (&permanent_obstack, (char *) &next, sizeof next);
2872   obstack_grow (&permanent_obstack, (char *) &label, sizeof label);
2873   obstack_grow (&permanent_obstack, (char *) &rtl, sizeof rtl);
2874
2875   /* Align the descriptor for the data payload.  */
2876   pad = (offsetof (struct constant_descriptor, u)
2877          - offsetof(struct constant_descriptor, rtl)
2878          - sizeof(next->rtl));
2879   if (pad > 0)
2880     obstack_blank (&permanent_obstack, pad);
2881
2882   record_constant_1 (exp);
2883   return (struct constant_descriptor *) obstack_finish (&permanent_obstack);
2884 }
2885
2886 /* Add a description of constant expression EXP
2887    to the object growing in `permanent_obstack'.
2888    No need to return its address; the caller will get that
2889    from the obstack when the object is complete.  */
2890
2891 static void
2892 record_constant_1 (exp)
2893      tree exp;
2894 {
2895   const unsigned char *strp;
2896   int len;
2897   enum tree_code code = TREE_CODE (exp);
2898
2899   obstack_1grow (&permanent_obstack, (unsigned int) code);
2900
2901   switch (code)
2902     {
2903     case INTEGER_CST:
2904       obstack_1grow (&permanent_obstack, TYPE_PRECISION (TREE_TYPE (exp)));
2905       strp = (unsigned char *) &TREE_INT_CST (exp);
2906       len = sizeof TREE_INT_CST (exp);
2907       break;
2908
2909     case REAL_CST:
2910       obstack_1grow (&permanent_obstack, TYPE_PRECISION (TREE_TYPE (exp)));
2911       strp = (unsigned char *) &TREE_REAL_CST (exp);
2912       len = sizeof TREE_REAL_CST (exp);
2913       break;
2914
2915     case STRING_CST:
2916       if (flag_writable_strings)
2917         return;
2918
2919       obstack_1grow (&permanent_obstack, TYPE_MODE (TREE_TYPE (exp)));
2920       strp = (const unsigned char *) TREE_STRING_POINTER (exp);
2921       len = TREE_STRING_LENGTH (exp);
2922       obstack_grow (&permanent_obstack, (char *) &TREE_STRING_LENGTH (exp),
2923                     sizeof TREE_STRING_LENGTH (exp));
2924       break;
2925
2926     case COMPLEX_CST:
2927       record_constant_1 (TREE_REALPART (exp));
2928       record_constant_1 (TREE_IMAGPART (exp));
2929       return;
2930
2931     case CONSTRUCTOR:
2932       if (TREE_CODE (TREE_TYPE (exp)) == SET_TYPE)
2933         {
2934           int nbytes = int_size_in_bytes (TREE_TYPE (exp));
2935           obstack_grow (&permanent_obstack, &nbytes, sizeof (nbytes));
2936           obstack_blank (&permanent_obstack, nbytes);
2937           get_set_constructor_bytes
2938             (exp, (unsigned char *) permanent_obstack.next_free-nbytes,
2939              nbytes);
2940           return;
2941         }
2942       else
2943         {
2944           tree link;
2945           int length = list_length (CONSTRUCTOR_ELTS (exp));
2946           enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
2947           tree type;
2948           int have_purpose = 0;
2949
2950           for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
2951             if (TREE_PURPOSE (link))
2952               have_purpose = 1;
2953
2954           obstack_grow (&permanent_obstack, (char *) &length, sizeof length);
2955
2956           /* For record constructors, insist that the types match.
2957              For arrays, just verify both constructors are for arrays
2958              of the same mode.  Then insist that either both or none
2959              have any TREE_PURPOSE values.  */
2960           if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
2961             type = TREE_TYPE (exp);
2962           else
2963             type = 0;
2964
2965           obstack_grow (&permanent_obstack, (char *) &type, sizeof type);
2966           if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
2967             obstack_grow (&permanent_obstack, &mode, sizeof mode);
2968
2969           obstack_grow (&permanent_obstack, (char *) &have_purpose,
2970                         sizeof have_purpose);
2971
2972           /* For arrays, insist that the size in bytes match.  */
2973           if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
2974             {
2975               HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (exp));
2976               obstack_grow (&permanent_obstack, (char *) &size, sizeof size);
2977             }
2978
2979           for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
2980             {
2981               if (TREE_VALUE (link))
2982                 record_constant_1 (TREE_VALUE (link));
2983               else
2984                 {
2985                   tree zero = 0;
2986
2987                   obstack_grow (&permanent_obstack,
2988                                 (char *) &zero, sizeof zero);
2989                 }
2990
2991               if (TREE_PURPOSE (link)
2992                   && TREE_CODE (TREE_PURPOSE (link)) == FIELD_DECL)
2993                 obstack_grow (&permanent_obstack,
2994                               (char *) &TREE_PURPOSE (link),
2995                               sizeof TREE_PURPOSE (link));
2996               else if (TREE_PURPOSE (link))
2997                 record_constant_1 (TREE_PURPOSE (link));
2998               else if (have_purpose)
2999                 {
3000                   int zero = 0;
3001
3002                   obstack_grow (&permanent_obstack,
3003                                 (char *) &zero, sizeof zero);
3004                 }
3005             }
3006         }
3007       return;
3008
3009     case ADDR_EXPR:
3010       {
3011         struct addr_const value;
3012
3013         decode_addr_const (exp, &value);
3014         /* Record the offset.  */
3015         obstack_grow (&permanent_obstack,
3016                       (char *) &value.offset, sizeof value.offset);
3017
3018         switch (GET_CODE (value.base))
3019           {
3020           case SYMBOL_REF:
3021             /* Record the symbol name.  */
3022             obstack_grow (&permanent_obstack, XSTR (value.base, 0),
3023                           strlen (XSTR (value.base, 0)) + 1);
3024             break;
3025           case LABEL_REF:
3026             /* Record the address of the CODE_LABEL.  It may not have
3027                been emitted yet, so it's UID may be zero.  But pointer
3028                identity is good enough.  */
3029             obstack_grow (&permanent_obstack, &XEXP (value.base, 0),
3030                           sizeof (rtx));
3031             break;
3032           default:
3033             abort ();
3034           }
3035       }
3036       return;
3037
3038     case PLUS_EXPR:
3039     case MINUS_EXPR:
3040     case RANGE_EXPR:
3041       record_constant_1 (TREE_OPERAND (exp, 0));
3042       record_constant_1 (TREE_OPERAND (exp, 1));
3043       return;
3044
3045     case NOP_EXPR:
3046     case CONVERT_EXPR:
3047     case NON_LVALUE_EXPR:
3048       record_constant_1 (TREE_OPERAND (exp, 0));
3049       return;
3050
3051     default:
3052       {
3053         tree new = (*lang_hooks.expand_constant) (exp);
3054
3055         if (new != exp)
3056           record_constant_1 (new);
3057         return;
3058       }
3059     }
3060
3061   /* Record constant contents.  */
3062   obstack_grow (&permanent_obstack, strp, len);
3063 }
3064 \f
3065 /* Record a list of constant expressions that were passed to
3066    output_constant_def but that could not be output right away.  */
3067
3068 struct deferred_constant
3069 {
3070   struct deferred_constant *next;
3071   tree exp;
3072   int reloc;
3073   int labelno;
3074 };
3075
3076 static struct deferred_constant *deferred_constants;
3077
3078 /* Another list of constants which should be output after the
3079    function.  */
3080 static struct deferred_constant *after_function_constants;
3081
3082 /* Nonzero means defer output of addressed subconstants
3083    (i.e., those for which output_constant_def is called.)  */
3084 static int defer_addressed_constants_flag;
3085
3086 /* Start deferring output of subconstants.  */
3087
3088 void
3089 defer_addressed_constants ()
3090 {
3091   defer_addressed_constants_flag++;
3092 }
3093
3094 /* Stop deferring output of subconstants,
3095    and output now all those that have been deferred.  */
3096
3097 void
3098 output_deferred_addressed_constants ()
3099 {
3100   struct deferred_constant *p, *next;
3101
3102   defer_addressed_constants_flag--;
3103
3104   if (defer_addressed_constants_flag > 0)
3105     return;
3106
3107   for (p = deferred_constants; p; p = next)
3108     {
3109       output_constant_def_contents (p->exp, p->reloc, p->labelno);
3110       next = p->next;
3111       free (p);
3112     }
3113
3114   deferred_constants = 0;
3115 }
3116
3117 /* Output any constants which should appear after a function.  */
3118
3119 static void
3120 output_after_function_constants ()
3121 {
3122   struct deferred_constant *p, *next;
3123
3124   for (p = after_function_constants; p; p = next)
3125     {
3126       output_constant_def_contents (p->exp, p->reloc, p->labelno);
3127       next = p->next;
3128       free (p);
3129     }
3130
3131   after_function_constants = 0;
3132 }
3133
3134 /* Make a copy of the whole tree structure for a constant.
3135    This handles the same types of nodes that compare_constant
3136    and record_constant handle.  */
3137
3138 static tree
3139 copy_constant (exp)
3140      tree exp;
3141 {
3142   switch (TREE_CODE (exp))
3143     {
3144     case ADDR_EXPR:
3145       /* For ADDR_EXPR, we do not want to copy the decl whose address
3146          is requested.  We do want to copy constants though.  */
3147       if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 0))) == 'c')
3148         return build1 (TREE_CODE (exp), TREE_TYPE (exp),
3149                        copy_constant (TREE_OPERAND (exp, 0)));
3150       else
3151         return copy_node (exp);
3152
3153     case INTEGER_CST:
3154     case REAL_CST:
3155     case STRING_CST:
3156       return copy_node (exp);
3157
3158     case COMPLEX_CST:
3159       return build_complex (TREE_TYPE (exp),
3160                             copy_constant (TREE_REALPART (exp)),
3161                             copy_constant (TREE_IMAGPART (exp)));
3162
3163     case PLUS_EXPR:
3164     case MINUS_EXPR:
3165       return build (TREE_CODE (exp), TREE_TYPE (exp),
3166                     copy_constant (TREE_OPERAND (exp, 0)),
3167                     copy_constant (TREE_OPERAND (exp, 1)));
3168
3169     case NOP_EXPR:
3170     case CONVERT_EXPR:
3171     case NON_LVALUE_EXPR:
3172       return build1 (TREE_CODE (exp), TREE_TYPE (exp),
3173                      copy_constant (TREE_OPERAND (exp, 0)));
3174
3175     case CONSTRUCTOR:
3176       {
3177         tree copy = copy_node (exp);
3178         tree list = copy_list (CONSTRUCTOR_ELTS (exp));
3179         tree tail;
3180
3181         CONSTRUCTOR_ELTS (copy) = list;
3182         for (tail = list; tail; tail = TREE_CHAIN (tail))
3183           TREE_VALUE (tail) = copy_constant (TREE_VALUE (tail));
3184         if (TREE_CODE (TREE_TYPE (exp)) == SET_TYPE)
3185           for (tail = list; tail; tail = TREE_CHAIN (tail))
3186             TREE_PURPOSE (tail) = copy_constant (TREE_PURPOSE (tail));
3187
3188         return copy;
3189       }
3190
3191     default:
3192       abort ();
3193     }
3194 }
3195 \f
3196 /* Return an rtx representing a reference to constant data in memory
3197    for the constant expression EXP.
3198
3199    If assembler code for such a constant has already been output,
3200    return an rtx to refer to it.
3201    Otherwise, output such a constant in memory (or defer it for later)
3202    and generate an rtx for it.
3203
3204    If DEFER is non-zero, the output of string constants can be deferred
3205    and output only if referenced in the function after all optimizations.
3206
3207    The TREE_CST_RTL of EXP is set up to point to that rtx.
3208    The const_hash_table records which constants already have label strings.  */
3209
3210 rtx
3211 output_constant_def (exp, defer)
3212      tree exp;
3213      int defer;
3214 {
3215   int hash;
3216   struct constant_descriptor *desc;
3217   struct deferred_string **defstr;
3218   char label[256];
3219   int reloc;
3220   int found = 1;
3221   int after_function = 0;
3222   int labelno = -1;
3223   rtx rtl;
3224
3225   /* We can't just use the saved RTL if this is a defererred string constant
3226      and we are not to defer anymode.  */
3227   if (TREE_CODE (exp) != INTEGER_CST && TREE_CST_RTL (exp)
3228       && (defer || !STRING_POOL_ADDRESS_P (XEXP (TREE_CST_RTL (exp), 0))))
3229     return TREE_CST_RTL (exp);
3230
3231   /* Make sure any other constants whose addresses appear in EXP
3232      are assigned label numbers.  */
3233
3234   reloc = output_addressed_constants (exp);
3235
3236   /* Compute hash code of EXP.  Search the descriptors for that hash code
3237      to see if any of them describes EXP.  If yes, the descriptor records
3238      the label number already assigned.  */
3239
3240   hash = const_hash (exp) % MAX_HASH_TABLE;
3241
3242   for (desc = const_hash_table[hash]; desc; desc = desc->next)
3243     if (compare_constant (exp, desc))
3244       break;
3245
3246   if (desc == 0)
3247     {
3248       /* No constant equal to EXP is known to have been output.
3249          Make a constant descriptor to enter EXP in the hash table.
3250          Assign the label number and record it in the descriptor for
3251          future calls to this function to find.  */
3252
3253       /* Create a string containing the label name, in LABEL.  */
3254       labelno = const_labelno++;
3255       ASM_GENERATE_INTERNAL_LABEL (label, "LC", labelno);
3256
3257       desc = record_constant (exp);
3258       desc->next = const_hash_table[hash];
3259       desc->label = ggc_strdup (label);
3260       const_hash_table[hash] = desc;
3261
3262       /* We have a symbol name; construct the SYMBOL_REF and the MEM.  */
3263       rtl = desc->rtl
3264         = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (exp)),
3265                        gen_rtx_SYMBOL_REF (Pmode, desc->label));
3266
3267       set_mem_attributes (rtl, exp, 1);
3268       set_mem_alias_set (rtl, 0);
3269       set_mem_alias_set (rtl, const_alias_set);
3270
3271       found = 0;
3272     }
3273   else
3274     rtl = desc->rtl;
3275
3276   if (TREE_CODE (exp) != INTEGER_CST)
3277     TREE_CST_RTL (exp) = rtl;
3278
3279   /* Optionally set flags or add text to the name to record information
3280      such as that it is a function name.  If the name is changed, the macro
3281      ASM_OUTPUT_LABELREF will have to know how to strip this information.  */
3282 #ifdef ENCODE_SECTION_INFO
3283   /* A previously-processed constant would already have section info
3284      encoded in it.  */
3285   if (! found)
3286     {
3287       /* Take care not to invoke ENCODE_SECTION_INFO for constants
3288          which don't have a TREE_CST_RTL.  */
3289       if (TREE_CODE (exp) != INTEGER_CST)
3290         ENCODE_SECTION_INFO (exp, true);
3291
3292       desc->rtl = rtl;
3293       desc->label = XSTR (XEXP (desc->rtl, 0), 0);
3294     }
3295 #endif
3296
3297 #ifdef CONSTANT_AFTER_FUNCTION_P
3298   if (current_function_decl != 0
3299       && CONSTANT_AFTER_FUNCTION_P (exp))
3300     after_function = 1;
3301 #endif
3302
3303   if (found
3304       && STRING_POOL_ADDRESS_P (XEXP (rtl, 0))
3305       && (!defer || defer_addressed_constants_flag || after_function))
3306     {
3307       defstr = (struct deferred_string **)
3308         htab_find_slot_with_hash (const_str_htab, desc->label,
3309                                   STRHASH (desc->label), NO_INSERT);
3310       if (defstr)
3311         {
3312           /* If the string is currently deferred but we need to output it now,
3313              remove it from deferred string hash table.  */
3314           found = 0;
3315           labelno = (*defstr)->labelno;
3316           STRING_POOL_ADDRESS_P (XEXP (rtl, 0)) = 0;
3317           htab_clear_slot (const_str_htab, (void **) defstr);
3318         }
3319     }
3320
3321   /* If this is the first time we've seen this particular constant,
3322      output it (or defer its output for later).  */
3323   if (! found)
3324     {
3325       if (defer_addressed_constants_flag || after_function)
3326         {
3327           struct deferred_constant *p
3328             = (struct deferred_constant *)
3329               xmalloc (sizeof (struct deferred_constant));
3330
3331           p->exp = copy_constant (exp);
3332           p->reloc = reloc;
3333           p->labelno = labelno;
3334           if (after_function)
3335             {
3336               p->next = after_function_constants;
3337               after_function_constants = p;
3338             }
3339           else
3340             {
3341               p->next = deferred_constants;
3342               deferred_constants = p;
3343             }
3344         }
3345       else
3346         {
3347           /* Do no output if -fsyntax-only.  */
3348           if (! flag_syntax_only)
3349             {
3350               if (TREE_CODE (exp) != STRING_CST
3351                   || !defer
3352                   || flag_writable_strings
3353                   || (defstr = (struct deferred_string **)
3354                                htab_find_slot_with_hash (const_str_htab,
3355                                                          desc->label,
3356                                                          STRHASH (desc->label),
3357                                                          INSERT)) == NULL)
3358                 output_constant_def_contents (exp, reloc, labelno);
3359               else
3360                 {
3361                   struct deferred_string *p;
3362
3363                   p = (struct deferred_string *)
3364                       xmalloc (sizeof (struct deferred_string));
3365
3366                   p->exp = copy_constant (exp);
3367                   p->label = desc->label;
3368                   p->labelno = labelno;
3369                   *defstr = p;
3370                   STRING_POOL_ADDRESS_P (XEXP (rtl, 0)) = 1;
3371                 }
3372             }
3373         }
3374     }
3375
3376   return rtl;
3377 }
3378
3379 /* Now output assembler code to define the label for EXP,
3380    and follow it with the data of EXP.  */
3381
3382 static void
3383 output_constant_def_contents (exp, reloc, labelno)
3384      tree exp;
3385      int reloc;
3386      int labelno;
3387 {
3388   int align;
3389
3390   /* Align the location counter as required by EXP's data type.  */
3391   align = TYPE_ALIGN (TREE_TYPE (exp));
3392 #ifdef CONSTANT_ALIGNMENT
3393   align = CONSTANT_ALIGNMENT (exp, align);
3394 #endif
3395
3396   if (IN_NAMED_SECTION (exp))
3397     named_section (exp, NULL, reloc);
3398   else
3399     {
3400       /* First switch to text section, except for writable strings.  */
3401 #ifdef SELECT_SECTION
3402       SELECT_SECTION (exp, reloc, align);
3403 #else
3404       if (((TREE_CODE (exp) == STRING_CST) && flag_writable_strings)
3405           || (flag_pic && reloc))
3406         data_section ();
3407       else
3408         readonly_data_section ();
3409 #endif
3410     }
3411
3412   if (align > BITS_PER_UNIT)
3413     {
3414       ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
3415     }
3416
3417   /* Output the label itself.  */
3418   ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LC", labelno);
3419
3420   /* Output the value of EXP.  */
3421   output_constant (exp,
3422                    (TREE_CODE (exp) == STRING_CST
3423                     ? MAX (TREE_STRING_LENGTH (exp),
3424                            int_size_in_bytes (TREE_TYPE (exp)))
3425                     : int_size_in_bytes (TREE_TYPE (exp))),
3426                    align);
3427
3428 }
3429 \f
3430 /* Structure to represent sufficient information about a constant so that
3431    it can be output when the constant pool is output, so that function
3432    integration can be done, and to simplify handling on machines that reference
3433    constant pool as base+displacement.  */
3434
3435 struct pool_constant
3436 {
3437   struct constant_descriptor *desc;
3438   struct pool_constant *next, *next_sym;
3439   rtx constant;
3440   enum machine_mode mode;
3441   int labelno;
3442   unsigned int align;
3443   HOST_WIDE_INT offset;
3444   int mark;
3445 };
3446
3447 /* Hash code for a SYMBOL_REF with CONSTANT_POOL_ADDRESS_P true.
3448    The argument is XSTR (... , 0)  */
3449
3450 #define SYMHASH(LABEL)  \
3451   ((((unsigned long) (LABEL)) & ((1 << HASHBITS) - 1))  % MAX_RTX_HASH_TABLE)
3452 \f
3453 /* Initialize constant pool hashing for a new function.  */
3454
3455 void
3456 init_varasm_status (f)
3457      struct function *f;
3458 {
3459   struct varasm_status *p;
3460   p = (struct varasm_status *) xmalloc (sizeof (struct varasm_status));
3461   f->varasm = p;
3462   p->x_const_rtx_hash_table
3463     = ((struct constant_descriptor **)
3464        xcalloc (MAX_RTX_HASH_TABLE, sizeof (struct constant_descriptor *)));
3465   p->x_const_rtx_sym_hash_table
3466     = ((struct pool_constant **)
3467        xcalloc (MAX_RTX_HASH_TABLE, sizeof (struct pool_constant *)));
3468
3469   p->x_first_pool = p->x_last_pool = 0;
3470   p->x_pool_offset = 0;
3471   p->x_const_double_chain = 0;
3472 }
3473
3474 /* Mark PC for GC.  */
3475
3476 static void
3477 mark_pool_constant (pc)
3478      struct pool_constant *pc;
3479 {
3480   while (pc)
3481     {
3482       ggc_mark (pc);
3483       ggc_mark_rtx (pc->constant);
3484       ggc_mark_rtx (pc->desc->rtl);
3485       pc = pc->next;
3486     }
3487 }
3488
3489 /* Mark P for GC.  */
3490
3491 void
3492 mark_varasm_status (p)
3493      struct varasm_status *p;
3494 {
3495   if (p == NULL)
3496     return;
3497
3498   mark_pool_constant (p->x_first_pool);
3499   ggc_mark_rtx (p->x_const_double_chain);
3500 }
3501
3502 /* Clear out all parts of the state in F that can safely be discarded
3503    after the function has been compiled, to let garbage collection
3504    reclaim the memory.  */
3505
3506 void
3507 free_varasm_status (f)
3508      struct function *f;
3509 {
3510   struct varasm_status *p;
3511   int i;
3512
3513   p = f->varasm;
3514
3515   /* Clear out the hash tables.  */
3516   for (i = 0; i < MAX_RTX_HASH_TABLE; ++i)
3517     {
3518       struct constant_descriptor *cd;
3519
3520       cd = p->x_const_rtx_hash_table[i];
3521       while (cd)
3522         {
3523           struct constant_descriptor *next = cd->next;
3524
3525           free (cd);
3526           cd = next;
3527         }
3528     }
3529
3530   free (p->x_const_rtx_hash_table);
3531   free (p->x_const_rtx_sym_hash_table);
3532   free (p);
3533
3534   f->varasm = NULL;
3535 }
3536 \f
3537
3538 /* Express an rtx for a constant integer (perhaps symbolic)
3539    as the sum of a symbol or label plus an explicit integer.
3540    They are stored into VALUE.  */
3541
3542 static void
3543 decode_rtx_const (mode, x, value)
3544      enum machine_mode mode;
3545      rtx x;
3546      struct rtx_const *value;
3547 {
3548   /* Clear the whole structure, including any gaps.  */
3549   memset (value, 0, sizeof (struct rtx_const));
3550
3551   value->kind = RTX_INT;        /* Most usual kind.  */
3552   value->mode = mode;
3553
3554   switch (GET_CODE (x))
3555     {
3556     case CONST_DOUBLE:
3557       value->kind = RTX_DOUBLE;
3558       if (GET_MODE (x) != VOIDmode)
3559         {
3560           value->mode = GET_MODE (x);
3561           REAL_VALUE_FROM_CONST_DOUBLE (value->un.du, x);
3562         }
3563       else
3564         {
3565           value->un.di.low = CONST_DOUBLE_LOW (x);
3566           value->un.di.high = CONST_DOUBLE_HIGH (x);
3567         }
3568       break;
3569
3570     case CONST_VECTOR:
3571       {
3572         int units, i;
3573         rtx elt;
3574
3575         units = CONST_VECTOR_NUNITS (x);
3576         value->kind = RTX_VECTOR;
3577         value->mode = mode;
3578
3579         for (i = 0; i < units; ++i)
3580           {
3581             elt = CONST_VECTOR_ELT (x, i);
3582             if (GET_MODE_CLASS (mode) == MODE_VECTOR_INT)
3583               {
3584                 value->un.veclo[i] = (HOST_WIDE_INT) INTVAL (elt);
3585                 value->un.vechi[i] = 0;
3586               }
3587             else if (GET_MODE_CLASS (mode) == MODE_VECTOR_FLOAT)
3588               {
3589                 value->un.veclo[i] = (HOST_WIDE_INT) CONST_DOUBLE_LOW (elt);
3590                 value->un.vechi[i] = (HOST_WIDE_INT) CONST_DOUBLE_HIGH (elt);
3591               }
3592             else
3593               abort ();
3594           }
3595       }
3596       break;
3597
3598     case CONST_INT:
3599       value->un.addr.offset = INTVAL (x);
3600       break;
3601
3602     case SYMBOL_REF:
3603     case LABEL_REF:
3604     case PC:
3605       value->un.addr.base = x;
3606       break;
3607
3608     case CONST:
3609       x = XEXP (x, 0);
3610       if (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 1)) == CONST_INT)
3611         {
3612           value->un.addr.base = XEXP (x, 0);
3613           value->un.addr.offset = INTVAL (XEXP (x, 1));
3614         }
3615       else if (GET_CODE (x) == MINUS && GET_CODE (XEXP (x, 1)) == CONST_INT)
3616         {
3617           value->un.addr.base = XEXP (x, 0);
3618           value->un.addr.offset = - INTVAL (XEXP (x, 1));
3619         }
3620       else
3621         {
3622           value->un.addr.base = x;
3623           value->un.addr.offset = 0;
3624         }
3625       break;
3626
3627     default:
3628       value->kind = RTX_UNKNOWN;
3629       break;
3630     }
3631
3632   if (value->kind == RTX_INT && value->un.addr.base != 0
3633       && GET_CODE (value->un.addr.base) == UNSPEC)
3634     {
3635       /* For a simple UNSPEC, the base is set to the
3636          operand, the kind field is set to the index of
3637          the unspec expression.
3638          Together with the code below, in case that
3639          the operand is a SYMBOL_REF or LABEL_REF,
3640          the address of the string or the code_label
3641          is taken as base.  */
3642       if (XVECLEN (value->un.addr.base, 0) == 1)
3643         {
3644           value->kind = RTX_UNSPEC + XINT (value->un.addr.base, 1);
3645           value->un.addr.base = XVECEXP (value->un.addr.base, 0, 0);
3646         }
3647     }
3648
3649   if (value->kind > RTX_DOUBLE && value->un.addr.base != 0)
3650     switch (GET_CODE (value->un.addr.base))
3651       {
3652       case SYMBOL_REF:
3653         /* Use the string's address, not the SYMBOL_REF's address,
3654            for the sake of addresses of library routines.  */
3655         value->un.addr.base = (rtx) XSTR (value->un.addr.base, 0);
3656         break;
3657
3658       case LABEL_REF:
3659         /* For a LABEL_REF, compare labels.  */
3660         value->un.addr.base = XEXP (value->un.addr.base, 0);
3661
3662       default:
3663         break;
3664       }
3665 }
3666
3667 /* Given a MINUS expression, simplify it if both sides
3668    include the same symbol.  */
3669
3670 rtx
3671 simplify_subtraction (x)
3672      rtx x;
3673 {
3674   struct rtx_const val0, val1;
3675
3676   decode_rtx_const (GET_MODE (x), XEXP (x, 0), &val0);
3677   decode_rtx_const (GET_MODE (x), XEXP (x, 1), &val1);
3678
3679   if (val0.kind > RTX_DOUBLE
3680       && val0.kind == val1.kind
3681       && val0.un.addr.base == val1.un.addr.base)
3682     return GEN_INT (val0.un.addr.offset - val1.un.addr.offset);
3683
3684   return x;
3685 }
3686
3687 /* Compute a hash code for a constant RTL expression.  */
3688
3689 static int
3690 const_hash_rtx (mode, x)
3691      enum machine_mode mode;
3692      rtx x;
3693 {
3694   int hi;
3695   size_t i;
3696
3697   struct rtx_const value;
3698   decode_rtx_const (mode, x, &value);
3699
3700   /* Compute hashing function */
3701   hi = 0;
3702   for (i = 0; i < sizeof value / sizeof (int); i++)
3703     hi += ((int *) &value)[i];
3704
3705   hi &= (1 << HASHBITS) - 1;
3706   hi %= MAX_RTX_HASH_TABLE;
3707   return hi;
3708 }
3709
3710 /* Compare a constant rtl object X with a constant-descriptor DESC.
3711    Return 1 if DESC describes a constant with the same value as X.  */
3712
3713 static int
3714 compare_constant_rtx (mode, x, desc)
3715      enum machine_mode mode;
3716      rtx x;
3717      struct constant_descriptor *desc;
3718 {
3719   int *p = (int *) desc->u.contents;
3720   int *strp;
3721   int len;
3722   struct rtx_const value;
3723
3724   decode_rtx_const (mode, x, &value);
3725   strp = (int *) &value;
3726   len = sizeof value / sizeof (int);
3727
3728   /* Compare constant contents.  */
3729   while (--len >= 0)
3730     if (*p++ != *strp++)
3731       return 0;
3732
3733   return 1;
3734 }
3735
3736 /* Construct a constant descriptor for the rtl-expression X.
3737    It is up to the caller to enter the descriptor in the hash table.  */
3738
3739 static struct constant_descriptor *
3740 record_constant_rtx (mode, x)
3741      enum machine_mode mode;
3742      rtx x;
3743 {
3744   struct constant_descriptor *ptr;
3745
3746   ptr = ((struct constant_descriptor *)
3747          xcalloc (1, (offsetof (struct constant_descriptor, u)
3748                       + sizeof (struct rtx_const))));
3749   decode_rtx_const (mode, x, (struct rtx_const *) ptr->u.contents);
3750
3751   return ptr;
3752 }
3753 \f
3754 /* Given a constant rtx X, return a MEM for the location in memory at which
3755    this constant has been placed.  Return 0 if it not has been placed yet.  */
3756
3757 rtx
3758 mem_for_const_double (x)
3759      rtx x;
3760 {
3761   enum machine_mode mode = GET_MODE (x);
3762   struct constant_descriptor *desc;
3763
3764   for (desc = const_rtx_hash_table[const_hash_rtx (mode, x)]; desc;
3765        desc = desc->next)
3766     if (compare_constant_rtx (mode, x, desc))
3767       return desc->rtl;
3768
3769   return 0;
3770 }
3771
3772 /* Given a constant rtx X, make (or find) a memory constant for its value
3773    and return a MEM rtx to refer to it in memory.  */
3774
3775 rtx
3776 force_const_mem (mode, x)
3777      enum machine_mode mode;
3778      rtx x;
3779 {
3780   int hash;
3781   struct constant_descriptor *desc;
3782   char label[256];
3783   rtx def;
3784   struct pool_constant *pool;
3785   unsigned int align;
3786
3787   /* Compute hash code of X.  Search the descriptors for that hash code
3788      to see if any of them describes X.  If yes, we have an rtx to use.  */
3789   hash = const_hash_rtx (mode, x);
3790   for (desc = const_rtx_hash_table[hash]; desc; desc = desc->next)
3791     if (compare_constant_rtx (mode, x, desc))
3792       return desc->rtl;
3793
3794   /* No constant equal to X is known to have been output.
3795      Make a constant descriptor to enter X in the hash table
3796      and make a MEM for it.  */
3797   desc = record_constant_rtx (mode, x);
3798   desc->next = const_rtx_hash_table[hash];
3799   const_rtx_hash_table[hash] = desc;
3800
3801   /* Align the location counter as required by EXP's data type.  */
3802   align = GET_MODE_ALIGNMENT (mode == VOIDmode ? word_mode : mode);
3803 #ifdef CONSTANT_ALIGNMENT
3804   align = CONSTANT_ALIGNMENT (make_tree ((*lang_hooks.types.type_for_mode)
3805                                          (mode, 0), x), align);
3806 #endif
3807
3808   pool_offset += (align / BITS_PER_UNIT) - 1;
3809   pool_offset &= ~ ((align / BITS_PER_UNIT) - 1);
3810
3811   if (GET_CODE (x) == LABEL_REF)
3812     LABEL_PRESERVE_P (XEXP (x, 0)) = 1;
3813
3814   /* Allocate a pool constant descriptor, fill it in, and chain it in.  */
3815   pool = (struct pool_constant *) ggc_alloc (sizeof (struct pool_constant));
3816   pool->desc = desc;
3817   pool->constant = x;
3818   pool->mode = mode;
3819   pool->labelno = const_labelno;
3820   pool->align = align;
3821   pool->offset = pool_offset;
3822   pool->mark = 1;
3823   pool->next = 0;
3824
3825   if (last_pool == 0)
3826     first_pool = pool;
3827   else
3828     last_pool->next = pool;
3829
3830   last_pool = pool;
3831   pool_offset += GET_MODE_SIZE (mode);
3832
3833   /* Create a string containing the label name, in LABEL.  */
3834   ASM_GENERATE_INTERNAL_LABEL (label, "LC", const_labelno);
3835
3836   ++const_labelno;
3837
3838   /* Construct the SYMBOL_REF and the MEM.  */
3839
3840   pool->desc->rtl = def
3841     = gen_rtx_MEM (mode, gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (label)));
3842   set_mem_alias_set (def, const_alias_set);
3843   set_mem_attributes (def, (*lang_hooks.types.type_for_mode) (mode, 0), 1);
3844   RTX_UNCHANGING_P (def) = 1;
3845
3846   /* Add label to symbol hash table.  */
3847   hash = SYMHASH (XSTR (XEXP (def, 0), 0));
3848   pool->next_sym = const_rtx_sym_hash_table[hash];
3849   const_rtx_sym_hash_table[hash] = pool;
3850
3851   /* Mark the symbol_ref as belonging to this constants pool.  */
3852   CONSTANT_POOL_ADDRESS_P (XEXP (def, 0)) = 1;
3853   current_function_uses_const_pool = 1;
3854
3855   return def;
3856 }
3857 \f
3858 /* Given a SYMBOL_REF with CONSTANT_POOL_ADDRESS_P true, return a pointer to
3859    the corresponding pool_constant structure.  */
3860
3861 static struct pool_constant *
3862 find_pool_constant (f, addr)
3863      struct function *f;
3864      rtx addr;
3865 {
3866   struct pool_constant *pool;
3867   const char *label = XSTR (addr, 0);
3868
3869   for (pool = f->varasm->x_const_rtx_sym_hash_table[SYMHASH (label)]; pool;
3870        pool = pool->next_sym)
3871     if (XSTR (XEXP (pool->desc->rtl, 0), 0) == label)
3872       return pool;
3873
3874   abort ();
3875 }
3876
3877 /* Given a constant pool SYMBOL_REF, return the corresponding constant.  */
3878
3879 rtx
3880 get_pool_constant (addr)
3881      rtx addr;
3882 {
3883   return (find_pool_constant (cfun, addr))->constant;
3884 }
3885
3886 /* Given a constant pool SYMBOL_REF, return the corresponding constant
3887    and whether it has been output or not.  */
3888
3889 rtx
3890 get_pool_constant_mark (addr, pmarked)
3891      rtx addr;
3892      bool *pmarked;
3893 {
3894   struct pool_constant *pool = find_pool_constant (cfun, addr);
3895   *pmarked = (pool->mark != 0);
3896   return pool->constant;
3897 }
3898
3899 /* Likewise, but for the constant pool of a specific function.  */
3900
3901 rtx
3902 get_pool_constant_for_function (f, addr)
3903      struct function *f;
3904      rtx addr;
3905 {
3906   return (find_pool_constant (f, addr))->constant;
3907 }
3908
3909 /* Similar, return the mode.  */
3910
3911 enum machine_mode
3912 get_pool_mode (addr)
3913      rtx addr;
3914 {
3915   return (find_pool_constant (cfun, addr))->mode;
3916 }
3917
3918 enum machine_mode
3919 get_pool_mode_for_function (f, addr)
3920      struct function *f;
3921      rtx addr;
3922 {
3923   return (find_pool_constant (f, addr))->mode;
3924 }
3925
3926 /* Similar, return the offset in the constant pool.  */
3927
3928 int
3929 get_pool_offset (addr)
3930      rtx addr;
3931 {
3932   return (find_pool_constant (cfun, addr))->offset;
3933 }
3934
3935 /* Return the size of the constant pool.  */
3936
3937 int
3938 get_pool_size ()
3939 {
3940   return pool_offset;
3941 }
3942 \f
3943 /* Write all the constants in the constant pool.  */
3944
3945 void
3946 output_constant_pool (fnname, fndecl)
3947   const char *fnname ATTRIBUTE_UNUSED;
3948   tree fndecl ATTRIBUTE_UNUSED;
3949 {
3950   struct pool_constant *pool;
3951   rtx x;
3952   REAL_VALUE_TYPE r;
3953
3954   /* It is possible for gcc to call force_const_mem and then to later
3955      discard the instructions which refer to the constant.  In such a
3956      case we do not need to output the constant.  */
3957   mark_constant_pool ();
3958
3959 #ifdef ASM_OUTPUT_POOL_PROLOGUE
3960   ASM_OUTPUT_POOL_PROLOGUE (asm_out_file, fnname, fndecl, pool_offset);
3961 #endif
3962
3963   for (pool = first_pool; pool; pool = pool->next)
3964     {
3965       rtx tmp;
3966
3967       x = pool->constant;
3968
3969       if (! pool->mark)
3970         continue;
3971
3972       /* See if X is a LABEL_REF (or a CONST referring to a LABEL_REF)
3973          whose CODE_LABEL has been deleted.  This can occur if a jump table
3974          is eliminated by optimization.  If so, write a constant of zero
3975          instead.  Note that this can also happen by turning the
3976          CODE_LABEL into a NOTE.  */
3977       /* ??? This seems completely and utterly wrong.  Certainly it's
3978          not true for NOTE_INSN_DELETED_LABEL, but I disbelieve proper
3979          functioning even with INSN_DELETED_P and friends.  */
3980
3981       tmp = x;
3982       switch (GET_CODE (x))
3983         {
3984         case CONST:
3985           if (GET_CODE (XEXP (x, 0)) != PLUS
3986               || GET_CODE (XEXP (XEXP (x, 0), 0)) != LABEL_REF)
3987             break;
3988           tmp = XEXP (XEXP (x, 0), 0);
3989           /* FALLTHRU */
3990
3991         case LABEL_REF:
3992           tmp = XEXP (x, 0);
3993           if (INSN_DELETED_P (tmp)
3994               || (GET_CODE (tmp) == NOTE
3995                   && NOTE_LINE_NUMBER (tmp) == NOTE_INSN_DELETED))
3996             {
3997               abort ();
3998               x = const0_rtx;
3999             }
4000           break;
4001
4002         default:
4003           break;
4004         }
4005
4006       /* First switch to correct section.  */
4007 #ifdef SELECT_RTX_SECTION
4008       SELECT_RTX_SECTION (pool->mode, x, pool->align);
4009 #else
4010       readonly_data_section ();
4011 #endif
4012
4013 #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
4014       ASM_OUTPUT_SPECIAL_POOL_ENTRY (asm_out_file, x, pool->mode,
4015                                      pool->align, pool->labelno, done);
4016 #endif
4017
4018       assemble_align (pool->align);
4019
4020       /* Output the label.  */
4021       ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LC", pool->labelno);
4022
4023       /* Output the value of the constant itself.  */
4024       switch (GET_MODE_CLASS (pool->mode))
4025         {
4026         case MODE_FLOAT:
4027           if (GET_CODE (x) != CONST_DOUBLE)
4028             abort ();
4029
4030           REAL_VALUE_FROM_CONST_DOUBLE (r, x);
4031           assemble_real (r, pool->mode, pool->align);
4032           break;
4033
4034         case MODE_INT:
4035         case MODE_PARTIAL_INT:
4036           assemble_integer (x, GET_MODE_SIZE (pool->mode), pool->align, 1);
4037           break;
4038
4039         case MODE_VECTOR_FLOAT:
4040           {
4041             int i, units;
4042             rtx elt;
4043
4044             if (GET_CODE (x) != CONST_VECTOR)
4045               abort ();
4046
4047             units = CONST_VECTOR_NUNITS (x);
4048
4049             for (i = 0; i < units; i++)
4050               {
4051                 elt = CONST_VECTOR_ELT (x, i);
4052                 REAL_VALUE_FROM_CONST_DOUBLE (r, elt);
4053                 assemble_real (r, 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 /* Merge weak status between NEWDECL and OLDDECL.  */
4995
4996 void
4997 merge_weak (newdecl, olddecl)
4998      tree newdecl;
4999      tree olddecl;
5000 {
5001   tree decl;
5002
5003   if (DECL_WEAK (newdecl) == DECL_WEAK (olddecl))
5004     return;
5005
5006   decl = DECL_WEAK (olddecl) ? newdecl : olddecl;
5007
5008   if (SUPPORTS_WEAK
5009       && DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)
5010       && (TREE_CODE (decl) != VAR_DECL
5011           || ! TREE_STATIC (decl))
5012       && TREE_USED (decl)
5013       && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))
5014     warning_with_decl (decl, "weak declaration of `%s' after first use results in unspecified behavior");
5015
5016   declare_weak (decl);
5017 }
5018
5019 /* Declare DECL to be a weak symbol.  */
5020
5021 void
5022 declare_weak (decl)
5023      tree decl;
5024 {
5025   if (! TREE_PUBLIC (decl))
5026     error_with_decl (decl, "weak declaration of `%s' must be public");
5027   else if (TREE_CODE (decl) == FUNCTION_DECL && TREE_ASM_WRITTEN (decl))
5028     error_with_decl (decl, "weak declaration of `%s' must precede definition");
5029   else if (SUPPORTS_WEAK)
5030     {
5031       if (! DECL_WEAK (decl))
5032         weak_decls = tree_cons (NULL, decl, weak_decls);
5033     }
5034   else
5035     warning_with_decl (decl, "weak declaration of `%s' not supported");
5036
5037   DECL_WEAK (decl) = 1;
5038
5039   if (DECL_RTL_SET_P (decl)
5040       && GET_CODE (DECL_RTL (decl)) == MEM
5041       && XEXP (DECL_RTL (decl), 0)
5042       && GET_CODE (XEXP (DECL_RTL (decl), 0)) == SYMBOL_REF)
5043     SYMBOL_REF_WEAK (XEXP (DECL_RTL (decl), 0)) = 1;
5044 }
5045
5046 /* Emit any pending weak declarations.  */
5047
5048 void
5049 weak_finish ()
5050 {
5051   tree t;
5052
5053   for (t = weak_decls; t ; t = TREE_CHAIN (t))
5054     {
5055       tree decl = TREE_VALUE (t);
5056       const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
5057
5058       if (! TREE_USED (decl))
5059         continue;
5060
5061 #ifdef ASM_WEAKEN_DECL
5062       ASM_WEAKEN_DECL (asm_out_file, decl, name, NULL);
5063 #else
5064 #ifdef ASM_WEAKEN_LABEL
5065       ASM_WEAKEN_LABEL (asm_out_file, name);
5066 #else
5067 #ifdef ASM_OUTPUT_WEAK_ALIAS
5068       warning ("only weak aliases are supported in this configuration");
5069       return;
5070 #endif
5071 #endif
5072 #endif
5073     }
5074 }
5075
5076 /* Emit the assembly bits to indicate that DECL is globally visible.  */
5077
5078 static void
5079 globalize_decl (decl)
5080      tree decl;
5081 {
5082   const char *name = XSTR (XEXP (DECL_RTL (decl), 0), 0);
5083
5084 #if defined (ASM_WEAKEN_LABEL) || defined (ASM_WEAKEN_DECL)
5085   if (DECL_WEAK (decl))
5086     {
5087       tree *p, t;
5088
5089 #ifdef ASM_WEAKEN_DECL
5090       ASM_WEAKEN_DECL (asm_out_file, decl, name, 0);
5091 #else
5092       ASM_WEAKEN_LABEL (asm_out_file, name);
5093 #endif
5094
5095       /* Remove this function from the pending weak list so that
5096          we do not emit multiple .weak directives for it.  */
5097       for (p = &weak_decls; (t = *p) ; p = &TREE_CHAIN (t))
5098         if (TREE_VALUE (t) == decl)
5099           {
5100             *p = TREE_CHAIN (t);
5101             break;
5102           }
5103       return;
5104     }
5105 #endif
5106
5107   ASM_GLOBALIZE_LABEL (asm_out_file, name);
5108 }
5109
5110 /* Emit an assembler directive to make the symbol for DECL an alias to
5111    the symbol for TARGET.  */
5112
5113 void
5114 assemble_alias (decl, target)
5115      tree decl, target ATTRIBUTE_UNUSED;
5116 {
5117   const char *name;
5118
5119   /* We must force creation of DECL_RTL for debug info generation, even though
5120      we don't use it here.  */
5121   make_decl_rtl (decl, NULL);
5122
5123   name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
5124
5125 #ifdef ASM_OUTPUT_DEF
5126   /* Make name accessible from other files, if appropriate.  */
5127
5128   if (TREE_PUBLIC (decl))
5129     {
5130       globalize_decl (decl);
5131       maybe_assemble_visibility (decl);
5132     }
5133
5134 #ifdef ASM_OUTPUT_DEF_FROM_DECLS
5135   ASM_OUTPUT_DEF_FROM_DECLS (asm_out_file, decl, target);
5136 #else
5137   ASM_OUTPUT_DEF (asm_out_file, name, IDENTIFIER_POINTER (target));
5138 #endif
5139   TREE_ASM_WRITTEN (decl) = 1;
5140 #else /* !ASM_OUTPUT_DEF */
5141 #if defined (ASM_OUTPUT_WEAK_ALIAS) || defined (ASM_WEAKEN_DECL)
5142   if (! DECL_WEAK (decl))
5143     warning ("only weak aliases are supported in this configuration");
5144
5145 #ifdef ASM_WEAKEN_DECL
5146   ASM_WEAKEN_DECL (asm_out_file, decl, name, IDENTIFIER_POINTER (target));
5147 #else
5148   ASM_OUTPUT_WEAK_ALIAS (asm_out_file, name, IDENTIFIER_POINTER (target));
5149 #endif
5150   TREE_ASM_WRITTEN (decl) = 1;
5151 #else
5152   warning ("alias definitions not supported in this configuration; ignored");
5153 #endif
5154 #endif
5155 }
5156
5157 /* Emit an assembler directive to set symbol for DECL visibility to
5158    VISIBILITY_TYPE.  */
5159
5160 void
5161 assemble_visibility (decl, visibility_type)
5162      tree decl;
5163      const char *visibility_type ATTRIBUTE_UNUSED;
5164 {
5165   const char *name;
5166
5167   name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
5168
5169 #ifdef HAVE_GAS_HIDDEN
5170   fprintf (asm_out_file, "\t.%s\t%s\n", visibility_type, name);
5171 #else
5172   warning ("visibility attribute not supported in this configuration; ignored");
5173 #endif
5174 }
5175
5176 /* A helper function to call assemble_visibility when needed for a decl.  */
5177
5178 static void
5179 maybe_assemble_visibility (decl)
5180      tree decl;
5181 {
5182   tree visibility = lookup_attribute ("visibility", DECL_ATTRIBUTES (decl));
5183   if (visibility)
5184     {
5185       const char *type
5186         = TREE_STRING_POINTER (TREE_VALUE (TREE_VALUE (visibility)));
5187       assemble_visibility (decl, type);
5188     }
5189 }
5190
5191 /* Returns 1 if the target configuration supports defining public symbols
5192    so that one of them will be chosen at link time instead of generating a
5193    multiply-defined symbol error, whether through the use of weak symbols or
5194    a target-specific mechanism for having duplicates discarded.  */
5195
5196 int
5197 supports_one_only ()
5198 {
5199   if (SUPPORTS_ONE_ONLY)
5200     return 1;
5201   return SUPPORTS_WEAK;
5202 }
5203
5204 /* Set up DECL as a public symbol that can be defined in multiple
5205    translation units without generating a linker error.  */
5206
5207 void
5208 make_decl_one_only (decl)
5209      tree decl;
5210 {
5211   if (TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != FUNCTION_DECL)
5212     abort ();
5213
5214   TREE_PUBLIC (decl) = 1;
5215
5216   if (TREE_CODE (decl) == VAR_DECL
5217       && (DECL_INITIAL (decl) == 0 || DECL_INITIAL (decl) == error_mark_node))
5218     DECL_COMMON (decl) = 1;
5219   else if (SUPPORTS_ONE_ONLY)
5220     {
5221 #ifdef MAKE_DECL_ONE_ONLY
5222       MAKE_DECL_ONE_ONLY (decl);
5223 #endif
5224       DECL_ONE_ONLY (decl) = 1;
5225     }
5226   else if (SUPPORTS_WEAK)
5227     DECL_WEAK (decl) = 1;
5228   else
5229     abort ();
5230 }
5231
5232 void
5233 init_varasm_once ()
5234 {
5235   const_str_htab = htab_create (128, const_str_htab_hash, const_str_htab_eq,
5236                                 const_str_htab_del);
5237   in_named_htab = htab_create (31, in_named_entry_hash,
5238                                in_named_entry_eq, NULL);
5239
5240   ggc_add_root (const_hash_table, MAX_HASH_TABLE, sizeof const_hash_table[0],
5241                 mark_const_hash_entry);
5242   ggc_add_root (&const_str_htab, 1, sizeof const_str_htab,
5243                 mark_const_str_htab);
5244   ggc_add_tree_root (&weak_decls, 1);
5245
5246   const_alias_set = new_alias_set ();
5247 }
5248
5249 /* Select a set of attributes for section NAME based on the properties
5250    of DECL and whether or not RELOC indicates that DECL's initializer
5251    might contain runtime relocations.
5252
5253    We make the section read-only and executable for a function decl,
5254    read-only for a const data decl, and writable for a non-const data decl.  */
5255
5256 unsigned int
5257 default_section_type_flags (decl, name, reloc)
5258      tree decl;
5259      const char *name;
5260      int reloc;
5261 {
5262   unsigned int flags;
5263
5264   if (decl && TREE_CODE (decl) == FUNCTION_DECL)
5265     flags = SECTION_CODE;
5266   else if (decl && DECL_READONLY_SECTION (decl, reloc))
5267     flags = 0;
5268   else
5269     flags = SECTION_WRITE;
5270
5271   if (decl && DECL_ONE_ONLY (decl))
5272     flags |= SECTION_LINKONCE;
5273
5274   if (strcmp (name, ".bss") == 0
5275       || strncmp (name, ".bss.", 5) == 0
5276       || strncmp (name, ".gnu.linkonce.b.", 16) == 0
5277       || strcmp (name, ".sbss") == 0
5278       || strncmp (name, ".sbss.", 6) == 0
5279       || strncmp (name, ".gnu.linkonce.sb.", 17) == 0)
5280     flags |= SECTION_BSS;
5281
5282   return flags;
5283 }
5284
5285 /* Output assembly to switch to section NAME with attribute FLAGS.
5286    Four variants for common object file formats.  */
5287
5288 void
5289 default_no_named_section (name, flags)
5290      const char *name ATTRIBUTE_UNUSED;
5291      unsigned int flags ATTRIBUTE_UNUSED;
5292 {
5293   /* Some object formats don't support named sections at all.  The
5294      front-end should already have flagged this as an error.  */
5295   abort ();
5296 }
5297
5298 void
5299 default_elf_asm_named_section (name, flags)
5300      const char *name;
5301      unsigned int flags;
5302 {
5303   char flagchars[10], *f = flagchars;
5304   const char *type;
5305
5306   if (! named_section_first_declaration (name))
5307     {
5308       fprintf (asm_out_file, "\t.section\t%s\n", name);
5309       return;
5310     }
5311
5312   if (!(flags & SECTION_DEBUG))
5313     *f++ = 'a';
5314   if (flags & SECTION_WRITE)
5315     *f++ = 'w';
5316   if (flags & SECTION_CODE)
5317     *f++ = 'x';
5318   if (flags & SECTION_SMALL)
5319     *f++ = 's';
5320   if (flags & SECTION_MERGE)
5321     *f++ = 'M';
5322   if (flags & SECTION_STRINGS)
5323     *f++ = 'S';
5324   *f = '\0';
5325
5326   if (flags & SECTION_BSS)
5327     type = "nobits";
5328   else
5329     type = "progbits";
5330
5331   if (flags & SECTION_ENTSIZE)
5332     fprintf (asm_out_file, "\t.section\t%s,\"%s\",@%s,%d\n",
5333              name, flagchars, type, flags & SECTION_ENTSIZE);
5334   else
5335     fprintf (asm_out_file, "\t.section\t%s,\"%s\",@%s\n",
5336              name, flagchars, type);
5337 }
5338
5339 void
5340 default_coff_asm_named_section (name, flags)
5341      const char *name;
5342      unsigned int flags;
5343 {
5344   char flagchars[8], *f = flagchars;
5345
5346   if (flags & SECTION_WRITE)
5347     *f++ = 'w';
5348   if (flags & SECTION_CODE)
5349     *f++ = 'x';
5350   *f = '\0';
5351
5352   fprintf (asm_out_file, "\t.section\t%s,\"%s\"\n", name, flagchars);
5353 }
5354
5355 void
5356 default_pe_asm_named_section (name, flags)
5357      const char *name;
5358      unsigned int flags;
5359 {
5360   default_coff_asm_named_section (name, flags);
5361
5362   if (flags & SECTION_LINKONCE)
5363     {
5364       /* Functions may have been compiled at various levels of
5365          optimization so we can't use `same_size' here.
5366          Instead, have the linker pick one.  */
5367       fprintf (asm_out_file, "\t.linkonce %s\n",
5368                (flags & SECTION_CODE ? "discard" : "same_size"));
5369     }
5370 }
5371 \f
5372 /* Used for vtable gc in GNU binutils.  Record that the pointer at OFFSET
5373    from SYMBOL is used in all classes derived from SYMBOL.  */
5374
5375 void
5376 assemble_vtable_entry (symbol, offset)
5377      rtx symbol;
5378      HOST_WIDE_INT offset;
5379 {
5380   fputs ("\t.vtable_entry ", asm_out_file);
5381   output_addr_const (asm_out_file, symbol);
5382   fputs (", ", asm_out_file);
5383   fprintf (asm_out_file, HOST_WIDE_INT_PRINT_DEC, offset);
5384   fputc ('\n', asm_out_file);
5385 }
5386
5387 /* Used for vtable gc in GNU binutils.  Record the class hierarchy by noting
5388    that the vtable symbol CHILD is derived from the vtable symbol PARENT.  */
5389
5390 void
5391 assemble_vtable_inherit (child, parent)
5392      rtx child, parent;
5393 {
5394   fputs ("\t.vtable_inherit ", asm_out_file);
5395   output_addr_const (asm_out_file, child);
5396   fputs (", ", asm_out_file);
5397   output_addr_const (asm_out_file, parent);
5398   fputc ('\n', asm_out_file);
5399 }