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