gcc/varasm.c

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