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