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