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