gcc/varasm.c

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