gcc/varasm.c

   1 /* Output variables, constants and external declarations, for GNU compiler.
   2    Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997,
   3    1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING.  If not, write to the Free
  19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA.  */
  21
  22
  23 /* This file handles generation of all the assembler code
  24    *except* the instructions of a function.
  25    This includes declarations of variables and their initial values.
  26
  27    We also output the assembler code for constants stored in memory
  28    and are responsible for combining constants with the same value.  */
  29
  30 #include "config.h"
  31 #include "system.h"
  32 #include "rtl.h"
  33 #include "tree.h"
  34 #include "flags.h"
  35 #include "function.h"
  36 #include "expr.h"
  37 #include "hard-reg-set.h"
  38 #include "regs.h"
  39 #include "output.h"
  40 #include "real.h"
  41 #include "toplev.h"
  42 #include "obstack.h"
  43 #include "hashtab.h"
  44 #include "c-pragma.h"
  45 #include "c-tree.h"
  46 #include "ggc.h"
  47 #include "langhooks.h"
  48 #include "tm_p.h"
  49 #include "debug.h"
  50 #include "target.h"
  51
  52 #ifdef XCOFF_DEBUGGING_INFO
  53 #include "xcoffout.h"           /* Needed for external data
  54                                    declarations for e.g. AIX 4.x.  */
  55 #endif
  56
  57 #ifndef TRAMPOLINE_ALIGNMENT
  58 #define TRAMPOLINE_ALIGNMENT FUNCTION_BOUNDARY
  59 #endif
  60
  61 #ifndef ASM_STABS_OP
  62 #define ASM_STABS_OP "\t.stabs\t"
  63 #endif
  64
  65 /* The (assembler) name of the first globally-visible object output.  */
  66 const char *first_global_object_name;
  67 const char *weak_global_object_name;
  68
  69 extern struct obstack permanent_obstack;
  70 #define obstack_chunk_alloc xmalloc
  71
  72 struct addr_const;
  73 struct constant_descriptor;
  74 struct rtx_const;
  75 struct pool_constant;
  76
  77 #define MAX_RTX_HASH_TABLE 61
  78
  79 struct varasm_status
  80 {
  81   /* Hash facility for making memory-constants
  82      from constant rtl-expressions.  It is used on RISC machines
  83      where immediate integer arguments and constant addresses are restricted
  84      so that such constants must be stored in memory.
  85
  86      This pool of constants is reinitialized for each function
  87      so each function gets its own constants-pool that comes right before
  88      it.  */
  89   struct constant_descriptor **x_const_rtx_hash_table;
  90   struct pool_constant **x_const_rtx_sym_hash_table;
  91
  92   /* Pointers to first and last constant in pool.  */
  93   struct pool_constant *x_first_pool, *x_last_pool;
  94
  95   /* Current offset in constant pool (does not include any machine-specific
  96      header).  */
  97   HOST_WIDE_INT x_pool_offset;
  98
  99   /* Chain of all CONST_DOUBLE rtx's constructed for the current function.
 100      They are chained through the CONST_DOUBLE_CHAIN.  */
 101   rtx x_const_double_chain;
 102 };
 103
 104 #define const_rtx_hash_table (cfun->varasm->x_const_rtx_hash_table)
 105 #define const_rtx_sym_hash_table (cfun->varasm->x_const_rtx_sym_hash_table)
 106 #define first_pool (cfun->varasm->x_first_pool)
 107 #define last_pool (cfun->varasm->x_last_pool)
 108 #define pool_offset (cfun->varasm->x_pool_offset)
 109 #define const_double_chain (cfun->varasm->x_const_double_chain)
 110
 111 /* Number for making the label on the next
 112    constant that is stored in memory.  */
 113
 114 int const_labelno;
 115
 116 /* Number for making the label on the next
 117    static variable internal to a function.  */
 118
 119 int var_labelno;
 120
 121 /* Carry information from ASM_DECLARE_OBJECT_NAME
 122    to ASM_FINISH_DECLARE_OBJECT.  */
 123
 124 int size_directive_output;
 125
 126 /* The last decl for which assemble_variable was called,
 127    if it did ASM_DECLARE_OBJECT_NAME.
 128    If the last call to assemble_variable didn't do that,
 129    this holds 0.  */
 130
 131 tree last_assemble_variable_decl;
 132
 133 /* RTX_UNCHANGING_P in a MEM can mean it is stored into, for initialization.
 134    So giving constant the alias set for the type will allow such
 135    initializations to appear to conflict with the load of the constant.  We
 136    avoid this by giving all constants an alias set for just constants.
 137    Since there will be no stores to that alias set, nothing will ever
 138    conflict with them.  */
 139
 140 static HOST_WIDE_INT const_alias_set;
 141
 142 static const char *strip_reg_name       PARAMS ((const char *));
 143 static int contains_pointers_p          PARAMS ((tree));
 144 static void decode_addr_const           PARAMS ((tree, struct addr_const *));
 145 static int const_hash                   PARAMS ((tree));
 146 static int compare_constant             PARAMS ((tree,
 147                                                struct constant_descriptor *));
 148 static const unsigned char *compare_constant_1  PARAMS ((tree, const unsigned char *));
 149 static struct constant_descriptor *record_constant PARAMS ((tree));
 150 static void record_constant_1           PARAMS ((tree));
 151 static tree copy_constant               PARAMS ((tree));
 152 static void output_constant_def_contents  PARAMS ((tree, int, int));
 153 static void decode_rtx_const            PARAMS ((enum machine_mode, rtx,
 154                                                struct rtx_const *));
 155 static int const_hash_rtx               PARAMS ((enum machine_mode, rtx));
 156 static int compare_constant_rtx         PARAMS ((enum machine_mode, rtx,
 157                                                struct constant_descriptor *));
 158 static struct constant_descriptor *record_constant_rtx PARAMS ((enum machine_mode,
 159                                                               rtx));
 160 static struct pool_constant *find_pool_constant PARAMS ((struct function *, rtx));
 161 static void mark_constant_pool          PARAMS ((void));
 162 static void mark_constants              PARAMS ((rtx));
 163 static int mark_constant                PARAMS ((rtx *current_rtx, void *data));
 164 static int output_addressed_constants   PARAMS ((tree));
 165 static void output_after_function_constants PARAMS ((void));
 166 static unsigned HOST_WIDE_INT array_size_for_constructor PARAMS ((tree));
 167 static unsigned min_align               PARAMS ((unsigned, unsigned));
 168 static void output_constructor          PARAMS ((tree, HOST_WIDE_INT,
 169                                                  unsigned int));
 170 static void globalize_decl              PARAMS ((tree));
 171 static void maybe_assemble_visibility   PARAMS ((tree));
 172 static int in_named_entry_eq            PARAMS ((const PTR, const PTR));
 173 static hashval_t in_named_entry_hash    PARAMS ((const PTR));
 174 #ifdef ASM_OUTPUT_BSS
 175 static void asm_output_bss              PARAMS ((FILE *, tree, const char *, int, int));
 176 #endif
 177 #ifdef BSS_SECTION_ASM_OP
 178 #ifdef ASM_OUTPUT_ALIGNED_BSS
 179 static void asm_output_aligned_bss      PARAMS ((FILE *, tree, const char *,
 180                                                  int, int));
 181 #endif
 182 #endif /* BSS_SECTION_ASM_OP */
 183 static void mark_pool_constant          PARAMS ((struct pool_constant *));
 184 static void mark_const_hash_entry       PARAMS ((void *));
 185 static int mark_const_str_htab_1        PARAMS ((void **, void *));
 186 static void mark_const_str_htab         PARAMS ((void *));
 187 static hashval_t const_str_htab_hash    PARAMS ((const void *x));
 188 static int const_str_htab_eq            PARAMS ((const void *x, const void *y));
 189 static void const_str_htab_del          PARAMS ((void *));
 190 static void asm_emit_uninitialised      PARAMS ((tree, const char*, int, int));
 191 static void resolve_unique_section      PARAMS ((tree, int));
 192 \f
 193 static enum in_section { no_section, in_text, in_data, in_named
 194 #ifdef BSS_SECTION_ASM_OP
 195   , in_bss
 196 #endif
 197 #ifdef CTORS_SECTION_ASM_OP
 198   , in_ctors
 199 #endif
 200 #ifdef DTORS_SECTION_ASM_OP
 201   , in_dtors
 202 #endif
 203 #ifdef EXTRA_SECTIONS
 204   , EXTRA_SECTIONS
 205 #endif
 206 } in_section = no_section;
 207
 208 /* Return a non-zero value if DECL has a section attribute.  */
 209 #ifndef IN_NAMED_SECTION
 210 #define IN_NAMED_SECTION(DECL) \
 211   ((TREE_CODE (DECL) == FUNCTION_DECL || TREE_CODE (DECL) == VAR_DECL) \
 212    && DECL_SECTION_NAME (DECL) != NULL_TREE)
 213 #endif
 214
 215 /* Text of section name when in_section == in_named.  */
 216 static const char *in_named_name;
 217
 218 /* Hash table of flags that have been used for a particular named section.  */
 219
 220 struct in_named_entry
 221 {
 222   const char *name;
 223   unsigned int flags;
 224   bool declared;
 225 };
 226
 227 static htab_t in_named_htab;
 228
 229 /* Define functions like text_section for any extra sections.  */
 230 #ifdef EXTRA_SECTION_FUNCTIONS
 231 EXTRA_SECTION_FUNCTIONS
 232 #endif
 233
 234 /* Tell assembler to switch to text section.  */
 235
 236 void
 237 text_section ()
 238 {
 239   if (in_section != in_text)
 240     {
 241 #ifdef TEXT_SECTION
 242       TEXT_SECTION ();
 243 #else
 244       fprintf (asm_out_file, "%s\n", TEXT_SECTION_ASM_OP);
 245 #endif
 246       in_section = in_text;
 247     }
 248 }
 249
 250 /* Tell assembler to switch to data section.  */
 251
 252 void
 253 data_section ()
 254 {
 255   if (in_section != in_data)
 256     {
 257       if (flag_shared_data)
 258         {
 259 #ifdef SHARED_SECTION_ASM_OP
 260           fprintf (asm_out_file, "%s\n", SHARED_SECTION_ASM_OP);
 261 #else
 262           fprintf (asm_out_file, "%s\n", DATA_SECTION_ASM_OP);
 263 #endif
 264         }
 265       else
 266         fprintf (asm_out_file, "%s\n", DATA_SECTION_ASM_OP);
 267
 268       in_section = in_data;
 269     }
 270 }
 271 /* Tell assembler to ALWAYS switch to data section, in case
 272    it's not sure where it is.  */
 273
 274 void
 275 force_data_section ()
 276 {
 277   in_section = no_section;
 278   data_section ();
 279 }
 280
 281 /* Tell assembler to switch to read-only data section.  This is normally
 282    the text section.  */
 283
 284 void
 285 readonly_data_section ()
 286 {
 287 #ifdef READONLY_DATA_SECTION
 288   READONLY_DATA_SECTION ();  /* Note this can call data_section.  */
 289 #else
 290   text_section ();
 291 #endif
 292 }
 293
 294 /* Determine if we're in the text section.  */
 295
 296 int
 297 in_text_section ()
 298 {
 299   return in_section == in_text;
 300 }
 301
 302 /* Determine if we're in the data section.  */
 303
 304 int
 305 in_data_section ()
 306 {
 307   return in_section == in_data;
 308 }
 309
 310 /* Helper routines for maintaining in_named_htab.  */
 311
 312 static int
 313 in_named_entry_eq (p1, p2)
 314      const PTR p1;
 315      const PTR p2;
 316 {
 317   const struct in_named_entry *old = p1;
 318   const char *new = p2;
 319
 320   return strcmp (old->name, new) == 0;
 321 }
 322
 323 static hashval_t
 324 in_named_entry_hash (p)
 325      const PTR p;
 326 {
 327   const struct in_named_entry *old = p;
 328   return htab_hash_string (old->name);
 329 }
 330
 331 /* If SECTION has been seen before as a named section, return the flags
 332    that were used.  Otherwise, return 0.  Note, that 0 is a perfectly valid
 333    set of flags for a section to have, so 0 does not mean that the section
 334    has not been seen.  */
 335
 336 unsigned int
 337 get_named_section_flags (section)
 338      const char *section;
 339 {
 340   struct in_named_entry **slot;
 341
 342   slot = (struct in_named_entry**)
 343     htab_find_slot_with_hash (in_named_htab, section,
 344                               htab_hash_string (section), NO_INSERT);
 345
 346   return slot ? (*slot)->flags : 0;
 347 }
 348
 349 /* Returns true if the section has been declared before.   Sets internal
 350    flag on this section in in_named_hash so subsequent calls on this
 351    section will return false.  */
 352
 353 bool
 354 named_section_first_declaration (name)
 355      const char *name;
 356 {
 357   struct in_named_entry **slot;
 358
 359   slot = (struct in_named_entry**)
 360     htab_find_slot_with_hash (in_named_htab, name,
 361                               htab_hash_string (name), NO_INSERT);
 362   if (! (*slot)->declared)
 363     {
 364       (*slot)->declared = true;
 365       return true;
 366     }
 367   else
 368     {
 369       return false;
 370     }
 371 }
 372
 373
 374 /* Record FLAGS for SECTION.  If SECTION was previously recorded with a
 375    different set of flags, return false.  */
 376
 377 bool
 378 set_named_section_flags (section, flags)
 379      const char *section;
 380      unsigned int flags;
 381 {
 382   struct in_named_entry **slot, *entry;
 383
 384   slot = (struct in_named_entry**)
 385     htab_find_slot_with_hash (in_named_htab, section,
 386                               htab_hash_string (section), INSERT);
 387   entry = *slot;
 388
 389   if (!entry)
 390     {
 391       entry = (struct in_named_entry *) xmalloc (sizeof (*entry));
 392       *slot = entry;
 393       entry->name = ggc_strdup (section);
 394       entry->flags = flags;
 395       entry->declared = false;
 396     }
 397   else if (entry->flags != flags)
 398     return false;
 399
 400   return true;
 401 }
 402
 403 /* Tell assembler to change to section NAME with attributes FLAGS.  */
 404
 405 void
 406 named_section_flags (name, flags)
 407      const char *name;
 408      unsigned int flags;
 409 {
 410   if (in_section != in_named || strcmp (name, in_named_name) != 0)
 411     {
 412       if (! set_named_section_flags (name, flags))
 413         abort ();
 414
 415       (* targetm.asm_out.named_section) (name, flags);
 416
 417       if (flags & SECTION_FORGET)
 418         in_section = no_section;
 419       else
 420         {
 421           in_named_name = ggc_strdup (name);
 422           in_section = in_named;
 423         }
 424     }
 425 }
 426
 427 /* Tell assembler to change to section NAME for DECL.
 428    If DECL is NULL, just switch to section NAME.
 429    If NAME is NULL, get the name from DECL.
 430    If RELOC is 1, the initializer for DECL contains relocs.  */
 431
 432 void
 433 named_section (decl, name, reloc)
 434      tree decl;
 435      const char *name;
 436      int reloc;
 437 {
 438   unsigned int flags;
 439
 440   if (decl != NULL_TREE && !DECL_P (decl))
 441     abort ();
 442   if (name == NULL)
 443     name = TREE_STRING_POINTER (DECL_SECTION_NAME (decl));
 444
 445   flags = (* targetm.section_type_flags) (decl, name, reloc);
 446
 447   /* Sanity check user variables for flag changes.  Non-user
 448      section flag changes will abort in named_section_flags.
 449      However, don't complain if SECTION_OVERRIDE is set.
 450      We trust that the setter knows that it is safe to ignore
 451      the default flags for this decl.  */
 452   if (decl && ! set_named_section_flags (name, flags))
 453     {
 454       flags = get_named_section_flags (name);
 455       if ((flags & SECTION_OVERRIDE) == 0)
 456         error_with_decl (decl, "%s causes a section type conflict");
 457     }
 458
 459   named_section_flags (name, flags);
 460 }
 461
 462 /* If required, set DECL_SECTION_NAME to a unique name.  */
 463
 464 static void
 465 resolve_unique_section (decl, reloc)
 466      tree decl;
 467      int reloc ATTRIBUTE_UNUSED;
 468 {
 469   if (DECL_SECTION_NAME (decl) == NULL_TREE
 470       && (flag_function_sections
 471           || (targetm.have_named_sections
 472               && DECL_ONE_ONLY (decl))))
 473     UNIQUE_SECTION (decl, reloc);
 474 }
 475
 476 #ifdef BSS_SECTION_ASM_OP
 477
 478 /* Tell the assembler to switch to the bss section.  */
 479
 480 void
 481 bss_section ()
 482 {
 483   if (in_section != in_bss)
 484     {
 485 #ifdef SHARED_BSS_SECTION_ASM_OP
 486       if (flag_shared_data)
 487         fprintf (asm_out_file, "%s\n", SHARED_BSS_SECTION_ASM_OP);
 488       else
 489 #endif
 490         fprintf (asm_out_file, "%s\n", BSS_SECTION_ASM_OP);
 491
 492       in_section = in_bss;
 493     }
 494 }
 495
 496 #ifdef ASM_OUTPUT_BSS
 497
 498 /* Utility function for ASM_OUTPUT_BSS for targets to use if
 499    they don't support alignments in .bss.
 500    ??? It is believed that this function will work in most cases so such
 501    support is localized here.  */
 502
 503 static void
 504 asm_output_bss (file, decl, name, size, rounded)
 505      FILE *file;
 506      tree decl ATTRIBUTE_UNUSED;
 507      const char *name;
 508      int size ATTRIBUTE_UNUSED, rounded;
 509 {
 510   ASM_GLOBALIZE_LABEL (file, name);
 511   bss_section ();
 512 #ifdef ASM_DECLARE_OBJECT_NAME
 513   last_assemble_variable_decl = decl;
 514   ASM_DECLARE_OBJECT_NAME (file, name, decl);
 515 #else
 516   /* Standard thing is just output label for the object.  */
 517   ASM_OUTPUT_LABEL (file, name);
 518 #endif /* ASM_DECLARE_OBJECT_NAME */
 519   ASM_OUTPUT_SKIP (file, rounded);
 520 }
 521
 522 #endif
 523
 524 #ifdef ASM_OUTPUT_ALIGNED_BSS
 525
 526 /* Utility function for targets to use in implementing
 527    ASM_OUTPUT_ALIGNED_BSS.
 528    ??? It is believed that this function will work in most cases so such
 529    support is localized here.  */
 530
 531 static void
 532 asm_output_aligned_bss (file, decl, name, size, align)
 533      FILE *file;
 534      tree decl ATTRIBUTE_UNUSED;
 535      const char *name;
 536      int size, align;
 537 {
 538   ASM_GLOBALIZE_LABEL (file, name);
 539   bss_section ();
 540   ASM_OUTPUT_ALIGN (file, floor_log2 (align / BITS_PER_UNIT));
 541 #ifdef ASM_DECLARE_OBJECT_NAME
 542   last_assemble_variable_decl = decl;
 543   ASM_DECLARE_OBJECT_NAME (file, name, decl);
 544 #else
 545   /* Standard thing is just output label for the object.  */
 546   ASM_OUTPUT_LABEL (file, name);
 547 #endif /* ASM_DECLARE_OBJECT_NAME */
 548   ASM_OUTPUT_SKIP (file, size ? size : 1);
 549 }
 550
 551 #endif
 552
 553 #endif /* BSS_SECTION_ASM_OP */
 554
 555 /* Switch to the section for function DECL.
 556
 557    If DECL is NULL_TREE, switch to the text section.
 558    ??? It's not clear that we will ever be passed NULL_TREE, but it's
 559    safer to handle it.  */
 560
 561 void
 562 function_section (decl)
 563      tree decl;
 564 {
 565   if (decl != NULL_TREE
 566       && DECL_SECTION_NAME (decl) != NULL_TREE)
 567     named_section (decl, (char *) 0, 0);
 568   else
 569     text_section ();
 570 }
 571
 572 /* Switch to section for variable DECL.
 573
 574    RELOC is the `reloc' argument to SELECT_SECTION.  */
 575
 576 void
 577 variable_section (decl, reloc)
 578      tree decl;
 579      int reloc;
 580 {
 581   if (IN_NAMED_SECTION (decl))
 582     named_section (decl, NULL, reloc);
 583   else
 584     {
 585       /* C++ can have const variables that get initialized from constructors,
 586          and thus can not be in a readonly section.  We prevent this by
 587          verifying that the initial value is constant for objects put in a
 588          readonly section.
 589
 590          error_mark_node is used by the C front end to indicate that the
 591          initializer has not been seen yet.  In this case, we assume that
 592          the initializer must be constant.
 593
 594          C++ uses error_mark_node for variables that have complicated
 595          initializers, but these variables go in BSS so we won't be called
 596          for them.  */
 597
 598 #ifdef SELECT_SECTION
 599       SELECT_SECTION (decl, reloc, DECL_ALIGN (decl));
 600 #else
 601       if (DECL_READONLY_SECTION (decl, reloc))
 602         readonly_data_section ();
 603       else
 604         data_section ();
 605 #endif
 606     }
 607 }
 608
 609 /* Tell assembler to switch to the section for the exception handling
 610    table.  */
 611
 612 void
 613 default_exception_section ()
 614 {
 615   if (targetm.have_named_sections)
 616     named_section (NULL_TREE, ".gcc_except_table", 0);
 617   else if (flag_pic)
 618     data_section ();
 619   else
 620     readonly_data_section ();
 621 }
 622
 623 /* Tell assembler to switch to the section for string merging.  */
 624
 625 void
 626 mergeable_string_section (decl, align, flags)
 627   tree decl ATTRIBUTE_UNUSED;
 628   unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED;
 629   unsigned int flags ATTRIBUTE_UNUSED;
 630 {
 631 #ifdef HAVE_GAS_SHF_MERGE
 632   if (flag_merge_constants
 633       && TREE_CODE (decl) == STRING_CST
 634       && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
 635       && align <= 256
 636       && TREE_STRING_LENGTH (decl) >= int_size_in_bytes (TREE_TYPE (decl)))
 637     {
 638       enum machine_mode mode;
 639       unsigned int modesize;
 640       const char *str;
 641       int i, j, len, unit;
 642       char name[30];
 643
 644       mode = TYPE_MODE (TREE_TYPE (TREE_TYPE (decl)));
 645       modesize = GET_MODE_BITSIZE (mode);
 646       if (modesize >= 8 && modesize <= 256
 647           && (modesize & (modesize - 1)) == 0)
 648         {
 649           if (align < modesize)
 650             align = modesize;
 651
 652           str = TREE_STRING_POINTER (decl);
 653           len = TREE_STRING_LENGTH (decl);
 654           unit = GET_MODE_SIZE (mode);
 655
 656           /* Check for embedded NUL characters.  */
 657           for (i = 0; i < len; i += unit)
 658             {
 659               for (j = 0; j < unit; j++)
 660                 if (str [i + j] != '\0')
 661                   break;
 662               if (j == unit)
 663                 break;
 664             }
 665           if (i == len - unit)
 666             {
 667               sprintf (name, ".rodata.str%d.%d", modesize / 8,
 668                        (int) (align / 8));
 669               flags |= (modesize / 8) | SECTION_MERGE | SECTION_STRINGS;
 670               if (!i && modesize < align)
 671                 {
 672                   /* A "" string with requested alignment greater than
 673                      character size might cause a problem:
 674                      if some other string required even bigger
 675                      alignment than "", then linker might think the
 676                      "" is just part of padding after some other string
 677                      and not put it into the hash table initially.
 678                      But this means "" could have smaller alignment
 679                      than requested.  */
 680 #ifdef ASM_OUTPUT_SECTION_START
 681                   named_section_flags (name, flags);
 682                   ASM_OUTPUT_SECTION_START (asm_out_file);
 683 #else
 684                   readonly_data_section ();
 685 #endif
 686                   return;
 687                 }
 688
 689               named_section_flags (name, flags);
 690               return;
 691             }
 692         }
 693     }
 694 #endif
 695   readonly_data_section ();
 696 }
 697
 698 /* Tell assembler to switch to the section for constant merging.  */
 699
 700 void
 701 mergeable_constant_section (mode, align, flags)
 702   enum machine_mode mode ATTRIBUTE_UNUSED;
 703   unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED;
 704   unsigned int flags ATTRIBUTE_UNUSED;
 705 {
 706 #ifdef HAVE_GAS_SHF_MERGE
 707   unsigned int modesize = GET_MODE_BITSIZE (mode);
 708
 709   if (flag_merge_constants
 710       && mode != VOIDmode
 711       && mode != BLKmode
 712       && modesize <= align
 713       && align >= 8
 714       && align <= 256
 715       && (align & (align - 1)) == 0)
 716     {
 717       char name[24];
 718
 719       sprintf (name, ".rodata.cst%d", (int) (align / 8));
 720       flags |= (align / 8) | SECTION_MERGE;
 721       named_section_flags (name, flags);
 722       return;
 723     }
 724 #endif
 725   readonly_data_section ();
 726 }
 727 \f
 728 /* Given NAME, a putative register name, discard any customary prefixes.  */
 729
 730 static const char *
 731 strip_reg_name (name)
 732   const char *name;
 733 {
 734 #ifdef REGISTER_PREFIX
 735   if (!strncmp (name, REGISTER_PREFIX, strlen (REGISTER_PREFIX)))
 736     name += strlen (REGISTER_PREFIX);
 737 #endif
 738   if (name[0] == '%' || name[0] == '#')
 739     name++;
 740   return name;
 741 }
 742 \f
 743 /* Decode an `asm' spec for a declaration as a register name.
 744    Return the register number, or -1 if nothing specified,
 745    or -2 if the ASMSPEC is not `cc' or `memory' and is not recognized,
 746    or -3 if ASMSPEC is `cc' and is not recognized,
 747    or -4 if ASMSPEC is `memory' and is not recognized.
 748    Accept an exact spelling or a decimal number.
 749    Prefixes such as % are optional.  */
 750
 751 int
 752 decode_reg_name (asmspec)
 753   const char *asmspec;
 754 {
 755   if (asmspec != 0)
 756     {
 757       int i;
 758
 759       /* Get rid of confusing prefixes.  */
 760       asmspec = strip_reg_name (asmspec);
 761
 762       /* Allow a decimal number as a "register name".  */
 763       for (i = strlen (asmspec) - 1; i >= 0; i--)
 764         if (! ISDIGIT (asmspec[i]))
 765           break;
 766       if (asmspec[0] != 0 && i < 0)
 767         {
 768           i = atoi (asmspec);
 769           if (i < FIRST_PSEUDO_REGISTER && i >= 0)
 770             return i;
 771           else
 772             return -2;
 773         }
 774
 775       for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
 776         if (reg_names[i][0]
 777             && ! strcmp (asmspec, strip_reg_name (reg_names[i])))
 778           return i;
 779
 780 #ifdef ADDITIONAL_REGISTER_NAMES
 781       {
 782         static const struct { const char *const name; const int number; } table[]
 783           = ADDITIONAL_REGISTER_NAMES;
 784
 785         for (i = 0; i < (int) ARRAY_SIZE (table); i++)
 786           if (! strcmp (asmspec, table[i].name))
 787             return table[i].number;
 788       }
 789 #endif /* ADDITIONAL_REGISTER_NAMES */
 790
 791       if (!strcmp (asmspec, "memory"))
 792         return -4;
 793
 794       if (!strcmp (asmspec, "cc"))
 795         return -3;
 796
 797       return -2;
 798     }
 799
 800   return -1;
 801 }
 802 \f
 803 /* Create the DECL_RTL for a VAR_DECL or FUNCTION_DECL.  DECL should
 804    have static storage duration.  In other words, it should not be an
 805    automatic variable, including PARM_DECLs.
 806
 807    There is, however, one exception: this function handles variables
 808    explicitly placed in a particular register by the user.
 809
 810    ASMSPEC, if not 0, is the string which the user specified as the
 811    assembler symbol name.
 812
 813    This is never called for PARM_DECL nodes.  */
 814
 815 void
 816 make_decl_rtl (decl, asmspec)
 817      tree decl;
 818      const char *asmspec;
 819 {
 820   int top_level = (DECL_CONTEXT (decl) == NULL_TREE);
 821   const char *name = 0;
 822   const char *new_name = 0;
 823   int reg_number;
 824   rtx x;
 825
 826   /* Check that we are not being given an automatic variable.  */
 827   /* A weak alias has TREE_PUBLIC set but not the other bits.  */
 828   if (TREE_CODE (decl) == PARM_DECL
 829       || TREE_CODE (decl) == RESULT_DECL
 830       || (TREE_CODE (decl) == VAR_DECL
 831           && !TREE_STATIC (decl)
 832           && !TREE_PUBLIC (decl)
 833           && !DECL_EXTERNAL (decl)
 834           && !DECL_REGISTER (decl)))
 835     abort ();
 836   /* And that we were not given a type or a label.  */
 837   else if (TREE_CODE (decl) == TYPE_DECL
 838            || TREE_CODE (decl) == LABEL_DECL)
 839     abort ();
 840
 841   /* For a duplicate declaration, we can be called twice on the
 842      same DECL node.  Don't discard the RTL already made.  */
 843   if (DECL_RTL_SET_P (decl))
 844     {
 845       /* If the old RTL had the wrong mode, fix the mode.  */
 846       if (GET_MODE (DECL_RTL (decl)) != DECL_MODE (decl))
 847         SET_DECL_RTL (decl, adjust_address_nv (DECL_RTL (decl),
 848                                                DECL_MODE (decl), 0));
 849
 850       /* ??? Another way to do this would be to do what halfpic.c does
 851          and maintain a hashed table of such critters.  */
 852       /* Let the target reassign the RTL if it wants.
 853          This is necessary, for example, when one machine specific
 854          decl attribute overrides another.  */
 855 #ifdef ENCODE_SECTION_INFO
 856       ENCODE_SECTION_INFO (decl, false);
 857 #endif
 858       return;
 859     }
 860
 861   new_name = name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
 862
 863   reg_number = decode_reg_name (asmspec);
 864   if (reg_number == -2)
 865     {
 866       /* ASMSPEC is given, and not the name of a register.  Mark the
 867          name with a star so assemble_name won't munge it.  */
 868       char *starred = alloca (strlen (asmspec) + 2);
 869       starred[0] = '*';
 870       strcpy (starred + 1, asmspec);
 871       new_name = starred;
 872     }
 873
 874   if (TREE_CODE (decl) != FUNCTION_DECL && DECL_REGISTER (decl))
 875     {
 876       /* First detect errors in declaring global registers.  */
 877       if (reg_number == -1)
 878         error_with_decl (decl, "register name not specified for `%s'");
 879       else if (reg_number < 0)
 880         error_with_decl (decl, "invalid register name for `%s'");
 881       else if (TYPE_MODE (TREE_TYPE (decl)) == BLKmode)
 882         error_with_decl (decl,
 883                          "data type of `%s' isn't suitable for a register");
 884       else if (! HARD_REGNO_MODE_OK (reg_number, TYPE_MODE (TREE_TYPE (decl))))
 885         error_with_decl (decl,
 886                          "register specified for `%s' isn't suitable for data type");
 887       /* Now handle properly declared static register variables.  */
 888       else
 889         {
 890           int nregs;
 891
 892           if (DECL_INITIAL (decl) != 0 && TREE_STATIC (decl))
 893             {
 894               DECL_INITIAL (decl) = 0;
 895               error ("global register variable has initial value");
 896             }
 897           if (TREE_THIS_VOLATILE (decl))
 898             warning ("volatile register variables don't work as you might wish");
 899
 900           /* If the user specified one of the eliminables registers here,
 901              e.g., FRAME_POINTER_REGNUM, we don't want to get this variable
 902              confused with that register and be eliminated.  This usage is
 903              somewhat suspect...  */
 904
 905           SET_DECL_RTL (decl, gen_rtx_raw_REG (DECL_MODE (decl), reg_number));
 906           ORIGINAL_REGNO (DECL_RTL (decl)) = reg_number;
 907           REG_USERVAR_P (DECL_RTL (decl)) = 1;
 908
 909           if (TREE_STATIC (decl))
 910             {
 911               /* Make this register global, so not usable for anything
 912                  else.  */
 913 #ifdef ASM_DECLARE_REGISTER_GLOBAL
 914               ASM_DECLARE_REGISTER_GLOBAL (asm_out_file, decl, reg_number, name);
 915 #endif
 916               nregs = HARD_REGNO_NREGS (reg_number, DECL_MODE (decl));
 917               while (nregs > 0)
 918                 globalize_reg (reg_number + --nregs);
 919             }
 920
 921           /* As a register variable, it has no section.  */
 922           return;
 923         }
 924     }
 925
 926   /* Now handle ordinary static variables and functions (in memory).
 927      Also handle vars declared register invalidly.  */
 928
 929   if (reg_number >= 0 || reg_number == -3)
 930     error_with_decl (decl,
 931                      "register name given for non-register variable `%s'");
 932
 933   /* Specifying a section attribute on a variable forces it into a
 934      non-.bss section, and thus it cannot be common.  */
 935   if (TREE_CODE (decl) == VAR_DECL
 936       && DECL_SECTION_NAME (decl) != NULL_TREE
 937       && DECL_INITIAL (decl) == NULL_TREE
 938       && DECL_COMMON (decl))
 939     DECL_COMMON (decl) = 0;
 940
 941   /* Can't use just the variable's own name for a variable
 942      whose scope is less than the whole file, unless it's a member
 943      of a local class (which will already be unambiguous).
 944      Concatenate a distinguishing number.  */
 945   if (!top_level && !TREE_PUBLIC (decl)
 946       && ! (DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl)))
 947       && asmspec == 0
 948       && name == IDENTIFIER_POINTER (DECL_NAME (decl)))
 949     {
 950       char *label;
 951
 952       ASM_FORMAT_PRIVATE_NAME (label, name, var_labelno);
 953       var_labelno++;
 954       new_name = label;
 955     }
 956
 957   if (name != new_name)
 958     {
 959       SET_DECL_ASSEMBLER_NAME (decl, get_identifier (new_name));
 960       name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
 961     }
 962
 963   /* If this variable is to be treated as volatile, show its
 964      tree node has side effects.  */
 965   if ((flag_volatile_global && TREE_CODE (decl) == VAR_DECL
 966        && TREE_PUBLIC (decl))
 967       || ((flag_volatile_static && TREE_CODE (decl) == VAR_DECL
 968            && (TREE_PUBLIC (decl) || TREE_STATIC (decl)))))
 969     TREE_SIDE_EFFECTS (decl) = 1;
 970
 971   x = gen_rtx_MEM (DECL_MODE (decl), gen_rtx_SYMBOL_REF (Pmode, name));
 972   SYMBOL_REF_WEAK (XEXP (x, 0)) = DECL_WEAK (decl);
 973   if (TREE_CODE (decl) != FUNCTION_DECL)
 974     set_mem_attributes (x, decl, 1);
 975   SET_DECL_RTL (decl, x);
 976
 977   /* Optionally set flags or add text to the name to record information
 978      such as that it is a function name.
 979      If the name is changed, the macro ASM_OUTPUT_LABELREF
 980      will have to know how to strip this information.  */
 981 #ifdef ENCODE_SECTION_INFO
 982   ENCODE_SECTION_INFO (decl, true);
 983 #endif
 984 }
 985
 986 /* Make the rtl for variable VAR be volatile.
 987    Use this only for static variables.  */
 988
 989 void
 990 make_var_volatile (var)
 991      tree var;
 992 {
 993   if (GET_CODE (DECL_RTL (var)) != MEM)
 994     abort ();
 995
 996   MEM_VOLATILE_P (DECL_RTL (var)) = 1;
 997 }
 998 \f
 999 /* Output alignment directive to align for constant expression EXP.  */
