gcc/varasm.c

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