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