gcc/varasm.c

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