1000
1001 void
1002 assemble_constant_align (exp)
1003      tree exp;
1004 {
1005   int align;
1006
1007   /* Align the location counter as required by EXP's data type.  */
1008   align = TYPE_ALIGN (TREE_TYPE (exp));
1009 #ifdef CONSTANT_ALIGNMENT
1010   align = CONSTANT_ALIGNMENT (exp, align);
1011 #endif
1012
1013   if (align > BITS_PER_UNIT)
1014     {
1015       ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
1016     }
1017 }
1018
1019 /* Output a string of literal assembler code
1020    for an `asm' keyword used between functions.  */
1021
1022 void
1023 assemble_asm (string)
1024      tree string;
1025 {
1026   app_enable ();
1027
1028   if (TREE_CODE (string) == ADDR_EXPR)
1029     string = TREE_OPERAND (string, 0);
1030
1031   fprintf (asm_out_file, "\t%s\n", TREE_STRING_POINTER (string));
1032 }
1033
1034 /* Record an element in the table of global destructors.  SYMBOL is
1035    a SYMBOL_REF of the function to be called; PRIORITY is a number
1036    between 0 and MAX_INIT_PRIORITY.  */
1037
1038 void
1039 default_stabs_asm_out_destructor (symbol, priority)
1040      rtx symbol;
1041      int priority ATTRIBUTE_UNUSED;
1042 {
1043   /* Tell GNU LD that this is part of the static destructor set.
1044      This will work for any system that uses stabs, most usefully
1045      aout systems.  */
1046   fprintf (asm_out_file, "%s\"___DTOR_LIST__\",22,0,0,", ASM_STABS_OP);
1047   assemble_name (asm_out_file, XSTR (symbol, 0));
1048   fputc ('\n', asm_out_file);
1049 }
1050
1051 void
1052 default_named_section_asm_out_destructor (symbol, priority)
1053      rtx symbol;
1054      int priority;
1055 {
1056   const char *section = ".dtors";
1057   char buf[16];
1058
1059   /* ??? This only works reliably with the GNU linker.  */
1060   if (priority != DEFAULT_INIT_PRIORITY)
1061     {
1062       sprintf (buf, ".dtors.%.5u",
1063                /* Invert the numbering so the linker puts us in the proper
1064                   order; constructors are run from right to left, and the
1065                   linker sorts in increasing order.  */
1066                MAX_INIT_PRIORITY - priority);
1067       section = buf;
1068     }
1069
1070   named_section_flags (section, SECTION_WRITE);
1071   assemble_align (POINTER_SIZE);
1072   assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1073 }
1074
1075 #ifdef DTORS_SECTION_ASM_OP
1076 void
1077 dtors_section ()
1078 {
1079   if (in_section != in_dtors)
1080     {
1081       in_section = in_dtors;
1082       fputs (DTORS_SECTION_ASM_OP, asm_out_file);
1083       fputc ('\n', asm_out_file);
1084     }
1085 }
1086
1087 void
1088 default_dtor_section_asm_out_destructor (symbol, priority)
1089      rtx symbol;
1090      int priority ATTRIBUTE_UNUSED;
1091 {
1092   dtors_section ();
1093   assemble_align (POINTER_SIZE);
1094   assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1095 }
1096 #endif
1097
1098 /* Likewise for global constructors.  */
1099
1100 void
1101 default_stabs_asm_out_constructor (symbol, priority)
1102      rtx symbol;
1103      int priority ATTRIBUTE_UNUSED;
1104 {
1105   /* Tell GNU LD that this is part of the static destructor set.
1106      This will work for any system that uses stabs, most usefully
1107      aout systems.  */
1108   fprintf (asm_out_file, "%s\"___CTOR_LIST__\",22,0,0,", ASM_STABS_OP);
1109   assemble_name (asm_out_file, XSTR (symbol, 0));
1110   fputc ('\n', asm_out_file);
1111 }
1112
1113 void
1114 default_named_section_asm_out_constructor (symbol, priority)
1115      rtx symbol;
1116      int priority;
1117 {
1118   const char *section = ".ctors";
1119   char buf[16];
1120
1121   /* ??? This only works reliably with the GNU linker.  */
1122   if (priority != DEFAULT_INIT_PRIORITY)
1123     {
1124       sprintf (buf, ".ctors.%.5u",
1125                /* Invert the numbering so the linker puts us in the proper
1126                   order; constructors are run from right to left, and the
1127                   linker sorts in increasing order.  */
1128                MAX_INIT_PRIORITY - priority);
1129       section = buf;
1130     }
1131
1132   named_section_flags (section, SECTION_WRITE);
1133   assemble_align (POINTER_SIZE);
1134   assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1135 }
1136
1137 #ifdef CTORS_SECTION_ASM_OP
1138 void
1139 ctors_section ()
1140 {
1141   if (in_section != in_ctors)
1142     {
1143       in_section = in_ctors;
1144       fputs (CTORS_SECTION_ASM_OP, asm_out_file);
1145       fputc ('\n', asm_out_file);
1146     }
1147 }
1148
1149 void
1150 default_ctor_section_asm_out_constructor (symbol, priority)
1151      rtx symbol;
1152      int priority ATTRIBUTE_UNUSED;
1153 {
1154   ctors_section ();
1155   assemble_align (POINTER_SIZE);
1156   assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1157 }
1158 #endif
1159 \f
1160 /* CONSTANT_POOL_BEFORE_FUNCTION may be defined as an expression with
1161    a non-zero value if the constant pool should be output before the
1162    start of the function, or a zero value if the pool should output
1163    after the end of the function.  The default is to put it before the
1164    start.  */
1165
1166 #ifndef CONSTANT_POOL_BEFORE_FUNCTION
1167 #define CONSTANT_POOL_BEFORE_FUNCTION 1
1168 #endif
1169
1170 /* Output assembler code for the constant pool of a function and associated
1171    with defining the name of the function.  DECL describes the function.
1172    NAME is the function's name.  For the constant pool, we use the current
1173    constant pool data.  */
1174
1175 void
1176 assemble_start_function (decl, fnname)
1177      tree decl;
1178      const char *fnname;
1179 {
1180   int align;
1181
1182   /* The following code does not need preprocessing in the assembler.  */
1183
1184   app_disable ();
1185
1186   if (CONSTANT_POOL_BEFORE_FUNCTION)
1187     output_constant_pool (fnname, decl);
1188
1189   resolve_unique_section (decl, 0);
1190   function_section (decl);
1191
1192   /* Tell assembler to move to target machine's alignment for functions.  */
1193   align = floor_log2 (FUNCTION_BOUNDARY / BITS_PER_UNIT);
1194   if (align > 0)
1195     {
1196       ASM_OUTPUT_ALIGN (asm_out_file, align);
1197     }
1198
1199   /* Handle a user-specified function alignment.
1200      Note that we still need to align to FUNCTION_BOUNDARY, as above,
1201      because ASM_OUTPUT_MAX_SKIP_ALIGN might not do any alignment at all.  */
1202   if (align_functions_log > align)
1203     {
1204 #ifdef ASM_OUTPUT_MAX_SKIP_ALIGN
1205       ASM_OUTPUT_MAX_SKIP_ALIGN (asm_out_file,
1206                                  align_functions_log, align_functions-1);
1207 #else
1208       ASM_OUTPUT_ALIGN (asm_out_file, align_functions_log);
1209 #endif
1210     }
1211
1212 #ifdef ASM_OUTPUT_FUNCTION_PREFIX
1213   ASM_OUTPUT_FUNCTION_PREFIX (asm_out_file, fnname);
1214 #endif
1215
1216   (*debug_hooks->begin_function) (decl);
1217
1218   /* Make function name accessible from other files, if appropriate.  */
1219
1220   if (TREE_PUBLIC (decl))
1221     {
1222       if (! first_global_object_name)
1223         {
1224           const char *p;
1225           char *name;
1226
1227           STRIP_NAME_ENCODING (p, fnname);
1228           name = permalloc (strlen (p) + 1);
1229           strcpy (name, p);
1230
1231           if (! DECL_WEAK (decl) && ! DECL_ONE_ONLY (decl))
1232             first_global_object_name = name;
1233           else
1234             weak_global_object_name = name;
1235         }
1236
1237       globalize_decl (decl);
1238
1239       maybe_assemble_visibility (decl);
1240     }
1241
1242   /* Do any machine/system dependent processing of the function name */
1243 #ifdef ASM_DECLARE_FUNCTION_NAME
1244   ASM_DECLARE_FUNCTION_NAME (asm_out_file, fnname, current_function_decl);
1245 #else
1246   /* Standard thing is just output label for the function.  */
1247   ASM_OUTPUT_LABEL (asm_out_file, fnname);
1248 #endif /* ASM_DECLARE_FUNCTION_NAME */
1249 }
1250
1251 /* Output assembler code associated with defining the size of the
1252    function.  DECL describes the function.  NAME is the function's name.  */
1253
1254 void
1255 assemble_end_function (decl, fnname)
1256      tree decl;
1257      const char *fnname;
1258 {
1259 #ifdef ASM_DECLARE_FUNCTION_SIZE
1260   ASM_DECLARE_FUNCTION_SIZE (asm_out_file, fnname, decl);
1261 #endif
1262   if (! CONSTANT_POOL_BEFORE_FUNCTION)
1263     {
1264       output_constant_pool (fnname, decl);
1265       function_section (decl);  /* need to switch back */
1266     }
1267
1268   /* Output any constants which should appear after the function.  */
1269   output_after_function_constants ();
1270 }
1271 \f
1272 /* Assemble code to leave SIZE bytes of zeros.  */
1273
1274 void
1275 assemble_zeros (size)
1276      int size;
1277 {
1278   /* Do no output if -fsyntax-only.  */
1279   if (flag_syntax_only)
1280     return;
1281
1282 #ifdef ASM_NO_SKIP_IN_TEXT
1283   /* The `space' pseudo in the text section outputs nop insns rather than 0s,
1284      so we must output 0s explicitly in the text section.  */
1285   if (ASM_NO_SKIP_IN_TEXT && in_text_section ())
1286     {
1287       int i;
1288       for (i = 0; i < size; i++)
1289         assemble_integer (const0_rtx, 1, BITS_PER_UNIT, 1);
1290     }
1291   else
1292 #endif
1293     if (size > 0)
1294       ASM_OUTPUT_SKIP (asm_out_file, size);
1295 }
1296
1297 /* Assemble an alignment pseudo op for an ALIGN-bit boundary.  */
1298
1299 void
1300 assemble_align (align)
1301      int align;
1302 {
1303   if (align > BITS_PER_UNIT)
1304     {
1305       ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
1306     }
1307 }
1308
1309 /* Assemble a string constant with the specified C string as contents.  */
1310
1311 void
1312 assemble_string (p, size)
1313      const char *p;
1314      int size;
1315 {
1316   int pos = 0;
1317   int maximum = 2000;
1318
1319   /* If the string is very long, split it up.  */
1320
1321   while (pos < size)
1322     {
1323       int thissize = size - pos;
1324       if (thissize > maximum)
1325         thissize = maximum;
1326
1327       ASM_OUTPUT_ASCII (asm_out_file, p, thissize);
1328
1329       pos += thissize;
1330       p += thissize;
1331     }
1332 }
1333
1334 \f
1335 #if defined  ASM_OUTPUT_ALIGNED_DECL_LOCAL
1336 #define ASM_EMIT_LOCAL(decl, name, size, rounded) \
1337   ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file, decl, name, size, DECL_ALIGN (decl))
1338 #else
1339 #if defined  ASM_OUTPUT_ALIGNED_LOCAL
1340 #define ASM_EMIT_LOCAL(decl, name, size, rounded) \
1341   ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, DECL_ALIGN (decl))
1342 #else
1343 #define ASM_EMIT_LOCAL(decl, name, size, rounded) \
1344   ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded)
1345 #endif
1346 #endif
1347
1348 #if defined ASM_OUTPUT_ALIGNED_BSS
1349 #define ASM_EMIT_BSS(decl, name, size, rounded) \
1350   ASM_OUTPUT_ALIGNED_BSS (asm_out_file, decl, name, size, DECL_ALIGN (decl))
1351 #else
1352 #if defined ASM_OUTPUT_BSS
1353 #define ASM_EMIT_BSS(decl, name, size, rounded) \
1354   ASM_OUTPUT_BSS (asm_out_file, decl, name, size, rounded)
1355 #else
1356 #undef  ASM_EMIT_BSS
1357 #endif
1358 #endif
1359
1360 #if defined ASM_OUTPUT_ALIGNED_DECL_COMMON
1361 #define ASM_EMIT_COMMON(decl, name, size, rounded) \
1362   ASM_OUTPUT_ALIGNED_DECL_COMMON (asm_out_file, decl, name, size, DECL_ALIGN (decl))
1363 #else
1364 #if defined ASM_OUTPUT_ALIGNED_COMMON
1365 #define ASM_EMIT_COMMON(decl, name, size, rounded) \
1366   ASM_OUTPUT_ALIGNED_COMMON (asm_out_file, name, size, DECL_ALIGN (decl))
1367 #else
1368 #define ASM_EMIT_COMMON(decl, name, size, rounded) \
1369   ASM_OUTPUT_COMMON (asm_out_file, name, size, rounded)
1370 #endif
1371 #endif
1372
1373 static void
1374 asm_emit_uninitialised (decl, name, size, rounded)
1375      tree decl;
1376      const char * name;
1377      int size ATTRIBUTE_UNUSED;
1378      int rounded ATTRIBUTE_UNUSED;
1379 {
1380   enum
1381   {
1382     asm_dest_common,
1383     asm_dest_bss,
1384     asm_dest_local
1385   }
1386   destination = asm_dest_local;
1387
1388   if (TREE_PUBLIC (decl))
1389     {
1390 #if defined ASM_EMIT_BSS
1391       if (! DECL_COMMON (decl))
1392         destination = asm_dest_bss;
1393       else
1394 #endif
1395         destination = asm_dest_common;
1396     }
1397
1398   switch (destination)
1399     {
1400     case asm_dest_common:
1401       if (! DECL_WEAK (decl))
1402         break;
1403     case asm_dest_bss:
1404       globalize_decl (decl);
1405     default:
1406       break;
1407     }
1408
1409   if (flag_shared_data)
1410     {
1411       switch (destination)
1412         {
1413 #ifdef ASM_OUTPUT_SHARED_BSS
1414         case asm_dest_bss:
1415           ASM_OUTPUT_SHARED_BSS (asm_out_file, decl, name, size, rounded);
1416           return;
1417 #endif
1418 #ifdef ASM_OUTPUT_SHARED_COMMON
1419         case asm_dest_common:
1420           ASM_OUTPUT_SHARED_COMMON (asm_out_file, name, size, rounded);
1421           return;
1422 #endif
1423 #ifdef ASM_OUTPUT_SHARED_LOCAL
1424         case asm_dest_local:
1425           ASM_OUTPUT_SHARED_LOCAL (asm_out_file, name, size, rounded);
1426           return;
1427 #endif
1428         default:
1429           break;
1430         }
1431     }
1432
1433   resolve_unique_section (decl, 0);
1434
1435   switch (destination)
1436     {
1437 #ifdef ASM_EMIT_BSS
1438     case asm_dest_bss:
1439       ASM_EMIT_BSS (decl, name, size, rounded);
1440       break;
1441 #endif
1442     case asm_dest_common:
1443       ASM_EMIT_COMMON (decl, name, size, rounded);
1444       break;
1445     case asm_dest_local:
1446       ASM_EMIT_LOCAL (decl, name, size, rounded);
1447       break;
1448     default:
1449       abort ();
1450     }
1451
1452   return;
1453 }
1454
1455 /* Assemble everything that is needed for a variable or function declaration.
1456    Not used for automatic variables, and not used for function definitions.
1457    Should not be called for variables of incomplete structure type.
1458
1459    TOP_LEVEL is nonzero if this variable has file scope.
1460    AT_END is nonzero if this is the special handling, at end of compilation,
1461    to define things that have had only tentative definitions.
1462    DONT_OUTPUT_DATA if nonzero means don't actually output the
1463    initial value (that will be done by the caller).  */
1464
1465 void
1466 assemble_variable (decl, top_level, at_end, dont_output_data)
1467      tree decl;
1468      int top_level ATTRIBUTE_UNUSED;
1469      int at_end ATTRIBUTE_UNUSED;
1470      int dont_output_data;
1471 {
1472   const char *name;
1473   unsigned int align;
1474   int reloc = 0;
1475   rtx decl_rtl;
1476
1477   last_assemble_variable_decl = 0;
1478
1479   /* Normally no need to say anything here for external references,
1480      since assemble_external is called by the language-specific code
1481      when a declaration is first seen.  */
1482
1483   if (DECL_EXTERNAL (decl))
1484     return;
1485
1486   /* Output no assembler code for a function declaration.
1487      Only definitions of functions output anything.  */
1488
1489   if (TREE_CODE (decl) == FUNCTION_DECL)
1490     return;
1491
1492   /* Do nothing for global register variables.  */
1493   if (DECL_RTL_SET_P (decl) && GET_CODE (DECL_RTL (decl)) == REG)
1494     {
1495       TREE_ASM_WRITTEN (decl) = 1;
1496       return;
1497     }
1498
1499   /* If type was incomplete when the variable was declared,
1500      see if it is complete now.  */
1501
1502   if (DECL_SIZE (decl) == 0)
1503     layout_decl (decl, 0);
1504
1505   /* Still incomplete => don't allocate it; treat the tentative defn
1506      (which is what it must have been) as an `extern' reference.  */
1507
1508   if (!dont_output_data && DECL_SIZE (decl) == 0)
1509     {
1510       error_with_file_and_line (DECL_SOURCE_FILE (decl),
1511                                 DECL_SOURCE_LINE (decl),
1512                                 "storage size of `%s' isn't known",
1513                                 IDENTIFIER_POINTER (DECL_NAME (decl)));
1514       TREE_ASM_WRITTEN (decl) = 1;
1515       return;
1516     }
1517
1518   /* The first declaration of a variable that comes through this function
1519      decides whether it is global (in C, has external linkage)
1520      or local (in C, has internal linkage).  So do nothing more
1521      if this function has already run.  */
1522
1523   if (TREE_ASM_WRITTEN (decl))
1524     return;
1525
1526   /* Make sure ENCODE_SECTION_INFO is invoked before we set ASM_WRITTEN.  */
1527   decl_rtl = DECL_RTL (decl);
1528
1529   TREE_ASM_WRITTEN (decl) = 1;
1530
1531   /* Do no output if -fsyntax-only.  */
1532   if (flag_syntax_only)
1533     return;
1534
1535   app_disable ();
1536
1537   if (! dont_output_data
1538       && ! host_integerp (DECL_SIZE_UNIT (decl), 1))
1539     {
1540       error_with_decl (decl, "size of variable `%s' is too large");
1541       return;
1542     }
1543
1544   name = XSTR (XEXP (decl_rtl, 0), 0);
1545   if (TREE_PUBLIC (decl) && DECL_NAME (decl)
1546       && ! first_global_object_name
1547       && ! (DECL_COMMON (decl) && (DECL_INITIAL (decl) == 0
1548                                    || DECL_INITIAL (decl) == error_mark_node))
1549       && ! DECL_WEAK (decl)
1550       && ! DECL_ONE_ONLY (decl))
1551     {
1552       const char *p;
1553       char *xname;
1554
1555       STRIP_NAME_ENCODING (p, name);
1556       xname = permalloc (strlen (p) + 1);
1557       strcpy (xname, p);
1558       first_global_object_name = xname;
1559     }
1560
1561   /* Compute the alignment of this data.  */
1562
1563   align = DECL_ALIGN (decl);
1564
1565   /* In the case for initialing an array whose length isn't specified,
1566      where we have not yet been able to do the layout,
1567      figure out the proper alignment now.  */
1568   if (dont_output_data && DECL_SIZE (decl) == 0
1569       && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
1570     align = MAX (align, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (decl))));
1571
1572   /* Some object file formats have a maximum alignment which they support.
1573      In particular, a.out format supports a maximum alignment of 4.  */
1574 #ifndef MAX_OFILE_ALIGNMENT
1575 #define MAX_OFILE_ALIGNMENT BIGGEST_ALIGNMENT
1576 #endif
1577   if (align > MAX_OFILE_ALIGNMENT)
1578     {
1579       warning_with_decl (decl,
1580         "alignment of `%s' is greater than maximum object file alignment. Using %d",
1581                     MAX_OFILE_ALIGNMENT/BITS_PER_UNIT);
1582       align = MAX_OFILE_ALIGNMENT;
1583     }
1584
1585   /* On some machines, it is good to increase alignment sometimes.  */
1586   if (! DECL_USER_ALIGN (decl))
1587     {
1588 #ifdef DATA_ALIGNMENT
1589       align = DATA_ALIGNMENT (TREE_TYPE (decl), align);
1590 #endif
1591 #ifdef CONSTANT_ALIGNMENT
1592       if (DECL_INITIAL (decl) != 0 && DECL_INITIAL (decl) != error_mark_node)
1593         align = CONSTANT_ALIGNMENT (DECL_INITIAL (decl), align);
1594 #endif
1595     }
1596
1597   /* Reset the alignment in case we have made it tighter, so we can benefit
1598      from it in get_pointer_alignment.  */
1599   DECL_ALIGN (decl) = align;
1600   set_mem_align (decl_rtl, align);
1601
1602   if (TREE_PUBLIC (decl))
1603     maybe_assemble_visibility (decl);
1604
1605   /* Output any data that we will need to use the address of.  */
1606   if (DECL_INITIAL (decl) == error_mark_node)
1607     reloc = contains_pointers_p (TREE_TYPE (decl)) ? 3 : 0;
1608   else if (DECL_INITIAL (decl))
1609     reloc = output_addressed_constants (DECL_INITIAL (decl));
1610   resolve_unique_section (decl, reloc);
1611
1612   /* Handle uninitialized definitions.  */
1613
1614   if ((DECL_INITIAL (decl) == 0 || DECL_INITIAL (decl) == error_mark_node
1615 #if defined ASM_EMIT_BSS
1616        || (flag_zero_initialized_in_bss
1617            && initializer_zerop (DECL_INITIAL (decl)))
1618 #endif
1619        )
1620       /* If the target can't output uninitialized but not common global data
1621          in .bss, then we have to use .data.  */
1622 #if ! defined ASM_EMIT_BSS
1623       && DECL_COMMON (decl)
1624 #endif
1625       && DECL_SECTION_NAME (decl) == NULL_TREE
1626       && ! dont_output_data)
1627     {
1628       unsigned HOST_WIDE_INT size = tree_low_cst (DECL_SIZE_UNIT (decl), 1);
1629       unsigned HOST_WIDE_INT rounded = size;
1630
1631       /* Don't allocate zero bytes of common,
1632          since that means "undefined external" in the linker.  */
1633       if (size == 0)
1634         rounded = 1;
1635
1636       /* Round size up to multiple of BIGGEST_ALIGNMENT bits
1637          so that each uninitialized object starts on such a boundary.  */
1638       rounded += (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1;
1639       rounded = (rounded / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
1640                  * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
1641
1642 /* Don't continue this line--convex cc version 4.1 would lose.  */
1643 #if !defined(ASM_OUTPUT_ALIGNED_COMMON) && !defined(ASM_OUTPUT_ALIGNED_DECL_COMMON) && !defined(ASM_OUTPUT_ALIGNED_BSS)
1644       if ((unsigned HOST_WIDE_INT) DECL_ALIGN (decl) / BITS_PER_UNIT > rounded)
1645          warning_with_decl
1646            (decl, "requested alignment for %s is greater than implemented alignment of %d",rounded);
1647 #endif
1648
1649       asm_emit_uninitialised (decl, name, size, rounded);
1650
1651       return;
1652     }
1653
1654   /* Handle initialized definitions.
1655      Also handle uninitialized global definitions if -fno-common and the
1656      target doesn't support ASM_OUTPUT_BSS.  */
1657
1658   /* First make the assembler name(s) global if appropriate.  */
1659   if (TREE_PUBLIC (decl) && DECL_NAME (decl))
1660     globalize_decl (decl);
1661
1662   /* Switch to the appropriate section.  */
1663   variable_section (decl, reloc);
1664
1665   /* dbxout.c needs to know this.  */
1666   if (in_text_section ())
1667     DECL_IN_TEXT_SECTION (decl) = 1;
1668
1669   /* Output the alignment of this data.  */
1670   if (align > BITS_PER_UNIT)
1671     {
1672       ASM_OUTPUT_ALIGN (asm_out_file,
1673                         floor_log2 (DECL_ALIGN (decl) / BITS_PER_UNIT));
1674     }
1675
1676   /* Do any machine/system dependent processing of the object.  */
1677 #ifdef ASM_DECLARE_OBJECT_NAME
1678   last_assemble_variable_decl = decl;
1679   ASM_DECLARE_OBJECT_NAME (asm_out_file, name, decl);
1680 #else
1681   /* Standard thing is just output label for the object.  */
1682   ASM_OUTPUT_LABEL (asm_out_file, name);
1683 #endif /* ASM_DECLARE_OBJECT_NAME */
1684
1685   if (!dont_output_data)
1686     {
1687       if (DECL_INITIAL (decl) && DECL_INITIAL (decl) != error_mark_node)
1688         /* Output the actual data.  */
1689         output_constant (DECL_INITIAL (decl),
1690                          tree_low_cst (DECL_SIZE_UNIT (decl), 1),
1691                          align);
1692       else
1693         /* Leave space for it.  */
1694         assemble_zeros (tree_low_cst (DECL_SIZE_UNIT (decl), 1));
1695     }
1696 }
1697
1698 /* Return 1 if type TYPE contains any pointers.  */
1699
1700 static int
1701 contains_pointers_p (type)
1702      tree type;
1703 {
1704   switch (TREE_CODE (type))
1705     {
1706     case POINTER_TYPE:
1707     case REFERENCE_TYPE:
1708       /* I'm not sure whether OFFSET_TYPE needs this treatment,
1709          so I'll play safe and return 1.  */
1710     case OFFSET_TYPE:
1711       return 1;
1712
1713     case RECORD_TYPE:
1714     case UNION_TYPE:
1715     case QUAL_UNION_TYPE:
1716       {
1717         tree fields;
1718         /* For a type that has fields, see if the fields have pointers.  */
1719         for (fields = TYPE_FIELDS (type); fields; fields = TREE_CHAIN (fields))
1720           if (TREE_CODE (fields) == FIELD_DECL
1721               && contains_pointers_p (TREE_TYPE (fields)))
1722             return 1;
1723         return 0;
1724       }
1725
1726     case ARRAY_TYPE:
1727       /* An array type contains pointers if its element type does.  */
1728       return contains_pointers_p (TREE_TYPE (type));
1729
1730     default:
1731       return 0;
1732     }
1733 }
1734
1735 /* Output something to declare an external symbol to the assembler.
1736    (Most assemblers don't need this, so we normally output nothing.)
1737    Do nothing if DECL is not external.  */
1738
1739 void
1740 assemble_external (decl)
1741      tree decl ATTRIBUTE_UNUSED;
1742 {
1743   /* Because most platforms do not define ASM_OUTPUT_EXTERNAL, the
1744      main body of this code is only rarely exercised.  To provide some
1745      testing, on all platforms, we make sure that the ASM_OUT_FILE is
1746      open.  If it's not, we should not be calling this function.  */
1747   if (!asm_out_file)
1748     abort ();
1749
1750 #ifdef ASM_OUTPUT_EXTERNAL
1751   if (DECL_P (decl) && DECL_EXTERNAL (decl) && TREE_PUBLIC (decl))
1752     {
1753       rtx rtl = DECL_RTL (decl);
1754
1755       if (GET_CODE (rtl) == MEM && GET_CODE (XEXP (rtl, 0)) == SYMBOL_REF
1756           && ! SYMBOL_REF_USED (XEXP (rtl, 0)))
1757         {
1758           /* Some systems do require some output.  */
1759           SYMBOL_REF_USED (XEXP (rtl, 0)) = 1;
1760           ASM_OUTPUT_EXTERNAL (asm_out_file, decl, XSTR (XEXP (rtl, 0), 0));
1761         }
1762     }
1763 #endif
1764 }
1765
1766 /* Similar, for calling a library function FUN.  */
1767
1768 void
1769 assemble_external_libcall (fun)
1770      rtx fun ATTRIBUTE_UNUSED;
1771 {
1772 #ifdef ASM_OUTPUT_EXTERNAL_LIBCALL
1773   /* Declare library function name external when first used, if nec.  */
1774   if (! SYMBOL_REF_USED (fun))
1775     {
1776       SYMBOL_REF_USED (fun) = 1;
1777       ASM_OUTPUT_EXTERNAL_LIBCALL (asm_out_file, fun);
1778     }
1779 #endif
1780 }
1781
1782 /* Declare the label NAME global.  */
1783
1784 void
1785 assemble_global (name)
1786      const char *name ATTRIBUTE_UNUSED;
1787 {
1788   ASM_GLOBALIZE_LABEL (asm_out_file, name);
1789 }
1790
1791 /* Assemble a label named NAME.  */
1792
1793 void
1794 assemble_label (name)
1795      const char *name;
1796 {
1797   ASM_OUTPUT_LABEL (asm_out_file, name);
1798 }
1799
1800 /* Output to FILE a reference to the assembler name of a C-level name NAME.
1801    If NAME starts with a *, the rest of NAME is output verbatim.
1802    Otherwise NAME is transformed in an implementation-defined way
1803    (usually by the addition of an underscore).
1804    Many macros in the tm file are defined to call this function.  */
1805
1806 void
1807 assemble_name (file, name)
1808      FILE *file;
1809      const char *name;
1810 {
1811   const char *real_name;
1812   tree id;
1813
1814   STRIP_NAME_ENCODING (real_name, name);
1815
1816   id = maybe_get_identifier (real_name);
1817   if (id)
1818     TREE_SYMBOL_REFERENCED (id) = 1;
1819
1820   if (name[0] == '*')
1821     fputs (&name[1], file);
1822   else
1823     ASM_OUTPUT_LABELREF (file, name);
1824 }
1825
1826 /* Allocate SIZE bytes writable static space with a gensym name
1827    and return an RTX to refer to its address.  */
1828
1829 rtx
1830 assemble_static_space (size)
1831      int size;
1832 {
1833   char name[12];
1834   const char *namestring;
1835   rtx x;
1836
1837 #if 0
1838   if (flag_shared_data)
1839     data_section ();
1840 #endif
1841
1842   ASM_GENERATE_INTERNAL_LABEL (name, "LF", const_labelno);
1843   ++const_labelno;
1844   namestring = ggc_strdup (name);
1845
1846   x = gen_rtx_SYMBOL_REF (Pmode, namestring);
1847
1848 #ifdef ASM_OUTPUT_ALIGNED_DECL_LOCAL
1849   ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file, NULL_TREE, name, size,
1850                                  BIGGEST_ALIGNMENT);
1851 #else
1852 #ifdef ASM_OUTPUT_ALIGNED_LOCAL
1853   ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, BIGGEST_ALIGNMENT);
1854 #else
1855   {
1856     /* Round size up to multiple of BIGGEST_ALIGNMENT bits
1857        so that each uninitialized object starts on such a boundary.  */
1858     /* Variable `rounded' might or might not be used in ASM_OUTPUT_LOCAL.  */
1859     int rounded ATTRIBUTE_UNUSED
1860       = ((size + (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1)
1861          / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
1862          * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
1863     ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
1864   }
1865 #endif
1866 #endif
1867   return x;
1868 }
1869
1870 /* Assemble the static constant template for function entry trampolines.
1871    This is done at most once per compilation.
1872    Returns an RTX for the address of the template.  */
1873
1874 #ifdef TRAMPOLINE_TEMPLATE
1875 rtx
1876 assemble_trampoline_template ()
1877 {
1878   char label[256];
1879   const char *name;
1880   int align;
1881
1882   /* By default, put trampoline templates in read-only data section.  */
1883
1884 #ifdef TRAMPOLINE_SECTION
1885   TRAMPOLINE_SECTION ();
1886 #else
1887   readonly_data_section ();
1888 #endif
1889
1890   /* Write the assembler code to define one.  */
1891   align = floor_log2 (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT);
1892   if (align > 0)
1893     {
1894       ASM_OUTPUT_ALIGN (asm_out_file, align);
1895     }
1896
1897   ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LTRAMP", 0);
1898   TRAMPOLINE_TEMPLATE (asm_out_file);
1899
1900   /* Record the rtl to refer to it.  */
1901   ASM_GENERATE_INTERNAL_LABEL (label, "LTRAMP", 0);
1902   name = ggc_strdup (label);
1903   return gen_rtx_SYMBOL_REF (Pmode, name);
1904 }
1905 #endif
1906 \f
1907 /* A and B are either alignments or offsets.  Return the minimum alignment
1908    that may be assumed after adding the two together.  */
1909
1910 static inline unsigned
1911 min_align (a, b)
1912      unsigned int a, b;
1913 {
1914   return (a | b) & -(a | b);
1915 }
1916
1917 /* Return the assembler directive for creating a given kind of integer
1918    object.  SIZE is the number of bytes in the object and ALIGNED_P
1919    indicates whether it is known to be aligned.  Return NULL if the
1920    assembly dialect has no such directive.
1921
1922    The returned string should be printed at the start of a new line and
1923    be followed immediately by the object's initial value.  */
1924
1925 const char *
1926 integer_asm_op (size, aligned_p)
1927      int size;
1928      int aligned_p;
1929 {
1930   struct asm_int_op *ops;
1931
1932   if (aligned_p)
1933     ops = &targetm.asm_out.aligned_op;
1934   else
1935     ops = &targetm.asm_out.unaligned_op;
1936
1937   switch (size)
1938     {
1939     case 1:
1940       return targetm.asm_out.byte_op;
1941     case 2:
1942       return ops->hi;
1943     case 4:
1944       return ops->si;
1945     case 8:
1946       return ops->di;
1947     case 16:
1948       return ops->ti;
1949     default:
1950       return NULL;
1951     }
1952 }
1953
1954 /* Use directive OP to assemble an integer object X.  Print OP at the
1955    start of the line, followed immediately by the value of X.  */
1956
1957 void
1958 assemble_integer_with_op (op, x)
1959      const char *op;
1960      rtx x;
1961 {
1962   fputs (op, asm_out_file);
1963   output_addr_const (asm_out_file, x);
1964   fputc ('\n', asm_out_file);
1965 }
1966
1967 /* The default implementation of the asm_out.integer target hook.  */
1968
1969 bool
1970 default_assemble_integer (x, size, aligned_p)
1971      rtx x ATTRIBUTE_UNUSED;
1972      unsigned int size ATTRIBUTE_UNUSED;
1973      int aligned_p ATTRIBUTE_UNUSED;
1974 {
1975   const char *op = integer_asm_op (size, aligned_p);
1976   return op && (assemble_integer_with_op (op, x), true);
1977 }
1978
1979 /* Assemble the integer constant X into an object of SIZE bytes.  ALIGN is
1980    the alignment of the integer in bits.  Return 1 if we were able to output
1981    the constant, otherwise 0.  If FORCE is non-zero, abort if we can't output
1982    the constant.  */
1983
1984 bool
1985 assemble_integer (x, size, align, force)
1986      rtx x;
1987      unsigned int size;
1988      unsigned int align;
1989      int force;
1990 {
1991   int aligned_p;
1992
1993   aligned_p = (align >= MIN (size * BITS_PER_UNIT, BIGGEST_ALIGNMENT));
1994
1995   /* See if the target hook can handle this kind of object.  */
1996   if ((*targetm.asm_out.integer) (x, size, aligned_p))
1997     return true;
1998
1999   /* If the object is a multi-byte one, try splitting it up.  Split
2000      it into words it if is multi-word, otherwise split it into bytes.  */
2001   if (size > 1)
2002     {
2003       enum machine_mode omode, imode;
2004       unsigned int subalign;
2005       unsigned int subsize, i;
2006
2007       subsize = size > UNITS_PER_WORD? UNITS_PER_WORD : 1;
2008       subalign = MIN (align, subsize * BITS_PER_UNIT);
2009       omode = mode_for_size (subsize * BITS_PER_UNIT, MODE_INT, 0);
2010       imode = mode_for_size (size * BITS_PER_UNIT, MODE_INT, 0);
2011
2012       for (i = 0; i < size; i += subsize)
2013         {
2014           rtx partial = simplify_subreg (omode, x, imode, i);
2015           if (!partial || !assemble_integer (partial, subsize, subalign, 0))
2016             break;
2017         }
2018       if (i == size)
2019         return true;
2020
2021       /* If we've printed some of it, but not all of it, there's no going
2022          back now.  */
2023       if (i > 0)
2024         abort ();
2025     }
2026
2027   if (force)
2028     abort ();
2029
2030   return false;
2031 }
2032 \f
2033 void
2034 assemble_real (d, mode, align)
2035      REAL_VALUE_TYPE d;
2036      enum machine_mode mode;
2037      unsigned int align;
2038 {
2039   long data[4];
2040   long l;
2041   unsigned int nalign = min_align (align, 32);
2042
2043   switch (BITS_PER_UNIT)
2044     {
2045     case 8:
2046       switch (mode)
2047         {
2048         case SFmode:
2049           REAL_VALUE_TO_TARGET_SINGLE (d, l);
2050           assemble_integer (GEN_INT (l), 4, align, 1);
2051           break;
2052         case DFmode:
2053           REAL_VALUE_TO_TARGET_DOUBLE (d, data);
2054           assemble_integer (GEN_INT (data[0]), 4, align, 1);
2055           assemble_integer (GEN_INT (data[1]), 4, nalign, 1);
2056           break;
2057         case XFmode:
2058           REAL_VALUE_TO_TARGET_LONG_DOUBLE (d, data);
2059           assemble_integer (GEN_INT (data[0]), 4, align, 1);
2060           assemble_integer (GEN_INT (data[1]), 4, nalign, 1);
2061           assemble_integer (GEN_INT (data[2]), 4, nalign, 1);
2062           break;
2063         case TFmode:
2064           REAL_VALUE_TO_TARGET_LONG_DOUBLE (d, data);
2065           assemble_integer (GEN_INT (data[0]), 4, align, 1);
2066           assemble_integer (GEN_INT (data[1]), 4, nalign, 1);
2067           assemble_integer (GEN_INT (data[2]), 4, nalign, 1);
2068           assemble_integer (GEN_INT (data[3]), 4, nalign, 1);
2069           break;
2070         default:
2071           abort ();
2072         }
2073       break;
2074
2075     case 16:
2076       switch (mode)
2077         {
2078         case HFmode:
2079           REAL_VALUE_TO_TARGET_SINGLE (d, l);
2080           assemble_integer (GEN_INT (l), 2, align, 1);
2081           break;
2082         case TQFmode:
2083           REAL_VALUE_TO_TARGET_DOUBLE (d, data);
2084           assemble_integer (GEN_INT (data[0]), 2, align, 1);
2085           assemble_integer (GEN_INT (data[1]), 1, nalign, 1);
2086           break;
2087         default:
2088           abort ();
2089         }
2090       break;
2091
2092     case 32:
2093       switch (mode)
2094         {
2095         case QFmode:
2096           REAL_VALUE_TO_TARGET_SINGLE (d, l);
2097           assemble_integer (GEN_INT (l), 1, align, 1);
2098           break;
2099         case HFmode:
2100           REAL_VALUE_TO_TARGET_DOUBLE (d, data);
2101           assemble_integer (GEN_INT (data[0]), 1, align, 1);
2102           assemble_integer (GEN_INT (data[1]), 1, nalign, 1);
2103           break;
2104         default:
2105           abort ();
2106         }
2107       break;
2108
2109     default:
2110       abort ();
2111     }
2112 }
2113 \f
2114 /* Here we combine duplicate floating constants to make
2115    CONST_DOUBLE rtx's, and force those out to memory when necessary.  */
2116
2117 /* Return a CONST_DOUBLE or CONST_INT for a value specified as a pair of ints.
2118    For an integer, I0 is the low-order word and I1 is the high-order word.
2119    For a real number, I0 is the word with the low address
2120    and I1 is the word with the high address.  */
2121
2122 rtx
2123 immed_double_const (i0, i1, mode)
2124      HOST_WIDE_INT i0, i1;
2125      enum machine_mode mode;
2126 {
2127   rtx r;
2128
2129   if (GET_MODE_CLASS (mode) == MODE_INT
2130       || GET_MODE_CLASS (mode) == MODE_PARTIAL_INT)
2131     {
2132       /* We clear out all bits that don't belong in MODE, unless they and our
2133          sign bit are all one.  So we get either a reasonable negative value
2134          or a reasonable unsigned value for this mode.  */
2135       int width = GET_MODE_BITSIZE (mode);
2136       if (width < HOST_BITS_PER_WIDE_INT
2137           && ((i0 & ((HOST_WIDE_INT) (-1) << (width - 1)))
2138               != ((HOST_WIDE_INT) (-1) << (width - 1))))
2139         i0 &= ((HOST_WIDE_INT) 1 << width) - 1, i1 = 0;
2140       else if (width == HOST_BITS_PER_WIDE_INT
2141                && ! (i1 == ~0 && i0 < 0))
2142         i1 = 0;
2143       else if (width > 2 * HOST_BITS_PER_WIDE_INT)
2144         /* We cannot represent this value as a constant.  */
2145         abort ();
2146
2147       /* If this would be an entire word for the target, but is not for
2148          the host, then sign-extend on the host so that the number will look
2149          the same way on the host that it would on the target.
2150
2151          For example, when building a 64 bit alpha hosted 32 bit sparc
2152          targeted compiler, then we want the 32 bit unsigned value -1 to be
2153          represented as a 64 bit value -1, and not as 0x00000000ffffffff.
2154          The later confuses the sparc backend.  */
2155
2156       if (width < HOST_BITS_PER_WIDE_INT
2157           && (i0 & ((HOST_WIDE_INT) 1 << (width - 1))))
2158         i0 |= ((HOST_WIDE_INT) (-1) << width);
2159
2160       /* If MODE fits within HOST_BITS_PER_WIDE_INT, always use a CONST_INT.
2161
2162          ??? Strictly speaking, this is wrong if we create a CONST_INT
2163          for a large unsigned constant with the size of MODE being
2164          HOST_BITS_PER_WIDE_INT and later try to interpret that constant in a
2165          wider mode.  In that case we will mis-interpret it as a negative
2166          number.
2167
2168          Unfortunately, the only alternative is to make a CONST_DOUBLE
2169          for any constant in any mode if it is an unsigned constant larger
2170          than the maximum signed integer in an int on the host.  However,
2171          doing this will break everyone that always expects to see a CONST_INT
2172          for SImode and smaller.
2173
2174          We have always been making CONST_INTs in this case, so nothing new
2175          is being broken.  */
2176
2177       if (width <= HOST_BITS_PER_WIDE_INT)
2178         i1 = (i0 < 0) ? ~(HOST_WIDE_INT) 0 : 0;
2179
2180       /* If this integer fits in one word, return a CONST_INT.  */
2181       if ((i1 == 0 && i0 >= 0)
2182           || (i1 == ~0 && i0 < 0))
2183         return GEN_INT (i0);
2184
2185       /* We use VOIDmode for integers.  */
2186       mode = VOIDmode;
2187     }
2188
2189   /* Search the chain for an existing CONST_DOUBLE with the right value.
2190      If one is found, return it.  */
2191   if (cfun != 0)
2192     for (r = const_double_chain; r; r = CONST_DOUBLE_CHAIN (r))
2193       if (CONST_DOUBLE_LOW (r) == i0 && CONST_DOUBLE_HIGH (r) == i1
2194           && GET_MODE (r) == mode)
2195         return r;
2196
2197   /* No; make a new one and add it to the chain.  */
2198   r = gen_rtx_CONST_DOUBLE (mode, i0, i1);
2199
2200   /* Don't touch const_double_chain if not inside any function.  */
2201   if (current_function_decl != 0)
2202     {
2203       CONST_DOUBLE_CHAIN (r) = const_double_chain;
2204       const_double_chain = r;
2205     }
2206
2207   return r;
2208 }
2209
2210 /* Return a CONST_DOUBLE for a specified `double' value
2211    and machine mode.  */
2212
2213 rtx
2214 immed_real_const_1 (d, mode)
2215      REAL_VALUE_TYPE d;
2216      enum machine_mode mode;
2217 {
2218   rtx r;
2219
2220   /* Detect special cases.  Check for NaN first, because some ports
2221      (specifically the i386) do not emit correct ieee-fp code by default, and
2222      thus will generate a core dump here if we pass a NaN to REAL_VALUES_EQUAL
2223      and if REAL_VALUES_EQUAL does a floating point comparison.  */
2224   if (! REAL_VALUE_ISNAN (d) && REAL_VALUES_IDENTICAL (dconst0, d))
2225     return CONST0_RTX (mode);
2226   else if (! REAL_VALUE_ISNAN (d) && REAL_VALUES_EQUAL (dconst1, d))
2227     return CONST1_RTX (mode);
2228   else if (! REAL_VALUE_ISNAN (d) && REAL_VALUES_EQUAL (dconst2, d))
2229     return CONST2_RTX (mode);
2230
2231   if (sizeof (REAL_VALUE_TYPE) == sizeof (HOST_WIDE_INT))
2232     return immed_double_const (d.r[0], 0, mode);
2233   if (sizeof (REAL_VALUE_TYPE) == 2 * sizeof (HOST_WIDE_INT))
2234     return immed_double_const (d.r[0], d.r[1], mode);
2235
2236   /* The rest of this function handles the case where
2237      a float value requires more than 2 ints of space.
2238      It will be deleted as dead code on machines that don't need it.  */
2239
2240   /* Search the chain for an existing CONST_DOUBLE with the right value.
2241      If one is found, return it.  */
2242   if (cfun != 0)
2243     for (r = const_double_chain; r; r = CONST_DOUBLE_CHAIN (r))
2244       if (! memcmp ((char *) &CONST_DOUBLE_LOW (r), (char *) &d, sizeof d)
2245           && GET_MODE (r) == mode)
2246         return r;
2247
2248   /* No; make a new one and add it to the chain.
2249
2250      We may be called by an optimizer which may be discarding any memory
2251      allocated during its processing (such as combine and loop).  However,
2252      we will be leaving this constant on the chain, so we cannot tolerate
2253      freed memory.  */
2254   r = rtx_alloc (CONST_DOUBLE);
2255   PUT_MODE (r, mode);
2256   memcpy ((char *) &CONST_DOUBLE_LOW (r), (char *) &d, sizeof d);
2257
2258   /* If we aren't inside a function, don't put r on the
2259      const_double_chain.  */
2260   if (current_function_decl != 0)
2261     {
2262       CONST_DOUBLE_CHAIN (r) = const_double_chain;
2263       const_double_chain = r;
2264     }
2265   else
2266     CONST_DOUBLE_CHAIN (r) = NULL_RTX;
2267
2268   return r;
2269 }
2270
2271 /* Return a CONST_DOUBLE rtx for a value specified by EXP,
2272    which must be a REAL_CST tree node.  */
2273
2274 rtx
2275 immed_real_const (exp)
2276      tree exp;
2277 {
2278   return immed_real_const_1 (TREE_REAL_CST (exp), TYPE_MODE (TREE_TYPE (exp)));
2279 }
2280
2281 /* At the end of a function, forget the memory-constants
2282    previously made for CONST_DOUBLEs.  Mark them as not on real_constant_chain.
2283    Also clear out real_constant_chain and clear out all the chain-pointers.  */
2284
2285 void
2286 clear_const_double_mem ()
2287 {
2288   rtx r, next;
2289
2290   for (r = const_double_chain; r; r = next)
2291     {
2292       next = CONST_DOUBLE_CHAIN (r);
2293       CONST_DOUBLE_CHAIN (r) = 0;
2294     }
2295   const_double_chain = 0;
2296 }
2297 \f
2298 /* Given an expression EXP with a constant value,
2299    reduce it to the sum of an assembler symbol and an integer.
2300    Store them both in the structure *VALUE.
2301    Abort if EXP does not reduce.  */
2302
2303 struct addr_const
2304 {
2305   rtx base;
2306   HOST_WIDE_INT offset;
2307 };
2308
2309 static void
2310 decode_addr_const (exp, value)
2311      tree exp;
2312      struct addr_const *value;
2313 {
2314   tree target = TREE_OPERAND (exp, 0);
2315   int offset = 0;
2316   rtx x;
2317
2318   while (1)
2319     {
2320       if (TREE_CODE (target) == COMPONENT_REF
2321           && host_integerp (byte_position (TREE_OPERAND (target, 1)), 0))
2322
2323         {
2324           offset += int_byte_position (TREE_OPERAND (target, 1));
2325           target = TREE_OPERAND (target, 0);
2326         }
2327       else if (TREE_CODE (target) == ARRAY_REF
2328                || TREE_CODE (target) == ARRAY_RANGE_REF)
2329         {
2330           offset += (tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (target)), 1)
2331                      * tree_low_cst (TREE_OPERAND (target, 1), 0));
2332           target = TREE_OPERAND (target, 0);
2333         }
2334       else
2335         break;
2336     }
2337
2338   switch (TREE_CODE (target))
2339     {
2340     case VAR_DECL:
2341     case FUNCTION_DECL:
2342       x = DECL_RTL (target);
2343       break;
2344
2345     case LABEL_DECL:
2346       x = gen_rtx_MEM (FUNCTION_MODE,
2347                        gen_rtx_LABEL_REF (VOIDmode,
2348                                           label_rtx (TREE_OPERAND (exp, 0))));
2349       break;
2350
2351     case REAL_CST:
2352     case STRING_CST:
2353     case COMPLEX_CST:
2354     case CONSTRUCTOR:
2355     case INTEGER_CST:
2356       /* This constant should have been output already, but we can't simply
2357          use TREE_CST_RTL since INTEGER_CST doesn't have one.  */
2358       x = output_constant_def (target, 1);
2359       break;
2360
2361     default:
2362       abort ();
2363     }
2364
2365   if (GET_CODE (x) != MEM)
2366     abort ();
2367   x = XEXP (x, 0);
2368
2369   value->base = x;
2370   value->offset = offset;
2371 }
2372 \f
2373 /* We do RTX_UNSPEC + XINT (blah), so nothing can go after RTX_UNSPEC.  */
2374 enum kind { RTX_UNKNOWN, RTX_DOUBLE, RTX_INT, RTX_VECTOR, RTX_UNSPEC };
2375 struct rtx_const
2376 {
2377   ENUM_BITFIELD(kind) kind : 16;
2378   ENUM_BITFIELD(machine_mode) mode : 16;
2379   union {
2380     REAL_VALUE_TYPE du;
2381     struct addr_const addr;
2382     struct {HOST_WIDE_INT high, low;} di;
2383
2384     /* The max vector size we have is 8 wide.  This should be enough.  */
2385     HOST_WIDE_INT veclo[16];
2386     HOST_WIDE_INT vechi[16];
2387   } un;
2388 };
2389
2390 /* Uniquize all constants that appear in memory.
2391    Each constant in memory thus far output is recorded
2392    in `const_hash_table' with a `struct constant_descriptor'
2393    that contains a polish representation of the value of
2394    the constant.
2395
2396    We cannot store the trees in the hash table
2397    because the trees may be temporary.  */
2398
2399 struct constant_descriptor
2400 {
2401   struct constant_descriptor *next;
2402   const char *label;
2403   rtx rtl;
2404   /* Make sure the data is reasonably aligned.  */
2405   union
2406   {
2407     unsigned char contents[1];
2408 #ifdef HAVE_LONG_DOUBLE
2409     long double d;
2410 #else
2411     double d;
2412 #endif
2413   } u;
2414 };
2415
2416 #define HASHBITS 30
2417 #define MAX_HASH_TABLE 1009
2418 static struct constant_descriptor *const_hash_table[MAX_HASH_TABLE];
2419
2420 /* We maintain a hash table of STRING_CST values.  Unless we are asked to force
2421    out a string constant, we defer output of the constants until we know
2422    they are actually used.  This will be if something takes its address or if
2423    there is a usage of the string in the RTL of a function.  */
2424
2425 #define STRHASH(x) ((hashval_t) ((long) (x) >> 3))
2426
2427 struct deferred_string
2428 {
2429   const char *label;
2430   tree exp;
2431   int labelno;
2432 };
2433
2434 static htab_t const_str_htab;
2435
2436 /* Mark a const_hash_table descriptor for GC.  */
2437
2438 static void
2439 mark_const_hash_entry (ptr)
2440      void *ptr;
2441 {
2442   struct constant_descriptor *desc = * (struct constant_descriptor **) ptr;
2443
2444   while (desc)
2445     {
2446       ggc_mark_rtx (desc->rtl);
2447       desc = desc->next;
2448     }
2449 }
2450
2451 /* Mark the hash-table element X (which is really a pointer to an
2452    struct deferred_string *).  */
2453
2454 static int
2455 mark_const_str_htab_1 (x, data)
2456      void **x;
2457      void *data ATTRIBUTE_UNUSED;
2458 {
2459   ggc_mark_tree (((struct deferred_string *) *x)->exp);
2460   return 1;
2461 }
2462
2463 /* Mark a const_str_htab for GC.  */
2464
2465 static void
2466 mark_const_str_htab (htab)
2467      void *htab;
2468 {
2469   htab_traverse (*((htab_t *) htab), mark_const_str_htab_1, NULL);
2470 }
2471
2472 /* Returns a hash code for X (which is a really a
2473    struct deferred_string *).  */
2474
2475 static hashval_t
2476 const_str_htab_hash (x)
2477      const void *x;
2478 {
2479   return STRHASH (((const struct deferred_string *) x)->label);
2480 }
2481
2482 /* Returns non-zero if the value represented by X (which is really a
2483    struct deferred_string *) is the same as that given by Y
2484    (which is really a char *).  */
2485
2486 static int
2487 const_str_htab_eq (x, y)
2488      const void *x;
2489      const void *y;
2490 {
2491   return (((const struct deferred_string *) x)->label == (const char *) y);
2492 }
2493
2494 /* Delete the hash table entry dfsp.  */
2495
2496 static void
2497 const_str_htab_del (dfsp)
2498     void *dfsp;
2499 {
2500   free (dfsp);
2501 }
2502
2503 /* Compute a hash code for a constant expression.  */
2504
2505 static int
2506 const_hash (exp)
2507      tree exp;
2508 {
2509   const char *p;
2510   int len, hi, i;
2511   enum tree_code code = TREE_CODE (exp);
2512
2513   /* Either set P and LEN to the address and len of something to hash and
2514      exit the switch or return a value.  */
2515
2516   switch (code)
2517     {
2518     case INTEGER_CST:
2519       p = (char *) &TREE_INT_CST (exp);
2520       len = sizeof TREE_INT_CST (exp);
2521       break;
2522
2523     case REAL_CST:
2524       p = (char *) &TREE_REAL_CST (exp);
2525       len = sizeof TREE_REAL_CST (exp);
2526       break;
2527
2528     case STRING_CST:
2529       p = TREE_STRING_POINTER (exp);
2530       len = TREE_STRING_LENGTH (exp);
2531       break;
2532
2533     case COMPLEX_CST:
2534       return (const_hash (TREE_REALPART (exp)) * 5
2535               + const_hash (TREE_IMAGPART (exp)));
2536
2537     case CONSTRUCTOR:
2538       if (TREE_CODE (TREE_TYPE (exp)) == SET_TYPE)
2539         {
2540           char *tmp;
2541
2542           len = int_size_in_bytes (TREE_TYPE (exp));
2543           tmp = (char *) alloca (len);
2544           get_set_constructor_bytes (exp, (unsigned char *) tmp, len);
2545           p = tmp;
2546           break;
2547         }
2548       else
2549         {
2550           tree link;
2551
2552           /* For record type, include the type in the hashing.
2553              We do not do so for array types
2554              because (1) the sizes of the elements are sufficient
2555              and (2) distinct array types can have the same constructor.
2556              Instead, we include the array size because the constructor could
2557              be shorter.  */
2558           if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
2559             hi = ((unsigned long) TREE_TYPE (exp) & ((1 << HASHBITS) - 1))
2560               % MAX_HASH_TABLE;
2561           else
2562             hi = ((5 + int_size_in_bytes (TREE_TYPE (exp)))
2563                   & ((1 << HASHBITS) - 1)) % MAX_HASH_TABLE;
2564
2565           for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
2566             if (TREE_VALUE (link))
2567               hi
2568                 = (hi * 603 + const_hash (TREE_VALUE (link))) % MAX_HASH_TABLE;
2569
2570           return hi;
2571         }
2572
2573     case ADDR_EXPR:
2574       {
2575         struct addr_const value;
2576
2577         decode_addr_const (exp, &value);
2578         if (GET_CODE (value.base) == SYMBOL_REF)
2579           {
2580             /* Don't hash the address of the SYMBOL_REF;
2581                only use the offset and the symbol name.  */
2582             hi = value.offset;
2583             p = XSTR (value.base, 0);
2584             for (i = 0; p[i] != 0; i++)
2585               hi = ((hi * 613) + (unsigned) (p[i]));
2586           }
2587         else if (GET_CODE (value.base) == LABEL_REF)
2588           hi = value.offset + CODE_LABEL_NUMBER (XEXP (value.base, 0)) * 13;
2589         else
2590           abort ();
2591
2592         hi &= (1 << HASHBITS) - 1;
2593         hi %= MAX_HASH_TABLE;
2594       }
2595       return hi;
2596
2597     case PLUS_EXPR:
2598     case MINUS_EXPR:
2599       return (const_hash (TREE_OPERAND (exp, 0)) * 9
2600               + const_hash (TREE_OPERAND (exp, 1)));
2601
2602     case NOP_EXPR:
2603     case CONVERT_EXPR:
2604     case NON_LVALUE_EXPR:
2605       return const_hash (TREE_OPERAND (exp, 0)) * 7 + 2;
2606
2607     default:
2608       /* A language specific constant. Just hash the code.  */
2609       return (int) code % MAX_HASH_TABLE;
2610     }
2611
2612   /* Compute hashing function */
2613   hi = len;
2614   for (i = 0; i < len; i++)
2615     hi = ((hi * 613) + (unsigned) (p[i]));
2616
2617   hi &= (1 << HASHBITS) - 1;
2618   hi %= MAX_HASH_TABLE;
2619   return hi;
2620 }
2621 \f
2622 /* Compare a constant expression EXP with a constant-descriptor DESC.
2623    Return 1 if DESC describes a constant with the same value as EXP.  */
2624
2625 static int
2626 compare_constant (exp, desc)
2627      tree exp;
2628      struct constant_descriptor *desc;
2629 {
2630   return 0 != compare_constant_1 (exp, desc->u.contents);
2631 }
2632
2633 /* Compare constant expression EXP with a substring P of a constant descriptor.
2634    If they match, return a pointer to the end of the substring matched.
2635    If they do not match, return 0.
2636
2637    Since descriptors are written in polish prefix notation,
2638    this function can be used recursively to test one operand of EXP
2639    against a subdescriptor, and if it succeeds it returns the
2640    address of the subdescriptor for the next operand.  */
2641
2642 static const unsigned char *
2643 compare_constant_1 (exp, p)
2644      tree exp;
2645      const unsigned char *p;
2646 {
2647   const unsigned char *strp;
2648   int len;
2649   enum tree_code code = TREE_CODE (exp);
2650
2651   if (code != (enum tree_code) *p++)
2652     return 0;
2653
2654   /* Either set STRP, P and LEN to pointers and length to compare and exit the
2655      switch, or return the result of the comparison.  */
2656
2657   switch (code)
2658     {
2659     case INTEGER_CST:
2660       /* Integer constants are the same only if the same width of type.  */
2661       if (*p++ != TYPE_PRECISION (TREE_TYPE (exp)))
2662         return 0;
2663
2664       strp = (unsigned char *) &TREE_INT_CST (exp);
2665       len = sizeof TREE_INT_CST (exp);
2666       break;
2667
2668     case REAL_CST:
2669       /* Real constants are the same only if the same width of type.  */
2670       if (*p++ != TYPE_PRECISION (TREE_TYPE (exp)))
2671         return 0;
2672
2673       strp = (unsigned char *) &TREE_REAL_CST (exp);
2674       len = sizeof TREE_REAL_CST (exp);
2675       break;
2676
2677     case STRING_CST:
2678       if (flag_writable_strings)
2679         return 0;
2680
2681       if ((enum machine_mode) *p++ != TYPE_MODE (TREE_TYPE (exp)))
2682         return 0;
2683
2684       strp = (const unsigned char *) TREE_STRING_POINTER (exp);
2685       len = TREE_STRING_LENGTH (exp);
2686       if (memcmp ((char *) &TREE_STRING_LENGTH (exp), p,
2687                   sizeof TREE_STRING_LENGTH (exp)))
2688         return 0;
2689
2690       p += sizeof TREE_STRING_LENGTH (exp);
2691       break;
2692
2693     case COMPLEX_CST:
2694       p = compare_constant_1 (TREE_REALPART (exp), p);
2695       if (p == 0)
2696         return 0;
2697
2698       return compare_constant_1 (TREE_IMAGPART (exp), p);
2699
2700     case CONSTRUCTOR:
2701       if (TREE_CODE (TREE_TYPE (exp)) == SET_TYPE)
2702         {
2703           int xlen = len = int_size_in_bytes (TREE_TYPE (exp));
2704           unsigned char *tmp = (unsigned char *) alloca (len);
2705
2706           get_set_constructor_bytes (exp, tmp, len);
2707           strp = (unsigned char *) tmp;
2708           if (memcmp ((char *) &xlen, p, sizeof xlen))
2709             return 0;
2710
2711           p += sizeof xlen;
2712           break;
2713         }
2714       else
2715         {
2716           tree link;
2717           int length = list_length (CONSTRUCTOR_ELTS (exp));
2718           tree type;
2719           enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
2720           int have_purpose = 0;
2721
2722           for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
2723             if (TREE_PURPOSE (link))
2724               have_purpose = 1;
2725
2726           if (memcmp ((char *) &length, p, sizeof length))
2727             return 0;
2728
2729           p += sizeof length;
2730
2731           /* For record constructors, insist that the types match.
2732              For arrays, just verify both constructors are for arrays.
2733              Then insist that either both or none have any TREE_PURPOSE
2734              values.  */
2735           if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
2736             type = TREE_TYPE (exp);
2737           else
2738             type = 0;
2739
2740           if (memcmp ((char *) &type, p, sizeof type))
2741             return 0;
2742
2743           if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
2744             {
2745               if (memcmp ((char *) &mode, p, sizeof mode))
2746                 return 0;
2747
2748               p += sizeof mode;
2749             }
2750
2751           p += sizeof type;
2752
2753           if (memcmp ((char *) &have_purpose, p, sizeof have_purpose))
2754             return 0;
2755
2756           p += sizeof have_purpose;
2757
2758           /* For arrays, insist that the size in bytes match.  */
2759           if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
2760             {
2761               HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (exp));
2762
2763               if (memcmp ((char *) &size, p, sizeof size))
2764                 return 0;
2765
2766               p += sizeof size;
2767             }
2768
2769           for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
2770             {
2771               if (TREE_VALUE (link))
2772                 {
2773                   if ((p = compare_constant_1 (TREE_VALUE (link), p)) == 0)
2774                     return 0;
2775                 }
2776               else
2777                 {
2778                   tree zero = 0;
2779
2780                   if (memcmp ((char *) &zero, p, sizeof zero))
2781                     return 0;
2782
2783                   p += sizeof zero;
2784                 }
2785
2786               if (TREE_PURPOSE (link)
2787                   && TREE_CODE (TREE_PURPOSE (link)) == FIELD_DECL)
2788                 {
2789                   if (memcmp ((char *) &TREE_PURPOSE (link), p,
2790                             sizeof TREE_PURPOSE (link)))
2791                     return 0;
2792
2793                   p += sizeof TREE_PURPOSE (link);
2794                 }
2795               else if (TREE_PURPOSE (link))
2796                 {
2797                   if ((p = compare_constant_1 (TREE_PURPOSE (link), p)) == 0)
2798                     return 0;
2799                 }
2800               else if (have_purpose)
2801                 {
2802                   int zero = 0;
2803
2804                   if (memcmp ((char *) &zero, p, sizeof zero))
2805                     return 0;
2806
2807                   p += sizeof zero;
2808                 }
2809             }
2810
2811           return p;
2812         }
2813
2814     case ADDR_EXPR:
2815       {
2816         struct addr_const value;
2817
2818         decode_addr_const (exp, &value);
2819         strp = (unsigned char *) &value.offset;
2820         len = sizeof value.offset;
2821         /* Compare the offset.  */
2822         while (--len >= 0)
2823           if (*p++ != *strp++)
2824             return 0;
2825
2826         /* Compare symbol name.  */
2827         strp = (const unsigned char *) XSTR (value.base, 0);
2828         len = strlen ((const char *) strp) + 1;
2829       }
2830       break;
2831
2832     case PLUS_EXPR:
2833     case MINUS_EXPR:
2834     case RANGE_EXPR:
2835       p = compare_constant_1 (TREE_OPERAND (exp, 0), p);
2836       if (p == 0)
2837         return 0;
2838
2839       return compare_constant_1 (TREE_OPERAND (exp, 1), p);
2840
2841     case NOP_EXPR:
2842     case CONVERT_EXPR:
2843     case NON_LVALUE_EXPR:
2844       return compare_constant_1 (TREE_OPERAND (exp, 0), p);
2845
2846     default:
2847       {
2848         tree new = (*lang_hooks.expand_constant) (exp);
2849
2850         if (new != exp)
2851           return compare_constant_1 (new, p);
2852         else
2853           return 0;
2854       }
2855     }
2856
2857   /* Compare constant contents.  */
2858   while (--len >= 0)
2859     if (*p++ != *strp++)
2860       return 0;
2861
2862   return p;
2863 }
2864 \f
2865 /* Construct a constant descriptor for the expression EXP.
2866    It is up to the caller to enter the descriptor in the hash table.  */
2867
2868 static struct constant_descriptor *
2869 record_constant (exp)
2870      tree exp;
2871 {
2872   struct constant_descriptor *next = 0;
2873   char *label = 0;
2874   rtx rtl = 0;
2875   int pad;
2876
2877   /* Make a struct constant_descriptor.  The first three pointers will
2878      be filled in later.  Here we just leave space for them.  */
2879
2880   obstack_grow (&permanent_obstack, (char *) &next, sizeof next);
2881   obstack_grow (&permanent_obstack, (char *) &label, sizeof label);
2882   obstack_grow (&permanent_obstack, (char *) &rtl, sizeof rtl);
2883
2884   /* Align the descriptor for the data payload.  */
2885   pad = (offsetof (struct constant_descriptor, u)
2886          - offsetof(struct constant_descriptor, rtl)
2887          - sizeof(next->rtl));
2888   if (pad > 0)
2889     obstack_blank (&permanent_obstack, pad);
2890
2891   record_constant_1 (exp);
2892   return (struct constant_descriptor *) obstack_finish (&permanent_obstack);
2893 }
2894
2895 /* Add a description of constant expression EXP
2896    to the object growing in `permanent_obstack'.
2897    No need to return its address; the caller will get that
2898    from the obstack when the object is complete.  */
2899
2900 static void
2901 record_constant_1 (exp)
2902      tree exp;
2903 {
2904   const unsigned char *strp;
2905   int len;
2906   enum tree_code code = TREE_CODE (exp);
2907
2908   obstack_1grow (&permanent_obstack, (unsigned int) code);
2909
2910   switch (code)
2911     {
2912     case INTEGER_CST:
2913       obstack_1grow (&permanent_obstack, TYPE_PRECISION (TREE_TYPE (exp)));
2914       strp = (unsigned char *) &TREE_INT_CST (exp);
2915       len = sizeof TREE_INT_CST (exp);
2916       break;
2917
2918     case REAL_CST:
2919       obstack_1grow (&permanent_obstack, TYPE_PRECISION (TREE_TYPE (exp)));
2920       strp = (unsigned char *) &TREE_REAL_CST (exp);
2921       len = sizeof TREE_REAL_CST (exp);
2922       break;
2923
2924     case STRING_CST:
2925       if (flag_writable_strings)
2926         return;
2927
2928       obstack_1grow (&permanent_obstack, TYPE_MODE (TREE_TYPE (exp)));
2929       strp = (const unsigned char *) TREE_STRING_POINTER (exp);
2930       len = TREE_STRING_LENGTH (exp);
2931       obstack_grow (&permanent_obstack, (char *) &TREE_STRING_LENGTH (exp),
2932                     sizeof TREE_STRING_LENGTH (exp));
2933       break;
2934
2935     case COMPLEX_CST:
2936       record_constant_1 (TREE_REALPART (exp));
2937       record_constant_1 (TREE_IMAGPART (exp));
2938       return;
2939
2940     case CONSTRUCTOR:
2941       if (TREE_CODE (TREE_TYPE (exp)) == SET_TYPE)
2942         {
2943           int nbytes = int_size_in_bytes (TREE_TYPE (exp));
2944           obstack_grow (&permanent_obstack, &nbytes, sizeof (nbytes));
2945           obstack_blank (&permanent_obstack, nbytes);
2946           get_set_constructor_bytes
2947             (exp, (unsigned char *) permanent_obstack.next_free-nbytes,
2948              nbytes);
2949           return;
2950         }
2951       else
2952         {
2953           tree link;
2954           int length = list_length (CONSTRUCTOR_ELTS (exp));
2955           enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
2956           tree type;
2957           int have_purpose = 0;
2958
2959           for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
2960             if (TREE_PURPOSE (link))
2961               have_purpose = 1;
2962
2963           obstack_grow (&permanent_obstack, (char *) &length, sizeof length);
2964
2965           /* For record constructors, insist that the types match.
2966              For arrays, just verify both constructors are for arrays
2967              of the same mode.  Then insist that either both or none
2968              have any TREE_PURPOSE values.  */
2969           if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
2970             type = TREE_TYPE (exp);
2971           else
2972             type = 0;
2973
2974           obstack_grow (&permanent_obstack, (char *) &type, sizeof type);
2975           if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
2976             obstack_grow (&permanent_obstack, &mode, sizeof mode);
2977
2978           obstack_grow (&permanent_obstack, (char *) &have_purpose,
2979                         sizeof have_purpose);
2980
2981           /* For arrays, insist that the size in bytes match.  */
2982           if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
2983             {
2984               HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (exp));
2985               obstack_grow (&permanent_obstack, (char *) &size, sizeof size);
2986             }
2987
2988           for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
2989             {
2990               if (TREE_VALUE (link))
2991                 record_constant_1 (TREE_VALUE (link));
2992               else
2993                 {
2994                   tree zero = 0;
2995
2996                   obstack_grow (&permanent_obstack,
2997                                 (char *) &zero, sizeof zero);
2998                 }
2999
3000               if (TREE_PURPOSE (link)
3001                   && TREE_CODE (TREE_PURPOSE (link)) == FIELD_DECL)
3002                 obstack_grow (&permanent_obstack,
3003                               (char *) &TREE_PURPOSE (link),
3004                               sizeof TREE_PURPOSE (link));
3005               else if (TREE_PURPOSE (link))
3006                 record_constant_1 (TREE_PURPOSE (link));
3007               else if (have_purpose)
3008                 {
3009                   int zero = 0;
3010
3011                   obstack_grow (&permanent_obstack,
3012                                 (char *) &zero, sizeof zero);
3013                 }
3014             }
3015         }
3016       return;
3017
3018     case ADDR_EXPR:
3019       {
3020         struct addr_const value;
3021
3022         decode_addr_const (exp, &value);
3023         /* Record the offset.  */
3024         obstack_grow (&permanent_obstack,
3025                       (char *) &value.offset, sizeof value.offset);
3026
3027         switch (GET_CODE (value.base))
3028           {
3029           case SYMBOL_REF:
3030             /* Record the symbol name.  */
3031             obstack_grow (&permanent_obstack, XSTR (value.base, 0),
3032                           strlen (XSTR (value.base, 0)) + 1);
3033             break;
3034           case LABEL_REF:
3035             /* Record the address of the CODE_LABEL.  It may not have
3036                been emitted yet, so it's UID may be zero.  But pointer
3037                identity is good enough.  */
3038             obstack_grow (&permanent_obstack, &XEXP (value.base, 0),
3039                           sizeof (rtx));
3040             break;
3041           default:
3042             abort ();
3043           }
3044       }
3045       return;
3046
3047     case PLUS_EXPR:
3048     case MINUS_EXPR:
3049     case RANGE_EXPR:
3050       record_constant_1 (TREE_OPERAND (exp, 0));
3051       record_constant_1 (TREE_OPERAND (exp, 1));
3052       return;
3053
3054     case NOP_EXPR:
3055     case CONVERT_EXPR:
3056     case NON_LVALUE_EXPR:
3057       record_constant_1 (TREE_OPERAND (exp, 0));
3058       return;
3059
3060     default:
3061       {
3062         tree new = (*lang_hooks.expand_constant) (exp);
3063
3064         if (new != exp)
3065           record_constant_1 (new);
3066         return;
3067       }
3068     }
3069
3070   /* Record constant contents.  */
3071   obstack_grow (&permanent_obstack, strp, len);
3072 }
3073 \f
3074 /* Record a list of constant expressions that were passed to
3075    output_constant_def but that could not be output right away.  */
3076
3077 struct deferred_constant
3078 {
3079   struct deferred_constant *next;
3080   tree exp;
3081   int reloc;
3082   int labelno;
3083 };
3084
3085 static struct deferred_constant *deferred_constants;
3086
3087 /* Another list of constants which should be output after the
3088    function.  */
3089 static struct deferred_constant *after_function_constants;
3090
3091 /* Nonzero means defer output of addressed subconstants
3092    (i.e., those for which output_constant_def is called.)  */
3093 static int defer_addressed_constants_flag;
3094
3095 /* Start deferring output of subconstants.  */
3096
3097 void
3098 defer_addressed_constants ()
3099 {
3100   defer_addressed_constants_flag++;
3101 }
3102
3103 /* Stop deferring output of subconstants,
3104    and output now all those that have been deferred.  */
3105
3106 void
3107 output_deferred_addressed_constants ()
3108 {
3109   struct deferred_constant *p, *next;
3110
3111   defer_addressed_constants_flag--;
3112
3113   if (defer_addressed_constants_flag > 0)
3114     return;
3115
3116   for (p = deferred_constants; p; p = next)
3117     {
3118       output_constant_def_contents (p->exp, p->reloc, p->labelno);
3119       next = p->next;
3120       free (p);
3121     }
3122
3123   deferred_constants = 0;
3124 }
3125
3126 /* Output any constants which should appear after a function.  */
3127
3128 static void
3129 output_after_function_constants ()
3130 {
3131   struct deferred_constant *p, *next;
3132
3133   for (p = after_function_constants; p; p = next)
3134     {
3135       output_constant_def_contents (p->exp, p->reloc, p->labelno);
3136       next = p->next;
3137       free (p);
3138     }
3139
3140   after_function_constants = 0;
3141 }
3142
3143 /* Make a copy of the whole tree structure for a constant.
3144    This handles the same types of nodes that compare_constant
3145    and record_constant handle.  */
3146
3147 static tree
3148 copy_constant (exp)
3149      tree exp;
3150 {
3151   switch (TREE_CODE (exp))
3152     {
3153     case ADDR_EXPR:
3154       /* For ADDR_EXPR, we do not want to copy the decl whose address
3155          is requested.  We do want to copy constants though.  */
3156       if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 0))) == 'c')
3157         return build1 (TREE_CODE (exp), TREE_TYPE (exp),
3158                        copy_constant (TREE_OPERAND (exp, 0)));
3159       else
3160         return copy_node (exp);
3161
3162     case INTEGER_CST:
3163     case REAL_CST:
3164     case STRING_CST:
3165       return copy_node (exp);
3166
3167     case COMPLEX_CST:
3168       return build_complex (TREE_TYPE (exp),
3169                             copy_constant (TREE_REALPART (exp)),
3170                             copy_constant (TREE_IMAGPART (exp)));
3171
3172     case PLUS_EXPR:
3173     case MINUS_EXPR:
3174       return build (TREE_CODE (exp), TREE_TYPE (exp),
3175                     copy_constant (TREE_OPERAND (exp, 0)),
3176                     copy_constant (TREE_OPERAND (exp, 1)));
3177
3178     case NOP_EXPR:
3179     case CONVERT_EXPR:
3180     case NON_LVALUE_EXPR:
3181       return build1 (TREE_CODE (exp), TREE_TYPE (exp),
3182                      copy_constant (TREE_OPERAND (exp, 0)));
3183
3184     case CONSTRUCTOR:
3185       {
3186         tree copy = copy_node (exp);
3187         tree list = copy_list (CONSTRUCTOR_ELTS (exp));
3188         tree tail;
3189
3190         CONSTRUCTOR_ELTS (copy) = list;
3191         for (tail = list; tail; tail = TREE_CHAIN (tail))
3192           TREE_VALUE (tail) = copy_constant (TREE_VALUE (tail));
3193         if (TREE_CODE (TREE_TYPE (exp)) == SET_TYPE)
3194           for (tail = list; tail; tail = TREE_CHAIN (tail))
3195             TREE_PURPOSE (tail) = copy_constant (TREE_PURPOSE (tail));
3196
3197         return copy;
3198       }
3199
3200     default:
3201       abort ();
3202     }
3203 }
3204 \f
3205 /* Return an rtx representing a reference to constant data in memory
3206    for the constant expression EXP.
3207
3208    If assembler code for such a constant has already been output,
3209    return an rtx to refer to it.
3210    Otherwise, output such a constant in memory (or defer it for later)
3211    and generate an rtx for it.
3212
3213    If DEFER is non-zero, the output of string constants can be deferred
3214    and output only if referenced in the function after all optimizations.
3215
3216    The TREE_CST_RTL of EXP is set up to point to that rtx.
3217    The const_hash_table records which constants already have label strings.  */
3218
3219 rtx
3220 output_constant_def (exp, defer)
3221      tree exp;
3222      int defer;
3223 {
3224   int hash;
3225   struct constant_descriptor *desc;
3226   struct deferred_string **defstr;
3227   char label[256];
3228   int reloc;
3229   int found = 1;
3230   int after_function = 0;
3231   int labelno = -1;
3232   rtx rtl;
3233
3234   /* We can't just use the saved RTL if this is a defererred string constant
3235      and we are not to defer anymode.  */
3236   if (TREE_CODE (exp) != INTEGER_CST && TREE_CST_RTL (exp)
3237       && (defer || !STRING_POOL_ADDRESS_P (XEXP (TREE_CST_RTL (exp), 0))))
3238     return TREE_CST_RTL (exp);
3239
3240   /* Make sure any other constants whose addresses appear in EXP
3241      are assigned label numbers.  */
3242
3243   reloc = output_addressed_constants (exp);
3244
3245   /* Compute hash code of EXP.  Search the descriptors for that hash code
3246      to see if any of them describes EXP.  If yes, the descriptor records
3247      the label number already assigned.  */
3248
3249   hash = const_hash (exp) % MAX_HASH_TABLE;
3250
3251   for (desc = const_hash_table[hash]; desc; desc = desc->next)
3252     if (compare_constant (exp, desc))
3253       break;
3254
3255   if (desc == 0)
3256     {
3257       /* No constant equal to EXP is known to have been output.
3258          Make a constant descriptor to enter EXP in the hash table.
3259          Assign the label number and record it in the descriptor for
3260          future calls to this function to find.  */
3261
3262       /* Create a string containing the label name, in LABEL.  */
3263       labelno = const_labelno++;
3264       ASM_GENERATE_INTERNAL_LABEL (label, "LC", labelno);
3265
3266       desc = record_constant (exp);
3267       desc->next = const_hash_table[hash];
3268       desc->label = ggc_strdup (label);
3269       const_hash_table[hash] = desc;
3270
3271       /* We have a symbol name; construct the SYMBOL_REF and the MEM.  */
3272       rtl = desc->rtl
3273         = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (exp)),
3274                        gen_rtx_SYMBOL_REF (Pmode, desc->label));
3275
3276       set_mem_attributes (rtl, exp, 1);
3277       set_mem_alias_set (rtl, 0);
3278       set_mem_alias_set (rtl, const_alias_set);
3279
3280       found = 0;
3281     }
3282   else
3283     rtl = desc->rtl;
3284
3285   if (TREE_CODE (exp) != INTEGER_CST)
3286     TREE_CST_RTL (exp) = rtl;
3287
3288   /* Optionally set flags or add text to the name to record information
3289      such as that it is a function name.  If the name is changed, the macro
3290      ASM_OUTPUT_LABELREF will have to know how to strip this information.  */
3291 #ifdef ENCODE_SECTION_INFO
3292   /* A previously-processed constant would already have section info
3293      encoded in it.  */
3294   if (! found)
3295     {
3296       if (TREE_CODE (exp) == INTEGER_CST)
3297         ENCODE_SECTION_INFO (exp, true);
3298
3299       desc->rtl = rtl;
3300       desc->label = XSTR (XEXP (desc->rtl, 0), 0);
3301     }
3302 #endif
3303
3304 #ifdef CONSTANT_AFTER_FUNCTION_P
3305   if (current_function_decl != 0
3306       && CONSTANT_AFTER_FUNCTION_P (exp))
3307     after_function = 1;
3308 #endif
3309
3310   if (found
3311       && STRING_POOL_ADDRESS_P (XEXP (rtl, 0))
3312       && (!defer || defer_addressed_constants_flag || after_function))
3313     {
3314       defstr = (struct deferred_string **)
3315         htab_find_slot_with_hash (const_str_htab, desc->label,
3316                                   STRHASH (desc->label), NO_INSERT);
3317       if (defstr)
3318         {
3319           /* If the string is currently deferred but we need to output it now,
3320              remove it from deferred string hash table.  */
3321           found = 0;
3322           labelno = (*defstr)->labelno;
3323           STRING_POOL_ADDRESS_P (XEXP (rtl, 0)) = 0;
3324           htab_clear_slot (const_str_htab, (void **) defstr);
3325         }
3326     }
3327
3328   /* If this is the first time we've seen this particular constant,
3329      output it (or defer its output for later).  */
3330   if (! found)
3331     {
3332       if (defer_addressed_constants_flag || after_function)
3333         {
3334           struct deferred_constant *p
3335             = (struct deferred_constant *)
3336               xmalloc (sizeof (struct deferred_constant));
3337
3338           p->exp = copy_constant (exp);
3339           p->reloc = reloc;
3340           p->labelno = labelno;
3341           if (after_function)
3342             {
3343               p->next = after_function_constants;
3344               after_function_constants = p;
3345             }
3346           else
3347             {
3348               p->next = deferred_constants;
3349               deferred_constants = p;
3350             }
3351         }
3352       else
3353         {
3354           /* Do no output if -fsyntax-only.  */
3355           if (! flag_syntax_only)
3356             {
3357               if (TREE_CODE (exp) != STRING_CST
3358                   || !defer
3359                   || flag_writable_strings
3360                   || (defstr = (struct deferred_string **)
3361                                htab_find_slot_with_hash (const_str_htab,
3362                                                          desc->label,
3363                                                          STRHASH (desc->label),
3364                                                          INSERT)) == NULL)
3365                 output_constant_def_contents (exp, reloc, labelno);
3366               else
3367                 {
3368                   struct deferred_string *p;
3369
3370                   p = (struct deferred_string *)
3371                       xmalloc (sizeof (struct deferred_string));
3372
3373                   p->exp = copy_constant (exp);
3374                   p->label = desc->label;
3375                   p->labelno = labelno;
3376                   *defstr = p;
3377                   STRING_POOL_ADDRESS_P (XEXP (rtl, 0)) = 1;
3378                 }
3379             }
3380         }
3381     }
3382
3383   return rtl;
3384 }
3385
3386 /* Now output assembler code to define the label for EXP,
3387    and follow it with the data of EXP.  */
3388
3389 static void
3390 output_constant_def_contents (exp, reloc, labelno)
3391      tree exp;
3392      int reloc;
3393      int labelno;
3394 {
3395   int align;
3396
3397   /* Align the location counter as required by EXP's data type.  */
3398   align = TYPE_ALIGN (TREE_TYPE (exp));
3399 #ifdef CONSTANT_ALIGNMENT
3400   align = CONSTANT_ALIGNMENT (exp, align);
3401 #endif
3402
3403   if (IN_NAMED_SECTION (exp))
3404     named_section (exp, NULL, reloc);
3405   else
3406     {
3407       /* First switch to text section, except for writable strings.  */
3408 #ifdef SELECT_SECTION
3409       SELECT_SECTION (exp, reloc, align);
3410 #else
3411       if (((TREE_CODE (exp) == STRING_CST) && flag_writable_strings)
3412           || (flag_pic && reloc))
3413         data_section ();
3414       else
3415         readonly_data_section ();
3416 #endif
3417     }
3418
3419   if (align > BITS_PER_UNIT)
3420     {
3421       ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
3422     }
3423
3424   /* Output the label itself.  */
3425   ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LC", labelno);
3426
3427   /* Output the value of EXP.  */
3428   output_constant (exp,
3429                    (TREE_CODE (exp) == STRING_CST
3430                     ? MAX (TREE_STRING_LENGTH (exp),
3431                            int_size_in_bytes (TREE_TYPE (exp)))
3432                     : int_size_in_bytes (TREE_TYPE (exp))),
3433                    align);
3434
3435 }
3436 \f
3437 /* Structure to represent sufficient information about a constant so that
3438    it can be output when the constant pool is output, so that function
3439    integration can be done, and to simplify handling on machines that reference
3440    constant pool as base+displacement.  */
3441
3442 struct pool_constant
3443 {
3444   struct constant_descriptor *desc;
3445   struct pool_constant *next, *next_sym;
3446   rtx constant;
3447   enum machine_mode mode;
3448   int labelno;
3449   unsigned int align;
3450   HOST_WIDE_INT offset;
3451   int mark;
3452 };
3453
3454 /* Hash code for a SYMBOL_REF with CONSTANT_POOL_ADDRESS_P true.
3455    The argument is XSTR (... , 0)  */
3456
3457 #define SYMHASH(LABEL)  \
3458   ((((unsigned long) (LABEL)) & ((1 << HASHBITS) - 1))  % MAX_RTX_HASH_TABLE)
3459 \f
3460 /* Initialize constant pool hashing for a new function.  */
3461
3462 void
3463 init_varasm_status (f)
3464      struct function *f;
3465 {
3466   struct varasm_status *p;
3467   p = (struct varasm_status *) xmalloc (sizeof (struct varasm_status));
3468   f->varasm = p;
3469   p->x_const_rtx_hash_table
3470     = ((struct constant_descriptor **)
3471        xcalloc (MAX_RTX_HASH_TABLE, sizeof (struct constant_descriptor *)));
3472   p->x_const_rtx_sym_hash_table
3473     = ((struct pool_constant **)
3474        xcalloc (MAX_RTX_HASH_TABLE, sizeof (struct pool_constant *)));
3475
3476   p->x_first_pool = p->x_last_pool = 0;
3477   p->x_pool_offset = 0;
3478   p->x_const_double_chain = 0;
3479 }
3480
3481 /* Mark PC for GC.  */
3482
3483 static void
3484 mark_pool_constant (pc)
3485      struct pool_constant *pc;
3486 {
3487   while (pc)
3488     {
3489       ggc_mark (pc);
3490       ggc_mark_rtx (pc->constant);
3491       ggc_mark_rtx (pc->desc->rtl);
3492       pc = pc->next;
3493     }
3494 }
3495
3496 /* Mark P for GC.  */
3497
3498 void
3499 mark_varasm_status (p)
3500      struct varasm_status *p;
3501 {
3502   if (p == NULL)
3503     return;
3504
3505   mark_pool_constant (p->x_first_pool);
3506   ggc_mark_rtx (p->x_const_double_chain);
3507 }
3508
3509 /* Clear out all parts of the state in F that can safely be discarded
3510    after the function has been compiled, to let garbage collection
3511    reclaim the memory.  */
3512
3513 void
3514 free_varasm_status (f)
3515      struct function *f;
3516 {
3517   struct varasm_status *p;
3518   int i;
3519
3520   p = f->varasm;
3521
3522   /* Clear out the hash tables.  */
3523   for (i = 0; i < MAX_RTX_HASH_TABLE; ++i)
3524     {
3525       struct constant_descriptor *cd;
3526
3527       cd = p->x_const_rtx_hash_table[i];
3528       while (cd)
3529         {
3530           struct constant_descriptor *next = cd->next;
3531
3532           free (cd);
3533           cd = next;
3534         }
3535     }
3536
3537   free (p->x_const_rtx_hash_table);
3538   free (p->x_const_rtx_sym_hash_table);
3539   free (p);
3540
3541   f->varasm = NULL;
3542 }
3543 \f
3544
3545 /* Express an rtx for a constant integer (perhaps symbolic)
3546    as the sum of a symbol or label plus an explicit integer.
3547    They are stored into VALUE.  */
3548
3549 static void
3550 decode_rtx_const (mode, x, value)
3551      enum machine_mode mode;
3552      rtx x;
3553      struct rtx_const *value;
3554 {
3555   /* Clear the whole structure, including any gaps.  */
3556   memset (value, 0, sizeof (struct rtx_const));
3557
3558   value->kind = RTX_INT;        /* Most usual kind.  */
3559   value->mode = mode;
3560
3561   switch (GET_CODE (x))
3562     {
3563     case CONST_DOUBLE:
3564       value->kind = RTX_DOUBLE;
3565       if (GET_MODE (x) != VOIDmode)
3566         {
3567           value->mode = GET_MODE (x);
3568           REAL_VALUE_FROM_CONST_DOUBLE (value->un.du, x);
3569         }
3570       else
3571         {
3572           value->un.di.low = CONST_DOUBLE_LOW (x);
3573           value->un.di.high = CONST_DOUBLE_HIGH (x);
3574         }
3575       break;
3576
3577     case CONST_VECTOR:
3578       {
3579         int units, i;
3580         rtx elt;
3581
3582         units = CONST_VECTOR_NUNITS (x);
3583         value->kind = RTX_VECTOR;
3584         value->mode = mode;
3585
3586         for (i = 0; i < units; ++i)
3587           {
3588             elt = CONST_VECTOR_ELT (x, i);
3589             if (GET_MODE_CLASS (mode) == MODE_VECTOR_INT)
3590               {
3591                 value->un.veclo[i] = (HOST_WIDE_INT) INTVAL (elt);
3592                 value->un.vechi[i] = 0;
3593               }
3594             else if (GET_MODE_CLASS (mode) == MODE_VECTOR_FLOAT)
3595               {
3596                 value->un.veclo[i] = (HOST_WIDE_INT) CONST_DOUBLE_LOW (elt);
3597                 value->un.vechi[i] = (HOST_WIDE_INT) CONST_DOUBLE_HIGH (elt);
3598               }
3599             else
3600               abort ();
3601           }
3602       }
3603       break;
3604
3605     case CONST_INT:
3606       value->un.addr.offset = INTVAL (x);
3607       break;
3608
3609     case SYMBOL_REF:
3610     case LABEL_REF:
3611     case PC:
3612       value->un.addr.base = x;
3613       break;
3614
3615     case CONST:
3616       x = XEXP (x, 0);
3617       if (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 1)) == CONST_INT)
3618         {
3619           value->un.addr.base = XEXP (x, 0);
3620           value->un.addr.offset = INTVAL (XEXP (x, 1));
3621         }
3622       else if (GET_CODE (x) == MINUS && GET_CODE (XEXP (x, 1)) == CONST_INT)
3623         {
3624           value->un.addr.base = XEXP (x, 0);
3625           value->un.addr.offset = - INTVAL (XEXP (x, 1));
3626         }
3627       else
3628         {
3629           value->un.addr.base = x;
3630           value->un.addr.offset = 0;
3631         }
3632       break;
3633
3634     default:
3635       value->kind = RTX_UNKNOWN;
3636       break;
3637     }
3638
3639   if (value->kind == RTX_INT && value->un.addr.base != 0
3640       && GET_CODE (value->un.addr.base) == UNSPEC)
3641     {
3642       /* For a simple UNSPEC, the base is set to the
3643          operand, the kind field is set to the index of
3644          the unspec expression.
3645          Together with the code below, in case that
3646          the operand is a SYMBOL_REF or LABEL_REF,
3647          the address of the string or the code_label
3648          is taken as base.  */
3649       if (XVECLEN (value->un.addr.base, 0) == 1)
3650         {
3651           value->kind = RTX_UNSPEC + XINT (value->un.addr.base, 1);
3652           value->un.addr.base = XVECEXP (value->un.addr.base, 0, 0);
3653         }
3654     }
3655
3656   if (value->kind > RTX_DOUBLE && value->un.addr.base != 0)
3657     switch (GET_CODE (value->un.addr.base))
3658       {
3659       case SYMBOL_REF:
3660         /* Use the string's address, not the SYMBOL_REF's address,
3661            for the sake of addresses of library routines.  */
3662         value->un.addr.base = (rtx) XSTR (value->un.addr.base, 0);
3663         break;
3664
3665       case LABEL_REF:
3666         /* For a LABEL_REF, compare labels.  */
3667         value->un.addr.base = XEXP (value->un.addr.base, 0);
3668
3669       default:
3670         break;
3671       }
3672 }
3673
3674 /* Given a MINUS expression, simplify it if both sides
3675    include the same symbol.  */
3676
3677 rtx
3678 simplify_subtraction (x)
3679      rtx x;
3680 {
3681   struct rtx_const val0, val1;
3682
3683   decode_rtx_const (GET_MODE (x), XEXP (x, 0), &val0);
3684   decode_rtx_const (GET_MODE (x), XEXP (x, 1), &val1);
3685
3686   if (val0.kind > RTX_DOUBLE
3687       && val0.kind == val1.kind
3688       && val0.un.addr.base == val1.un.addr.base)
3689     return GEN_INT (val0.un.addr.offset - val1.un.addr.offset);
3690
3691   return x;
3692 }
3693
3694 /* Compute a hash code for a constant RTL expression.  */
3695
3696 static int
3697 const_hash_rtx (mode, x)
3698      enum machine_mode mode;
3699      rtx x;
3700 {
3701   int hi;
3702   size_t i;
3703
3704   struct rtx_const value;
3705   decode_rtx_const (mode, x, &value);
3706
3707   /* Compute hashing function */
3708   hi = 0;
3709   for (i = 0; i < sizeof value / sizeof (int); i++)
3710     hi += ((int *) &value)[i];
3711
3712   hi &= (1 << HASHBITS) - 1;
3713   hi %= MAX_RTX_HASH_TABLE;