gcc/varasm.c

   1 /* Output variables, constants and external declarations, for GNU compiler.
   2    Copyright (C) 1987, 88, 89, 92-99, 2000 Free Software Foundation, Inc.
   3
   4 This file is part of GNU CC.
   5
   6 GNU CC is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU CC is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU CC; see the file COPYING.  If not, write to
  18 the Free Software Foundation, 59 Temple Place - Suite 330,
  19 Boston, MA 02111-1307, USA.  */
  20
  21
  22 /* This file handles generation of all the assembler code
  23    *except* the instructions of a function.
  24    This includes declarations of variables and their initial values.
  25
  26    We also output the assembler code for constants stored in memory
  27    and are responsible for combining constants with the same value.  */
  28
  29 #include "config.h"
  30 #include "system.h"
  31 #include <setjmp.h>
  32 #include "rtl.h"
  33 #include "tree.h"
  34 #include "flags.h"
  35 #include "function.h"
  36 #include "expr.h"
  37 #include "output.h"
  38 #include "hard-reg-set.h"
  39 #include "regs.h"
  40 #include "defaults.h"
  41 #include "real.h"
  42 #include "toplev.h"
  43 #include "dbxout.h"
  44 #include "sdbout.h"
  45 #include "obstack.h"
  46 #include "c-pragma.h"
  47 #include "ggc.h"
  48 #include "tm_p.h"
  49
  50 #ifdef XCOFF_DEBUGGING_INFO
  51 #include "xcoffout.h"
  52 #endif
  53
  54 #ifndef TRAMPOLINE_ALIGNMENT
  55 #define TRAMPOLINE_ALIGNMENT FUNCTION_BOUNDARY
  56 #endif
  57
  58 #ifndef ASM_STABS_OP
  59 #define ASM_STABS_OP ".stabs"
  60 #endif
  61
  62 /* Define the prefix to use when check_memory_usage_flag is enable.  */
  63 #ifdef NO_DOLLAR_IN_LABEL
  64 #ifdef NO_DOT_IN_LABEL
  65 #define CHKR_PREFIX "chkr_prefix_"
  66 #else /* !NO_DOT_IN_LABEL */
  67 #define CHKR_PREFIX "chkr."
  68 #endif
  69 #else /* !NO_DOLLAR_IN_LABEL */
  70 #define CHKR_PREFIX "chkr$"
  71 #endif
  72 #define CHKR_PREFIX_SIZE (sizeof (CHKR_PREFIX) - 1)
  73
  74 /* File in which assembler code is being written.  */
  75
  76 extern FILE *asm_out_file;
  77
  78 /* The (assembler) name of the first globally-visible object output.  */
  79 char *first_global_object_name;
  80 char *weak_global_object_name;
  81
  82 extern struct obstack *current_obstack;
  83 extern struct obstack *saveable_obstack;
  84 extern struct obstack *rtl_obstack;
  85 extern struct obstack permanent_obstack;
  86 #define obstack_chunk_alloc xmalloc
  87
  88 struct addr_const;
  89 struct constant_descriptor;
  90 struct rtx_const;
  91 struct pool_constant;
  92
  93 #define MAX_RTX_HASH_TABLE 61
  94
  95 struct varasm_status
  96 {
  97   /* Hash facility for making memory-constants
  98      from constant rtl-expressions.  It is used on RISC machines
  99      where immediate integer arguments and constant addresses are restricted
 100      so that such constants must be stored in memory.
 101
 102      This pool of constants is reinitialized for each function
 103      so each function gets its own constants-pool that comes right before
 104      it.  */
 105   struct constant_descriptor **x_const_rtx_hash_table;
 106   struct pool_sym **x_const_rtx_sym_hash_table;
 107
 108   /* Pointers to first and last constant in pool.  */
 109   struct pool_constant *x_first_pool, *x_last_pool;
 110
 111   /* Current offset in constant pool (does not include any machine-specific
 112      header.  */
 113   int x_pool_offset;
 114
 115   /* Chain of all CONST_DOUBLE rtx's constructed for the current function.
 116      They are chained through the CONST_DOUBLE_CHAIN.
 117      A CONST_DOUBLE rtx has CONST_DOUBLE_MEM != cc0_rtx iff it is on this chain.
 118      In that case, CONST_DOUBLE_MEM is either a MEM,
 119      or const0_rtx if no MEM has been made for this CONST_DOUBLE yet.  */
 120   rtx x_const_double_chain;
 121 };
 122
 123 #define const_rtx_hash_table (cfun->varasm->x_const_rtx_hash_table)
 124 #define const_rtx_sym_hash_table (cfun->varasm->x_const_rtx_sym_hash_table)
 125 #define first_pool (cfun->varasm->x_first_pool)
 126 #define last_pool (cfun->varasm->x_last_pool)
 127 #define pool_offset (cfun->varasm->x_pool_offset)
 128 #define const_double_chain (cfun->varasm->x_const_double_chain)
 129
 130 /* Number for making the label on the next
 131    constant that is stored in memory.  */
 132
 133 int const_labelno;
 134
 135 /* Number for making the label on the next
 136    static variable internal to a function.  */
 137
 138 int var_labelno;
 139
 140 /* Carry information from ASM_DECLARE_OBJECT_NAME
 141    to ASM_FINISH_DECLARE_OBJECT.  */
 142
 143 int size_directive_output;
 144
 145 /* The last decl for which assemble_variable was called,
 146    if it did ASM_DECLARE_OBJECT_NAME.
 147    If the last call to assemble_variable didn't do that,
 148    this holds 0.  */
 149
 150 tree last_assemble_variable_decl;
 151
 152 static const char *strip_reg_name       PARAMS ((const char *));
 153 static int contains_pointers_p          PARAMS ((tree));
 154 static void decode_addr_const           PARAMS ((tree, struct addr_const *));
 155 static int const_hash                   PARAMS ((tree));
 156 static int compare_constant             PARAMS ((tree,
 157                                                struct constant_descriptor *));
 158 static char *compare_constant_1         PARAMS ((tree, char *));
 159 static struct constant_descriptor *record_constant PARAMS ((tree));
 160 static void record_constant_1           PARAMS ((tree));
 161 static tree copy_constant               PARAMS ((tree));
 162 static void output_constant_def_contents  PARAMS ((tree, int, int));
 163 static void decode_rtx_const            PARAMS ((enum machine_mode, rtx,
 164                                                struct rtx_const *));
 165 static int const_hash_rtx               PARAMS ((enum machine_mode, rtx));
 166 static int compare_constant_rtx         PARAMS ((enum machine_mode, rtx,
 167                                                struct constant_descriptor *));
 168 static struct constant_descriptor *record_constant_rtx PARAMS ((enum machine_mode,
 169                                                               rtx));
 170 static struct pool_constant *find_pool_constant PARAMS ((struct function *, rtx));
 171 static void mark_constant_pool          PARAMS ((void));
 172 static void mark_constants              PARAMS ((rtx));
 173 static int output_addressed_constants   PARAMS ((tree));
 174 static void output_after_function_constants PARAMS ((void));
 175 static void output_constructor          PARAMS ((tree, int));
 176 #ifdef ASM_WEAKEN_LABEL
 177 static void remove_from_pending_weak_list       PARAMS ((char *));
 178 #endif
 179 #ifdef ASM_OUTPUT_BSS
 180 static void asm_output_bss              PARAMS ((FILE *, tree, char *, int, int));
 181 #endif
 182 #ifdef BSS_SECTION_ASM_OP
 183 #ifdef ASM_OUTPUT_ALIGNED_BSS
 184 static void asm_output_aligned_bss      PARAMS ((FILE *, tree, char *, int, int));
 185 #endif
 186 #endif /* BSS_SECTION_ASM_OP */
 187 static void mark_pool_constant          PARAMS ((struct pool_constant *));
 188 static void mark_pool_sym_hash_table    PARAMS ((struct pool_sym **));
 189 static void mark_const_hash_entry       PARAMS ((void *));
 190 static void asm_emit_uninitialised      PARAMS ((tree, char *, int, int));
 191 \f
 192 static enum in_section { no_section, in_text, in_data, in_named
 193 #ifdef BSS_SECTION_ASM_OP
 194   , in_bss
 195 #endif
 196 #ifdef EH_FRAME_SECTION_ASM_OP
 197   , in_eh_frame
 198 #endif
 199 #ifdef EXTRA_SECTIONS
 200   , EXTRA_SECTIONS
 201 #endif
 202 } in_section = no_section;
 203
 204 /* Return a non-zero value if DECL has a section attribute.  */
 205 #ifndef IN_NAMED_SECTION
 206 #define IN_NAMED_SECTION(DECL) \
 207   ((TREE_CODE (DECL) == FUNCTION_DECL || TREE_CODE (DECL) == VAR_DECL) \
 208    && DECL_SECTION_NAME (DECL) != NULL_TREE)
 209 #endif
 210
 211 /* Text of section name when in_section == in_named.  */
 212 static char *in_named_name;
 213
 214 /* Define functions like text_section for any extra sections.  */
 215 #ifdef EXTRA_SECTION_FUNCTIONS
 216 EXTRA_SECTION_FUNCTIONS
 217 #endif
 218
 219 /* Tell assembler to switch to text section.  */
 220
 221 void
 222 text_section ()
 223 {
 224   if (in_section != in_text)
 225     {
 226       fprintf (asm_out_file, "%s\n", TEXT_SECTION_ASM_OP);
 227       in_section = in_text;
 228     }
 229 }
 230
 231 /* Tell assembler to switch to data section.  */
 232
 233 void
 234 data_section ()
 235 {
 236   if (in_section != in_data)
 237     {
 238       if (flag_shared_data)
 239         {
 240 #ifdef SHARED_SECTION_ASM_OP
 241           fprintf (asm_out_file, "%s\n", SHARED_SECTION_ASM_OP);
 242 #else
 243           fprintf (asm_out_file, "%s\n", DATA_SECTION_ASM_OP);
 244 #endif
 245         }
 246       else
 247         fprintf (asm_out_file, "%s\n", DATA_SECTION_ASM_OP);
 248
 249       in_section = in_data;
 250     }
 251 }
 252 /* Tell assembler to ALWAYS switch to data section, in case
 253    it's not sure where it it.  */
 254
 255 void
 256 force_data_section ()
 257 {
 258   in_section = no_section;
 259   data_section ();
 260 }
 261
 262 /* Tell assembler to switch to read-only data section.  This is normally
 263    the text section.  */
 264
 265 void
 266 readonly_data_section ()
 267 {
 268 #ifdef READONLY_DATA_SECTION
 269   READONLY_DATA_SECTION ();  /* Note this can call data_section.  */
 270 #else
 271   text_section ();
 272 #endif
 273 }
 274
 275 /* Determine if we're in the text section.  */
 276
 277 int
 278 in_text_section ()
 279 {
 280   return in_section == in_text;
 281 }
 282
 283 /* Determine if we're in the data section.  */
 284
 285 int
 286 in_data_section ()
 287 {
 288   return in_section == in_data;
 289 }
 290
 291 /* Tell assembler to change to section NAME for DECL.
 292    If DECL is NULL, just switch to section NAME.
 293    If NAME is NULL, get the name from DECL.
 294    If RELOC is 1, the initializer for DECL contains relocs.  */
 295
 296 void
 297 named_section (decl, name, reloc)
 298      tree decl;
 299      const char *name;
 300      int reloc ATTRIBUTE_UNUSED;
 301 {
 302   if (decl != NULL_TREE
 303       && TREE_CODE_CLASS (TREE_CODE (decl)) != 'd')
 304     abort ();
 305   if (name == NULL)
 306     name = TREE_STRING_POINTER (DECL_SECTION_NAME (decl));
 307
 308   if (in_section != in_named || strcmp (name, in_named_name))
 309     {
 310 #ifdef ASM_OUTPUT_SECTION_NAME
 311       ASM_OUTPUT_SECTION_NAME (asm_out_file, decl, name, reloc);
 312 #else
 313       /* Section attributes are not supported if this macro isn't provided -
 314          some host formats don't support them at all.  The front-end should
 315          already have flagged this as an error.  */
 316       abort ();
 317 #endif
 318
 319       in_named_name = ggc_alloc_string (name, -1);
 320       in_section = in_named;
 321     }
 322 }
 323
 324 #ifdef ASM_OUTPUT_SECTION_NAME
 325 #ifndef UNIQUE_SECTION
 326 #define UNIQUE_SECTION(DECL,RELOC)                              \
 327 do {                                                            \
 328   int len;                                                      \
 329   const char *name;                                             \
 330   char *string;                                                 \
 331                                                                 \
 332   name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (DECL));       \
 333   /* Strip off any encoding in name.  */                        \
 334   STRIP_NAME_ENCODING (name, name);                             \
 335                                                                 \
 336   len = strlen (name) + 1;                                      \
 337   string = alloca (len + 1);                                    \
 338   sprintf (string, ".%s", name);                                \
 339                                                                 \
 340   DECL_SECTION_NAME (DECL) = build_string (len, string);        \
 341 } while (0)
 342 #endif
 343 #ifndef UNIQUE_SECTION_P
 344 #define UNIQUE_SECTION_P(DECL) 0
 345 #endif
 346 #endif
 347
 348 #ifdef BSS_SECTION_ASM_OP
 349
 350 /* Tell the assembler to switch to the bss section.  */
 351
 352 void
 353 bss_section ()
 354 {
 355   if (in_section != in_bss)
 356     {
 357 #ifdef SHARED_BSS_SECTION_ASM_OP
 358       if (flag_shared_data)
 359         fprintf (asm_out_file, "%s\n", SHARED_BSS_SECTION_ASM_OP);
 360       else
 361 #endif
 362         fprintf (asm_out_file, "%s\n", BSS_SECTION_ASM_OP);
 363
 364       in_section = in_bss;
 365     }
 366 }
 367
 368 #ifdef ASM_OUTPUT_BSS
 369
 370 /* Utility function for ASM_OUTPUT_BSS for targets to use if
 371    they don't support alignments in .bss.
 372    ??? It is believed that this function will work in most cases so such
 373    support is localized here.  */
 374
 375 static void
 376 asm_output_bss (file, decl, name, size, rounded)
 377      FILE *file;
 378      tree decl ATTRIBUTE_UNUSED;
 379      char *name;
 380      int size ATTRIBUTE_UNUSED, rounded;
 381 {
 382   ASM_GLOBALIZE_LABEL (file, name);
 383   bss_section ();
 384 #ifdef ASM_DECLARE_OBJECT_NAME
 385   last_assemble_variable_decl = decl;
 386   ASM_DECLARE_OBJECT_NAME (file, name, decl);
 387 #else
 388   /* Standard thing is just output label for the object.  */
 389   ASM_OUTPUT_LABEL (file, name);
 390 #endif /* ASM_DECLARE_OBJECT_NAME */
 391   ASM_OUTPUT_SKIP (file, rounded);
 392 }
 393
 394 #endif
 395
 396 #ifdef ASM_OUTPUT_ALIGNED_BSS
 397
 398 /* Utility function for targets to use in implementing
 399    ASM_OUTPUT_ALIGNED_BSS.
 400    ??? It is believed that this function will work in most cases so such
 401    support is localized here.  */
 402
 403 static void
 404 asm_output_aligned_bss (file, decl, name, size, align)
 405      FILE *file;
 406      tree decl;
 407      char *name;
 408      int size, align;
 409 {
 410   ASM_GLOBALIZE_LABEL (file, name);
 411   bss_section ();
 412   ASM_OUTPUT_ALIGN (file, floor_log2 (align / BITS_PER_UNIT));
 413 #ifdef ASM_DECLARE_OBJECT_NAME
 414   last_assemble_variable_decl = decl;
 415   ASM_DECLARE_OBJECT_NAME (file, name, decl);
 416 #else
 417   /* Standard thing is just output label for the object.  */
 418   ASM_OUTPUT_LABEL (file, name);
 419 #endif /* ASM_DECLARE_OBJECT_NAME */
 420   ASM_OUTPUT_SKIP (file, size ? size : 1);
 421 }
 422
 423 #endif
 424
 425 #endif /* BSS_SECTION_ASM_OP */
 426
 427 #ifdef EH_FRAME_SECTION_ASM_OP
 428 void
 429 eh_frame_section ()
 430 {
 431   if (in_section != in_eh_frame)
 432     {
 433       fprintf (asm_out_file, "%s\n", EH_FRAME_SECTION_ASM_OP);
 434       in_section = in_eh_frame;
 435     }
 436 }
 437 #endif
 438
 439 /* Switch to the section for function DECL.
 440
 441    If DECL is NULL_TREE, switch to the text section.
 442    ??? It's not clear that we will ever be passed NULL_TREE, but it's
 443    safer to handle it.  */
 444
 445 void
 446 function_section (decl)
 447      tree decl;
 448 {
 449   if (decl != NULL_TREE
 450       && DECL_SECTION_NAME (decl) != NULL_TREE)
 451     named_section (decl, (char *) 0, 0);
 452   else
 453     text_section ();
 454 }
 455
 456 /* Switch to section for variable DECL.
 457
 458    RELOC is the `reloc' argument to SELECT_SECTION.  */
 459
 460 void
 461 variable_section (decl, reloc)
 462      tree decl;
 463      int reloc;
 464 {
 465   if (IN_NAMED_SECTION (decl))
 466     named_section (decl, NULL, reloc);
 467   else
 468     {
 469       /* C++ can have const variables that get initialized from constructors,
 470          and thus can not be in a readonly section.  We prevent this by
 471          verifying that the initial value is constant for objects put in a
 472          readonly section.
 473
 474          error_mark_node is used by the C front end to indicate that the
 475          initializer has not been seen yet.  In this case, we assume that
 476          the initializer must be constant.
 477
 478          C++ uses error_mark_node for variables that have complicated
 479          initializers, but these variables go in BSS so we won't be called
 480          for them.  */
 481
 482 #ifdef SELECT_SECTION
 483       SELECT_SECTION (decl, reloc);
 484 #else
 485       if (DECL_READONLY_SECTION (decl, reloc))
 486         readonly_data_section ();
 487       else
 488         data_section ();
 489 #endif
 490     }
 491 }
 492
 493 /* Tell assembler to switch to the section for the exception handling
 494    table.  */
 495
 496 void
 497 exception_section ()
 498 {
 499 #if defined (EXCEPTION_SECTION)
 500   EXCEPTION_SECTION ();
 501 #else
 502 #ifdef ASM_OUTPUT_SECTION_NAME
 503   named_section (NULL_TREE, ".gcc_except_table", 0);
 504 #else
 505   if (flag_pic)
 506     data_section ();
 507   else
 508     readonly_data_section ();
 509 #endif
 510 #endif
 511 }
 512 \f
 513 /* Create the rtl to represent a function, for a function definition.
 514    DECL is a FUNCTION_DECL node which describes which function.
 515    The rtl is stored into DECL.  */
 516
 517 void
 518 make_function_rtl (decl)
 519      tree decl;
 520 {
 521   char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
 522   char *new_name = name;
 523
 524   /* Rename a nested function to avoid conflicts.  */
 525   if (decl_function_context (decl) != 0
 526       && DECL_INITIAL (decl) != 0
 527       && DECL_RTL (decl) == 0)
 528     {
 529       char *label;
 530
 531       name = IDENTIFIER_POINTER (DECL_NAME (decl));
 532       ASM_FORMAT_PRIVATE_NAME (label, name, var_labelno);
 533       name = ggc_alloc_string (label, -1);
 534       var_labelno++;
 535     }
 536   else
 537     {
 538       /* When -fprefix-function-name is used, every function name is
 539          prefixed.  Even static functions are prefixed because they
 540          could be declared latter.  Note that a nested function name
 541          is not prefixed.  */
 542       if (flag_prefix_function_name)
 543         {
 544           size_t name_len = strlen (name);
 545
 546           new_name = ggc_alloc_string (NULL, name_len + CHKR_PREFIX_SIZE);
 547           memcpy (new_name, CHKR_PREFIX, CHKR_PREFIX_SIZE);
 548           memcpy (new_name + CHKR_PREFIX_SIZE, name, name_len + 1);
 549           name = new_name;
 550         }
 551     }
 552
 553   if (DECL_RTL (decl) == 0)
 554     {
 555       DECL_RTL (decl)
 556         = gen_rtx_MEM (DECL_MODE (decl),
 557                        gen_rtx_SYMBOL_REF (Pmode, name));
 558
 559       /* Optionally set flags or add text to the name to record information
 560          such as that it is a function name.  If the name is changed, the macro
 561          ASM_OUTPUT_LABELREF will have to know how to strip this information.  */
 562 #ifdef ENCODE_SECTION_INFO
 563       ENCODE_SECTION_INFO (decl);
 564 #endif
 565     }
 566   else
 567     {
 568       /* ??? Another way to do this would be to do what halfpic.c does
 569          and maintain a hashed table of such critters.  */
 570       /* ??? Another way to do this would be to pass a flag bit to
 571          ENCODE_SECTION_INFO saying whether this is a new decl or not.  */
 572       /* Let the target reassign the RTL if it wants.
 573          This is necessary, for example, when one machine specific
 574          decl attribute overrides another.  */
 575 #ifdef REDO_SECTION_INFO_P
 576       if (REDO_SECTION_INFO_P (decl))
 577         ENCODE_SECTION_INFO (decl);
 578 #endif
 579     }
 580 }
 581
 582 /* Given NAME, a putative register name, discard any customary prefixes.  */
 583
 584 static const char *
 585 strip_reg_name (name)
 586   const char *name;
 587 {
 588 #ifdef REGISTER_PREFIX
 589   if (!strncmp (name, REGISTER_PREFIX, strlen (REGISTER_PREFIX)))
 590     name += strlen (REGISTER_PREFIX);
 591 #endif
 592   if (name[0] == '%' || name[0] == '#')
 593     name++;
 594   return name;
 595 }
 596 \f
 597 /* Decode an `asm' spec for a declaration as a register name.
 598    Return the register number, or -1 if nothing specified,
 599    or -2 if the ASMSPEC is not `cc' or `memory' and is not recognized,
 600    or -3 if ASMSPEC is `cc' and is not recognized,
 601    or -4 if ASMSPEC is `memory' and is not recognized.
 602    Accept an exact spelling or a decimal number.
 603    Prefixes such as % are optional.  */
 604
 605 int
 606 decode_reg_name (asmspec)
 607   const char *asmspec;
 608 {
 609   if (asmspec != 0)
 610     {
 611       int i;
 612
 613       /* Get rid of confusing prefixes.  */
 614       asmspec = strip_reg_name (asmspec);
 615
 616       /* Allow a decimal number as a "register name".  */
 617       for (i = strlen (asmspec) - 1; i >= 0; i--)
 618         if (! (asmspec[i] >= '0' && asmspec[i] <= '9'))
 619           break;
 620       if (asmspec[0] != 0 && i < 0)
 621         {
 622           i = atoi (asmspec);
 623           if (i < FIRST_PSEUDO_REGISTER && i >= 0)
 624             return i;
 625           else
 626             return -2;
 627         }
 628
 629       for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
 630         if (reg_names[i][0]
 631             && ! strcmp (asmspec, strip_reg_name (reg_names[i])))
 632           return i;
 633
 634 #ifdef ADDITIONAL_REGISTER_NAMES
 635       {
 636         static struct { const char *name; int number; } table[]
 637           = ADDITIONAL_REGISTER_NAMES;
 638
 639         for (i = 0; i < (int)(sizeof (table) / sizeof (table[0])); i++)
 640           if (! strcmp (asmspec, table[i].name))
 641             return table[i].number;
 642       }
 643 #endif /* ADDITIONAL_REGISTER_NAMES */
 644
 645       if (!strcmp (asmspec, "memory"))
 646         return -4;
 647
 648       if (!strcmp (asmspec, "cc"))
 649         return -3;
 650
 651       return -2;
 652     }
 653
 654   return -1;
 655 }
 656 \f
 657 /* Create the DECL_RTL for a declaration for a static or external variable
 658    or static or external function.
 659    ASMSPEC, if not 0, is the string which the user specified
 660    as the assembler symbol name.
 661    TOP_LEVEL is nonzero if this is a file-scope variable.
 662
 663    This is never called for PARM_DECL nodes.  */
 664
 665 void
 666 make_decl_rtl (decl, asmspec, top_level)
 667      tree decl;
 668      const char *asmspec;
 669      int top_level;
 670 {
 671   register char *name = 0;
 672   int reg_number;
 673
 674   reg_number = decode_reg_name (asmspec);
 675
 676   if (DECL_ASSEMBLER_NAME (decl) != NULL_TREE)
 677     name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
 678
 679   if (reg_number == -2)
 680     {
 681       /* ASMSPEC is given, and not the name of a register.  */
 682       size_t len = strlen (asmspec);
 683
 684       name = ggc_alloc_string (NULL, len + 1);
 685       name[0] = '*';
 686       memcpy (&name[1], asmspec, len + 1);
 687     }
 688
 689   /* For a duplicate declaration, we can be called twice on the
 690      same DECL node.  Don't discard the RTL already made.  */
 691   if (DECL_RTL (decl) == 0)
 692     {
 693       /* First detect errors in declaring global registers.  */
 694       if (TREE_CODE (decl) != FUNCTION_DECL
 695           && DECL_REGISTER (decl) && reg_number == -1)
 696         error_with_decl (decl,
 697                          "register name not specified for `%s'");
 698       else if (TREE_CODE (decl) != FUNCTION_DECL
 699                && DECL_REGISTER (decl) && reg_number < 0)
 700         error_with_decl (decl,
 701                          "invalid register name for `%s'");
 702       else if ((reg_number >= 0 || reg_number == -3)
 703                && (TREE_CODE (decl) == FUNCTION_DECL
 704                    && ! DECL_REGISTER (decl)))
 705         error_with_decl (decl,
 706                          "register name given for non-register variable `%s'");
 707       else if (TREE_CODE (decl) != FUNCTION_DECL
 708                && DECL_REGISTER (decl)
 709                && TYPE_MODE (TREE_TYPE (decl)) == BLKmode)
 710         error_with_decl (decl,
 711                          "data type of `%s' isn't suitable for a register");
 712       else if (TREE_CODE (decl) != FUNCTION_DECL && DECL_REGISTER (decl)
 713                && ! HARD_REGNO_MODE_OK (reg_number,
 714                                         TYPE_MODE (TREE_TYPE (decl))))
 715         error_with_decl (decl,
 716                          "register number for `%s' isn't suitable for data type");
 717       /* Now handle properly declared static register variables.  */
 718       else if (TREE_CODE (decl) != FUNCTION_DECL && DECL_REGISTER (decl))
 719         {
 720           int nregs;
 721
 722           if (DECL_INITIAL (decl) != 0 && top_level)
 723             {
 724               DECL_INITIAL (decl) = 0;
 725               error ("global register variable has initial value");
 726             }
 727           if (TREE_THIS_VOLATILE (decl))
 728             warning ("volatile register variables don't work as you might wish");
 729
 730           /* If the user specified one of the eliminables registers here,
 731              e.g., FRAME_POINTER_REGNUM, we don't want to get this variable
 732              confused with that register and be eliminated.  Although this
 733              usage is somewhat suspect, we nevertheless use the following
 734              kludge to avoid setting DECL_RTL to frame_pointer_rtx.  */
 735
 736           DECL_RTL (decl)
 737             = gen_rtx_REG (DECL_MODE (decl), FIRST_PSEUDO_REGISTER);
 738           REGNO (DECL_RTL (decl)) = reg_number;
 739           REG_USERVAR_P (DECL_RTL (decl)) = 1;
 740
 741           if (top_level)
 742             {
 743               /* Make this register global, so not usable for anything
 744                  else.  */
 745 #ifdef ASM_DECLARE_REGISTER_GLOBAL
 746               ASM_DECLARE_REGISTER_GLOBAL (asm_out_file, decl, reg_number, name);
 747 #endif
 748               nregs = HARD_REGNO_NREGS (reg_number, DECL_MODE (decl));
 749               while (nregs > 0)
 750                 globalize_reg (reg_number + --nregs);
 751             }
 752         }
 753       /* Specifying a section attribute on a variable forces it into a
 754          non-.bss section, and thus it cannot be common. */
 755       else if (TREE_CODE (decl) == VAR_DECL
 756                && DECL_SECTION_NAME (decl) != NULL_TREE
 757                && DECL_INITIAL (decl) == NULL_TREE
 758                && DECL_COMMON (decl))
 759           DECL_COMMON (decl) = 0;
 760
 761       /* Now handle ordinary static variables and functions (in memory).
 762          Also handle vars declared register invalidly.  */
 763       if (DECL_RTL (decl) == 0)
 764         {
 765           /* Can't use just the variable's own name for a variable
 766              whose scope is less than the whole file.
 767              Concatenate a distinguishing number.  */
 768           if (!top_level && !TREE_PUBLIC (decl) && asmspec == 0)
 769             {
 770               char *label;
 771
 772               ASM_FORMAT_PRIVATE_NAME (label, name, var_labelno);
 773               name = ggc_alloc_string (label, -1);
 774               var_labelno++;
 775             }
 776
 777           if (name == 0)
 778             abort ();
 779
 780           /* When -fprefix-function-name is used, the functions
 781              names are prefixed.  Only nested function names are not
 782              prefixed.  */
 783           if (flag_prefix_function_name && TREE_CODE (decl) == FUNCTION_DECL)
 784             {
 785               size_t name_len = strlen (name);
 786               char *new_name;
 787
 788               new_name = ggc_alloc_string (NULL, name_len + CHKR_PREFIX_SIZE);
 789               memcpy (new_name, CHKR_PREFIX, CHKR_PREFIX_SIZE);
 790               memcpy (new_name + CHKR_PREFIX_SIZE, name, name_len + 1);
 791               name = new_name;
 792             }
 793
 794           DECL_RTL (decl) = gen_rtx_MEM (DECL_MODE (decl),
 795                                          gen_rtx_SYMBOL_REF (Pmode, name));
 796           MEM_ALIAS_SET (DECL_RTL (decl)) = get_alias_set (decl);
 797
 798           /* If this variable is to be treated as volatile, show its
 799              tree node has side effects.  If it has side effects, either
 800              because of this test or from TREE_THIS_VOLATILE also
 801              being set, show the MEM is volatile.  */
 802           if (flag_volatile_global && TREE_CODE (decl) == VAR_DECL
 803               && TREE_PUBLIC (decl))
 804             TREE_SIDE_EFFECTS (decl) = 1;
 805           else if (flag_volatile_static && TREE_CODE (decl) == VAR_DECL
 806                && (TREE_PUBLIC (decl) || TREE_STATIC (decl)))
 807             TREE_SIDE_EFFECTS (decl) = 1;
 808
 809           if (TREE_SIDE_EFFECTS (decl))
 810             MEM_VOLATILE_P (DECL_RTL (decl)) = 1;
 811
 812           if (TREE_READONLY (decl))
 813             RTX_UNCHANGING_P (DECL_RTL (decl)) = 1;
 814           MEM_SET_IN_STRUCT_P (DECL_RTL (decl),
 815                                AGGREGATE_TYPE_P (TREE_TYPE (decl)));
 816
 817           /* Optionally set flags or add text to the name to record information
 818              such as that it is a function name.
 819              If the name is changed, the macro ASM_OUTPUT_LABELREF
 820              will have to know how to strip this information.  */
 821 #ifdef ENCODE_SECTION_INFO
 822           ENCODE_SECTION_INFO (decl);
 823 #endif
 824         }
 825     }
 826   else
 827     {
 828       /* If the old RTL had the wrong mode, fix the mode.  */
 829       if (GET_MODE (DECL_RTL (decl)) != DECL_MODE (decl))
 830         {
 831           rtx rtl = DECL_RTL (decl);
 832           PUT_MODE (rtl, DECL_MODE (decl));
 833         }
 834
 835       /* ??? Another way to do this would be to do what halfpic.c does
 836          and maintain a hashed table of such critters.  */
 837       /* ??? Another way to do this would be to pass a flag bit to
 838          ENCODE_SECTION_INFO saying whether this is a new decl or not.  */
 839       /* Let the target reassign the RTL if it wants.
 840          This is necessary, for example, when one machine specific
 841          decl attribute overrides another.  */
 842 #ifdef REDO_SECTION_INFO_P
 843       if (REDO_SECTION_INFO_P (decl))
 844         ENCODE_SECTION_INFO (decl);
 845 #endif
 846     }
 847 }
 848
 849 /* Make the rtl for variable VAR be volatile.
 850    Use this only for static variables.  */
 851
 852 void
 853 make_var_volatile (var)
 854      tree var;
 855 {
 856   if (GET_CODE (DECL_RTL (var)) != MEM)
 857     abort ();
 858
 859   MEM_VOLATILE_P (DECL_RTL (var)) = 1;
 860 }
 861 \f
 862 /* Output alignment directive to align for constant expression EXP.  */
 863
 864 void
 865 assemble_constant_align (exp)
 866      tree exp;
 867 {
 868   int align;
 869
 870   /* Align the location counter as required by EXP's data type.  */
 871   align = TYPE_ALIGN (TREE_TYPE (exp));
 872 #ifdef CONSTANT_ALIGNMENT
 873   align = CONSTANT_ALIGNMENT (exp, align);
 874 #endif
 875
 876   if (align > BITS_PER_UNIT)
 877     ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
 878 }
 879
 880 /* Output a string of literal assembler code
 881    for an `asm' keyword used between functions.  */
 882
 883 void
 884 assemble_asm (string)
 885      tree string;
 886 {
 887   app_enable ();
 888
 889   if (TREE_CODE (string) == ADDR_EXPR)
 890     string = TREE_OPERAND (string, 0);
 891
 892   fprintf (asm_out_file, "\t%s\n", TREE_STRING_POINTER (string));
 893 }
 894
 895 #if 0 /* This should no longer be needed, because
 896          flag_gnu_linker should be 0 on these systems,
 897          which should prevent any output
 898          if ASM_OUTPUT_CONSTRUCTOR and ASM_OUTPUT_DESTRUCTOR are absent.  */
 899 #if !(defined(DBX_DEBUGGING_INFO) && !defined(FASCIST_ASSEMBLER))
 900 #ifndef ASM_OUTPUT_CONSTRUCTOR
 901 #define ASM_OUTPUT_CONSTRUCTOR(file, name)
 902 #endif
 903 #ifndef ASM_OUTPUT_DESTRUCTOR
 904 #define ASM_OUTPUT_DESTRUCTOR(file, name)
 905 #endif
 906 #endif
 907 #endif /* 0 */
 908
 909 /* Record an element in the table of global destructors.
 910    How this is done depends on what sort of assembler and linker
 911    are in use.
 912
 913    NAME should be the name of a global function to be called
 914    at exit time.  This name is output using assemble_name.  */
 915
 916 void
 917 assemble_destructor (name)
 918      const char *name;
 919 {
 920 #ifdef ASM_OUTPUT_DESTRUCTOR
 921   ASM_OUTPUT_DESTRUCTOR (asm_out_file, name);
 922 #else
 923   if (flag_gnu_linker)
 924     {
 925       /* Now tell GNU LD that this is part of the static destructor set.  */
 926       /* This code works for any machine provided you use GNU as/ld.  */
 927       fprintf (asm_out_file, "%s \"___DTOR_LIST__\",22,0,0,", ASM_STABS_OP);
 928       assemble_name (asm_out_file, name);
 929       fputc ('\n', asm_out_file);
 930     }
 931 #endif
 932 }
 933
 934 /* Likewise for global constructors.  */
 935
 936 void
 937 assemble_constructor (name)
 938      const char *name;
 939 {
 940 #ifdef ASM_OUTPUT_CONSTRUCTOR
 941   ASM_OUTPUT_CONSTRUCTOR (asm_out_file, name);
 942 #else
 943   if (flag_gnu_linker)
 944     {
 945       /* Now tell GNU LD that this is part of the static constructor set.  */
 946       /* This code works for any machine provided you use GNU as/ld.  */
 947       fprintf (asm_out_file, "%s \"___CTOR_LIST__\",22,0,0,", ASM_STABS_OP);
 948       assemble_name (asm_out_file, name);
 949       fputc ('\n', asm_out_file);
 950     }
 951 #endif
 952 }
 953
 954 /* Likewise for entries we want to record for garbage collection.
 955    Garbage collection is still under development.  */
 956
 957 void
 958 assemble_gc_entry (name)
 959      const char *name;
 960 {
 961 #ifdef ASM_OUTPUT_GC_ENTRY
 962   ASM_OUTPUT_GC_ENTRY (asm_out_file, name);
 963 #else
 964   if (flag_gnu_linker)
 965     {
 966       /* Now tell GNU LD that this is part of the static constructor set.  */
 967       fprintf (asm_out_file, "%s \"___PTR_LIST__\",22,0,0,", ASM_STABS_OP);
 968       assemble_name (asm_out_file, name);
 969       fputc ('\n', asm_out_file);
 970     }
 971 #endif
 972 }
 973 \f
 974 /* CONSTANT_POOL_BEFORE_FUNCTION may be defined as an expression with
 975    a non-zero value if the constant pool should be output before the
 976    start of the function, or a zero value if the pool should output
 977    after the end of the function.  The default is to put it before the
 978    start.  */
 979
 980 #ifndef CONSTANT_POOL_BEFORE_FUNCTION
 981 #define CONSTANT_POOL_BEFORE_FUNCTION 1
 982 #endif
 983
 984 /* Output assembler code for the constant pool of a function and associated
 985    with defining the name of the function.  DECL describes the function.
 986    NAME is the function's name.  For the constant pool, we use the current
 987    constant pool data.  */
 988
 989 void
 990 assemble_start_function (decl, fnname)
 991      tree decl;
 992      char *fnname;
 993 {
 994   int align;
 995
 996   /* The following code does not need preprocessing in the assembler.  */
 997
 998   app_disable ();
 999
1000   if (CONSTANT_POOL_BEFORE_FUNCTION)
1001     output_constant_pool (fnname, decl);
1002
1003 #ifdef ASM_OUTPUT_SECTION_NAME
1004   /* If the function is to be put in its own section and it's not in a section
1005      already, indicate so.  */
1006   if ((flag_function_sections
1007        && DECL_SECTION_NAME (decl) == NULL_TREE)
1008       || UNIQUE_SECTION_P (decl))
1009     UNIQUE_SECTION (decl, 0);
1010 #endif
1011
1012   function_section (decl);
1013
1014   /* Tell assembler to move to target machine's alignment for functions.  */
1015   align = floor_log2 (FUNCTION_BOUNDARY / BITS_PER_UNIT);
1016   if (align > 0)
1017     ASM_OUTPUT_ALIGN (asm_out_file, align);
1018
1019   /* Handle a user-specified function alignment.
1020      Note that we still need to align to FUNCTION_BOUNDARY, as above,
1021      because ASM_OUTPUT_MAX_SKIP_ALIGN might not do any alignment at all.  */
1022   if (align_functions_log > align)
1023     {
1024 #ifdef ASM_OUTPUT_MAX_SKIP_ALIGN
1025       ASM_OUTPUT_MAX_SKIP_ALIGN (asm_out_file,
1026                                  align_functions_log, align_functions-1);
1027 #else
1028       ASM_OUTPUT_ALIGN (asm_out_file, align_functions_log);
1029 #endif
1030     }
1031
1032 #ifdef ASM_OUTPUT_FUNCTION_PREFIX
1033   ASM_OUTPUT_FUNCTION_PREFIX (asm_out_file, fnname);
1034 #endif
1035
1036 #ifdef SDB_DEBUGGING_INFO
1037   /* Output SDB definition of the function.  */
1038   if (write_symbols == SDB_DEBUG)
1039     sdbout_mark_begin_function ();
1040 #endif
1041
1042 #ifdef DBX_DEBUGGING_INFO
1043   /* Output DBX definition of the function.  */
1044   if (write_symbols == DBX_DEBUG)
1045     dbxout_begin_function (decl);
1046 #endif
1047
1048   /* Make function name accessible from other files, if appropriate.  */
1049
1050   if (TREE_PUBLIC (decl))
1051     {
1052       if (! first_global_object_name)
1053         {
1054           const char *p;
1055           char **name;
1056
1057           if (! DECL_WEAK (decl) && ! DECL_ONE_ONLY (decl))
1058             name = &first_global_object_name;
1059           else
1060             name = &weak_global_object_name;
1061
1062           STRIP_NAME_ENCODING (p, fnname);
1063           *name = permalloc (strlen (p) + 1);
1064           strcpy (*name, p);
1065         }
1066
1067 #ifdef ASM_WEAKEN_LABEL
1068       if (DECL_WEAK (decl))
1069         {
1070           ASM_WEAKEN_LABEL (asm_out_file, fnname);
1071           /* Remove this function from the pending weak list so that
1072              we do not emit multiple .weak directives for it.  */
1073           remove_from_pending_weak_list
1074             (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
1075         }
1076       else
1077 #endif
1078       ASM_GLOBALIZE_LABEL (asm_out_file, fnname);
1079     }
1080
1081   /* Do any machine/system dependent processing of the function name */
1082 #ifdef ASM_DECLARE_FUNCTION_NAME
1083   ASM_DECLARE_FUNCTION_NAME (asm_out_file, fnname, current_function_decl);
1084 #else
1085   /* Standard thing is just output label for the function.  */
1086   ASM_OUTPUT_LABEL (asm_out_file, fnname);
1087 #endif /* ASM_DECLARE_FUNCTION_NAME */
1088 }
1089
1090 /* Output assembler code associated with defining the size of the
1091    function.  DECL describes the function.  NAME is the function's name.  */
1092
1093 void
1094 assemble_end_function (decl, fnname)
1095      tree decl;
1096      const char *fnname;
1097 {
1098 #ifdef ASM_DECLARE_FUNCTION_SIZE
1099   ASM_DECLARE_FUNCTION_SIZE (asm_out_file, fnname, decl);
1100 #endif
1101   if (! CONSTANT_POOL_BEFORE_FUNCTION)
1102     {
1103       output_constant_pool (fnname, decl);
1104       function_section (decl);  /* need to switch back */
1105     }
1106
1107   /* Output any constants which should appear after the function.  */
1108   output_after_function_constants ();
1109 }
1110 \f
1111 /* Assemble code to leave SIZE bytes of zeros.  */
1112
1113 void
1114 assemble_zeros (size)
1115      int size;
1116 {
1117   /* Do no output if -fsyntax-only.  */
1118   if (flag_syntax_only)
1119     return;
1120
1121 #ifdef ASM_NO_SKIP_IN_TEXT
1122   /* The `space' pseudo in the text section outputs nop insns rather than 0s,
1123      so we must output 0s explicitly in the text section.  */
1124   if (ASM_NO_SKIP_IN_TEXT && in_text_section ())
1125     {
1126       int i;
1127
1128       for (i = 0; i < size - 20; i += 20)
1129         {
1130 #ifdef ASM_BYTE_OP
1131           fprintf (asm_out_file,
1132                    "%s 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0\n", ASM_BYTE_OP);
1133 #else
1134           fprintf (asm_out_file,
1135                    "\tbyte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0\n");
1136 #endif
1137         }
1138       if (i < size)
1139         {
1140 #ifdef ASM_BYTE_OP
1141           fprintf (asm_out_file, "%s 0", ASM_BYTE_OP);
1142 #else
1143           fprintf (asm_out_file, "\tbyte 0");
1144 #endif
1145           i++;
1146           for (; i < size; i++)
1147             fprintf (asm_out_file, ",0");
1148           fprintf (asm_out_file, "\n");
1149         }
1150     }
1151   else
1152 #endif
1153     if (size > 0)
1154       ASM_OUTPUT_SKIP (asm_out_file, size);
1155 }
1156
1157 /* Assemble an alignment pseudo op for an ALIGN-bit boundary.  */
1158
1159 void
1160 assemble_align (align)
1161      int align;
1162 {
1163   if (align > BITS_PER_UNIT)
1164     ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
1165 }
1166
1167 /* Assemble a string constant with the specified C string as contents.  */
1168
1169 void
1170 assemble_string (p, size)
1171      const char *p;
1172      int size;
1173 {
1174   int pos = 0;
1175   int maximum = 2000;
1176
1177   /* If the string is very long, split it up.  */
1178
1179   while (pos < size)
1180     {
1181       int thissize = size - pos;
1182       if (thissize > maximum)
1183         thissize = maximum;
1184
1185       ASM_OUTPUT_ASCII (asm_out_file, p, thissize);
1186
1187       pos += thissize;
1188       p += thissize;
1189     }
1190 }
1191
1192 \f
1193 #if defined  ASM_OUTPUT_ALIGNED_DECL_LOCAL
1194 #define ASM_EMIT_LOCAL(decl, name, size, rounded) \
1195   ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file, decl, name, size, DECL_ALIGN (decl))
1196 #else
1197 #if defined  ASM_OUTPUT_ALIGNED_LOCAL
1198 #define ASM_EMIT_LOCAL(decl, name, size, rounded) \
1199   ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, DECL_ALIGN (decl))
1200 #else
1201 #define ASM_EMIT_LOCAL(decl, name, size, rounded) \
1202   ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded)
1203 #endif
1204 #endif
1205
1206 #if defined ASM_OUTPUT_ALIGNED_BSS
1207 #define ASM_EMIT_BSS(decl, name, size, rounded) \
1208   ASM_OUTPUT_ALIGNED_BSS (asm_out_file, decl, name, size, DECL_ALIGN (decl))
1209 #else
1210 #if defined ASM_OUTPUT_BSS
1211 #define ASM_EMIT_BSS(decl, name, size, rounded) \
1212   ASM_OUTPUT_BSS (asm_out_file, decl, name, size, rounded)
1213 #else
1214 #undef  ASM_EMIT_BSS
1215 #endif
1216 #endif
1217
1218 #if defined ASM_OUTPUT_ALIGNED_DECL_COMMON
1219 #define ASM_EMIT_COMMON(decl, name, size, rounded) \
1220   ASM_OUTPUT_ALIGNED_DECL_COMMON (asm_out_file, decl, name, size, DECL_ALIGN (decl))
1221 #else
1222 #if defined ASM_OUTPUT_ALIGNED_COMMON
1223 #define ASM_EMIT_COMMON(decl, name, size, rounded) \
1224   ASM_OUTPUT_ALIGNED_COMMON (asm_out_file, name, size, DECL_ALIGN (decl))
1225 #else
1226 #define ASM_EMIT_COMMON(decl, name, size, rounded) \
1227   ASM_OUTPUT_COMMON (asm_out_file, name, size, rounded)
1228 #endif
1229 #endif
1230
1231 static void
1232 asm_emit_uninitialised (decl, name, size, rounded)
1233      tree decl;
1234      char * name;
1235      int size ATTRIBUTE_UNUSED;
1236      int rounded ATTRIBUTE_UNUSED;
1237 {
1238   enum
1239   {
1240     asm_dest_common,
1241     asm_dest_bss,
1242     asm_dest_local
1243   }
1244   destination = asm_dest_local;
1245
1246   if (TREE_PUBLIC (decl))
1247     {
1248 #if defined ASM_EMIT_BSS
1249       if (! DECL_COMMON (decl))
1250         destination = asm_dest_bss;
1251       else
1252 #endif
1253         destination = asm_dest_common;
1254     }
1255
1256   if (flag_shared_data)
1257     {
1258       switch (destination)
1259         {
1260 #ifdef ASM_OUTPUT_SHARED_BSS
1261         case asm_dest_bss:
1262           ASM_OUTPUT_SHARED_BSS (asm_out_file, decl, name, size, rounded);
1263           return;
1264 #endif
1265 #ifdef ASM_OUTPUT_SHARED_COMMON
1266         case asm_dest_common:
1267           ASM_OUTPUT_SHARED_COMMON (asm_out_file, name, size, rounded);
1268           return;
1269 #endif
1270 #ifdef ASM_OUTPUT_SHARED_LOCAL
1271         case asm_dest_local:
1272           ASM_OUTPUT_SHARED_LOCAL (asm_out_file, name, size, rounded);
1273           return;
1274 #endif
1275         default:
1276           break;
1277         }
1278     }
1279
1280 #ifdef ASM_OUTPUT_SECTION_NAME
1281   /* We already know that DECL_SECTION_NAME() == NULL.  */
1282   if (flag_data_sections != 0 || UNIQUE_SECTION_P (decl))
1283     UNIQUE_SECTION (decl, NULL);
1284 #endif
1285
1286   switch (destination)
1287     {
1288 #ifdef ASM_EMIT_BSS
1289     case asm_dest_bss:
1290       ASM_EMIT_BSS (decl, name, size, rounded);
1291       break;
1292 #endif
1293     case asm_dest_common:
1294       ASM_EMIT_COMMON (decl, name, size, rounded);
1295       break;
1296     case asm_dest_local:
1297       ASM_EMIT_LOCAL (decl, name, size, rounded);
1298       break;
1299     default:
1300       abort ();
1301     }
1302
1303   return;
1304 }
1305
1306 /* Assemble everything that is needed for a variable or function declaration.
1307    Not used for automatic variables, and not used for function definitions.
1308    Should not be called for variables of incomplete structure type.
1309
1310    TOP_LEVEL is nonzero if this variable has file scope.
1311    AT_END is nonzero if this is the special handling, at end of compilation,
1312    to define things that have had only tentative definitions.
1313    DONT_OUTPUT_DATA if nonzero means don't actually output the
1314    initial value (that will be done by the caller).  */
1315
1316 void
1317 assemble_variable (decl, top_level, at_end, dont_output_data)
1318      tree decl;
1319      int top_level ATTRIBUTE_UNUSED;
1320      int at_end ATTRIBUTE_UNUSED;
1321      int dont_output_data;
1322 {
1323   register char *name;
1324   unsigned int align;
1325   tree size_tree = NULL_TREE;
1326   int reloc = 0;
1327   enum in_section saved_in_section;
1328
1329   last_assemble_variable_decl = 0;
1330
1331   if (GET_CODE (DECL_RTL (decl)) == REG)
1332     {
1333       /* Do output symbol info for global register variables, but do nothing
1334          else for them.  */
1335
1336       if (TREE_ASM_WRITTEN (decl))
1337         return;
1338       TREE_ASM_WRITTEN (decl) = 1;
1339
1340       /* Do no output if -fsyntax-only.  */
1341       if (flag_syntax_only)
1342         return;
1343
1344 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
1345       /* File-scope global variables are output here.  */
1346       if ((write_symbols == DBX_DEBUG || write_symbols == XCOFF_DEBUG)
1347            && top_level)
1348         dbxout_symbol (decl, 0);
1349 #endif
1350 #ifdef SDB_DEBUGGING_INFO
1351       if (write_symbols == SDB_DEBUG && top_level
1352           /* Leave initialized global vars for end of compilation;
1353              see comment in compile_file.  */
1354           && (TREE_PUBLIC (decl) == 0 || DECL_INITIAL (decl) == 0))
1355         sdbout_symbol (decl, 0);
1356 #endif
1357
1358       /* Don't output any DWARF debugging information for variables here.
1359          In the case of local variables, the information for them is output
1360          when we do our recursive traversal of the tree representation for
1361          the entire containing function.  In the case of file-scope variables,
1362          we output information for all of them at the very end of compilation
1363          while we are doing our final traversal of the chain of file-scope
1364          declarations.  */
1365
1366       return;
1367     }
1368
1369   /* Normally no need to say anything here for external references,
1370      since assemble_external is called by the language-specific code
1371      when a declaration is first seen.  */
1372
1373   if (DECL_EXTERNAL (decl))
1374     return;
1375
1376   /* Output no assembler code for a function declaration.
1377      Only definitions of functions output anything.  */
1378
1379   if (TREE_CODE (decl) == FUNCTION_DECL)
1380     return;
1381
1382   /* If type was incomplete when the variable was declared,
1383      see if it is complete now.  */
1384
1385   if (DECL_SIZE (decl) == 0)
1386     layout_decl (decl, 0);
1387
1388   /* Still incomplete => don't allocate it; treat the tentative defn
1389      (which is what it must have been) as an `extern' reference.  */
1390
1391   if (!dont_output_data && DECL_SIZE (decl) == 0)
1392     {
1393       error_with_file_and_line (DECL_SOURCE_FILE (decl),
1394                                 DECL_SOURCE_LINE (decl),
1395                                 "storage size of `%s' isn't known",
1396                                 IDENTIFIER_POINTER (DECL_NAME (decl)));
1397       TREE_ASM_WRITTEN (decl) = 1;
1398       return;
1399     }
1400
1401   /* The first declaration of a variable that comes through this function
1402      decides whether it is global (in C, has external linkage)
1403      or local (in C, has internal linkage).  So do nothing more
1404      if this function has already run.  */
1405
1406   if (TREE_ASM_WRITTEN (decl))
1407     return;
1408
1409   TREE_ASM_WRITTEN (decl) = 1;
1410
1411   /* Do no output if -fsyntax-only.  */
1412   if (flag_syntax_only)
1413     return;
1414
1415   app_disable ();
1416
1417   if (! dont_output_data)
1418     {
1419       int size;
1420
1421       if (TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST)
1422         goto finish;
1423
1424       /* This is better than explicit arithmetic, since it avoids overflow.  */
1425       size_tree = size_binop (CEIL_DIV_EXPR,
1426                               DECL_SIZE (decl), size_int (BITS_PER_UNIT));
1427
1428       size = TREE_INT_CST_LOW (size_tree);
1429       if (TREE_INT_CST_HIGH (size_tree) != 0
1430           || size != TREE_INT_CST_LOW (size_tree))
1431         {
1432           error_with_decl (decl, "size of variable `%s' is too large");
1433           goto finish;
1434         }
1435     }
1436
1437   name = XSTR (XEXP (DECL_RTL (decl), 0), 0);
1438
1439   if (TREE_PUBLIC (decl) && DECL_NAME (decl)
1440       && ! first_global_object_name
1441       && ! (DECL_COMMON (decl) && (DECL_INITIAL (decl) == 0
1442                                    || DECL_INITIAL (decl) == error_mark_node))
1443       && ! DECL_WEAK (decl)
1444       && ! DECL_ONE_ONLY (decl))
1445     {
1446       const char *p;
1447
1448       STRIP_NAME_ENCODING (p, name);
1449       first_global_object_name = permalloc (strlen (p) + 1);
1450       strcpy (first_global_object_name, p);
1451     }
1452
1453   /* Compute the alignment of this data.  */
1454
1455   align = DECL_ALIGN (decl);
1456
1457   /* In the case for initialing an array whose length isn't specified,
1458      where we have not yet been able to do the layout,
1459      figure out the proper alignment now.  */
1460   if (dont_output_data && DECL_SIZE (decl) == 0
1461       && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
1462     align = MAX (align, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (decl))));
1463
1464   /* Some object file formats have a maximum alignment which they support.
1465      In particular, a.out format supports a maximum alignment of 4.  */
1466 #ifndef MAX_OFILE_ALIGNMENT
1467 #define MAX_OFILE_ALIGNMENT BIGGEST_ALIGNMENT
1468 #endif
1469   if (align > MAX_OFILE_ALIGNMENT)
1470     {
1471       warning_with_decl (decl,
1472         "alignment of `%s' is greater than maximum object file alignment. Using %d.",
1473                     MAX_OFILE_ALIGNMENT/BITS_PER_UNIT);
1474       align = MAX_OFILE_ALIGNMENT;
1475     }
1476
1477   /* On some machines, it is good to increase alignment sometimes.  */
1478 #ifdef DATA_ALIGNMENT
1479   align = DATA_ALIGNMENT (TREE_TYPE (decl), align);
1480 #endif
1481 #ifdef CONSTANT_ALIGNMENT
1482   if (DECL_INITIAL (decl) != 0 && DECL_INITIAL (decl) != error_mark_node)
1483     align = CONSTANT_ALIGNMENT (DECL_INITIAL (decl), align);
1484 #endif
1485
1486   /* Reset the alignment in case we have made it tighter, so we can benefit
1487      from it in get_pointer_alignment.  */
1488   DECL_ALIGN (decl) = align;
1489
1490   /* Handle uninitialized definitions.  */
1491
1492   if ((DECL_INITIAL (decl) == 0 || DECL_INITIAL (decl) == error_mark_node)
1493       /* If the target can't output uninitialized but not common global data
1494          in .bss, then we have to use .data.  */
1495 #if ! defined ASM_EMIT_BSS
1496       && DECL_COMMON (decl)
1497 #endif
1498       && DECL_SECTION_NAME (decl) == NULL_TREE
1499       && ! dont_output_data)
1500     {
1501       int size = TREE_INT_CST_LOW (size_tree);
1502       int rounded = size;
1503
1504       /* Don't allocate zero bytes of common,
1505          since that means "undefined external" in the linker.  */
1506       if (size == 0) rounded = 1;
1507       /* Round size up to multiple of BIGGEST_ALIGNMENT bits
1508          so that each uninitialized object starts on such a boundary.  */
1509       rounded += (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1;
1510       rounded = (rounded / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
1511                  * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
1512
1513 #if !defined(ASM_OUTPUT_ALIGNED_COMMON) && !defined(ASM_OUTPUT_ALIGNED_BSS)
1514       if ((DECL_ALIGN (decl) / BITS_PER_UNIT) > (unsigned int) rounded)
1515          warning_with_decl
1516            (decl, "requested alignment for %s is greater than implemented alignment of %d.",rounded);
1517 #endif
1518
1519 #ifdef DBX_DEBUGGING_INFO
1520       /* File-scope global variables are output here.  */
1521       if (write_symbols == DBX_DEBUG && top_level)
1522         dbxout_symbol (decl, 0);
1523 #endif
1524 #ifdef SDB_DEBUGGING_INFO
1525       if (write_symbols == SDB_DEBUG && top_level
1526           /* Leave initialized global vars for end of compilation;
1527              see comment in compile_file.  */
1528           && (TREE_PUBLIC (decl) == 0 || DECL_INITIAL (decl) == 0))
1529         sdbout_symbol (decl, 0);
1530 #endif
1531
1532       /* Don't output any DWARF debugging information for variables here.
1533          In the case of local variables, the information for them is output
1534          when we do our recursive traversal of the tree representation for
1535          the entire containing function.  In the case of file-scope variables,
1536          we output information for all of them at the very end of compilation
1537          while we are doing our final traversal of the chain of file-scope
1538          declarations.  */
1539
1540 #if 0 /* ??? We should either delete this or add a comment describing what
1541          it was intended to do and why we shouldn't delete it.  */
1542       if (flag_shared_data)
1543         data_section ();
1544 #endif
1545       asm_emit_uninitialised (decl, name, size, rounded);
1546
1547       goto finish;
1548     }
1549
1550   /* Handle initialized definitions.
1551      Also handle uninitialized global definitions if -fno-common and the
1552      target doesn't support ASM_OUTPUT_BSS.  */
1553
1554   /* First make the assembler name(s) global if appropriate.  */
1555   if (TREE_PUBLIC (decl) && DECL_NAME (decl))
1556     {
1557 #ifdef ASM_WEAKEN_LABEL
1558       if (DECL_WEAK (decl))
1559         {
1560           ASM_WEAKEN_LABEL (asm_out_file, name);
1561            /* Remove this variable from the pending weak list so that
1562               we do not emit multiple .weak directives for it.  */
1563           remove_from_pending_weak_list
1564             (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
1565         }
1566       else
1567 #endif
1568       ASM_GLOBALIZE_LABEL (asm_out_file, name);
1569     }
1570 #if 0
1571   for (d = equivalents; d; d = TREE_CHAIN (d))
1572     {
1573       tree e = TREE_VALUE (d);
1574       if (TREE_PUBLIC (e) && DECL_NAME (e))
1575         ASM_GLOBALIZE_LABEL (asm_out_file,
1576                              XSTR (XEXP (DECL_RTL (e), 0), 0));
1577     }
1578 #endif
1579
1580   /* Output any data that we will need to use the address of.  */
1581   if (DECL_INITIAL (decl) == error_mark_node)
1582     reloc = contains_pointers_p (TREE_TYPE (decl));
1583   else if (DECL_INITIAL (decl))
1584     reloc = output_addressed_constants (DECL_INITIAL (decl));
1585
1586 #ifdef ASM_OUTPUT_SECTION_NAME
1587   if ((flag_data_sections != 0 && DECL_SECTION_NAME (decl) == NULL_TREE)
1588       || UNIQUE_SECTION_P (decl))
1589     UNIQUE_SECTION (decl, reloc);
1590 #endif
1591
1592   /* Switch to the appropriate section.  */
1593   variable_section (decl, reloc);
1594
1595   /* dbxout.c needs to know this.  */
1596   if (in_text_section ())
1597     DECL_IN_TEXT_SECTION (decl) = 1;
1598
1599   /* Record current section so we can restore it if dbxout.c clobbers it.  */
1600   saved_in_section = in_section;
1601
1602   /* Output the dbx info now that we have chosen the section.  */
1603
1604 #ifdef DBX_DEBUGGING_INFO
1605   /* File-scope global variables are output here.  */
1606   if (write_symbols == DBX_DEBUG && top_level)
1607     dbxout_symbol (decl, 0);
1608 #endif
1609 #ifdef SDB_DEBUGGING_INFO
1610   if (write_symbols == SDB_DEBUG && top_level
1611       /* Leave initialized global vars for end of compilation;
1612          see comment in compile_file.  */
1613       && (TREE_PUBLIC (decl) == 0 || DECL_INITIAL (decl) == 0))
1614     sdbout_symbol (decl, 0);
1615 #endif
1616
1617   /* Don't output any DWARF debugging information for variables here.
1618      In the case of local variables, the information for them is output
1619      when we do our recursive traversal of the tree representation for
1620      the entire containing function.  In the case of file-scope variables,
1621      we output information for all of them at the very end of compilation
1622      while we are doing our final traversal of the chain of file-scope
1623      declarations.  */
1624
1625   /* If the debugging output changed sections, reselect the section
1626      that's supposed to be selected.  */
1627   if (in_section != saved_in_section)
1628     variable_section (decl, reloc);
1629
1630   /* Output the alignment of this data.  */
1631   if (align > BITS_PER_UNIT)
1632     ASM_OUTPUT_ALIGN (asm_out_file,
1633                       floor_log2 (DECL_ALIGN (decl) / BITS_PER_UNIT));
1634
1635   /* Do any machine/system dependent processing of the object.  */
1636 #ifdef ASM_DECLARE_OBJECT_NAME
1637   last_assemble_variable_decl = decl;
1638   ASM_DECLARE_OBJECT_NAME (asm_out_file, name, decl);
1639 #else
1640   /* Standard thing is just output label for the object.  */
1641   ASM_OUTPUT_LABEL (asm_out_file, name);
1642 #endif /* ASM_DECLARE_OBJECT_NAME */
1643
1644   if (!dont_output_data)
1645     {
1646       if (DECL_INITIAL (decl))
1647         /* Output the actual data.  */
1648         output_constant (DECL_INITIAL (decl), TREE_INT_CST_LOW (size_tree));
1649       else
1650         /* Leave space for it.  */
1651         assemble_zeros (TREE_INT_CST_LOW (size_tree));
1652     }
1653
1654  finish:
1655 #ifdef XCOFF_DEBUGGING_INFO
1656   /* Unfortunately, the IBM assembler cannot handle stabx before the actual
1657      declaration.  When something like ".stabx  "aa:S-2",aa,133,0" is emitted
1658      and `aa' hasn't been output yet, the assembler generates a stab entry with
1659      a value of zero, in addition to creating an unnecessary external entry
1660      for `aa'.  Hence, we must postpone dbxout_symbol to here at the end.  */
1661
1662   /* File-scope global variables are output here.  */
1663   if (write_symbols == XCOFF_DEBUG && top_level)
1664     {
1665       saved_in_section = in_section;
1666
1667       dbxout_symbol (decl, 0);
1668
1669       if (in_section != saved_in_section)
1670         variable_section (decl, reloc);
1671     }
1672 #else
1673   /* There must be a statement after a label.  */
1674   ;
1675 #endif
1676 }
1677
1678 /* Return 1 if type TYPE contains any pointers.  */
1679
1680 static int
1681 contains_pointers_p (type)
1682      tree type;
1683 {
1684   switch (TREE_CODE (type))
1685     {
1686     case POINTER_TYPE:
1687     case REFERENCE_TYPE:
1688       /* I'm not sure whether OFFSET_TYPE needs this treatment,
1689          so I'll play safe and return 1.  */
1690     case OFFSET_TYPE:
1691       return 1;
1692
1693     case RECORD_TYPE:
1694     case UNION_TYPE:
1695     case QUAL_UNION_TYPE:
1696       {
1697         tree fields;
1698         /* For a type that has fields, see if the fields have pointers.  */
1699         for (fields = TYPE_FIELDS (type); fields; fields = TREE_CHAIN (fields))
1700           if (TREE_CODE (fields) == FIELD_DECL
1701               && contains_pointers_p (TREE_TYPE (fields)))
1702             return 1;
1703         return 0;
1704       }
1705
1706     case ARRAY_TYPE:
1707       /* An array type contains pointers if its element type does.  */
1708       return contains_pointers_p (TREE_TYPE (type));
1709
1710     default:
1711       return 0;
1712     }
1713 }
1714
1715 /* Output something to declare an external symbol to the assembler.
1716    (Most assemblers don't need this, so we normally output nothing.)
1717    Do nothing if DECL is not external.  */
1718
1719 void
1720 assemble_external (decl)
1721      tree decl ATTRIBUTE_UNUSED;
1722 {
1723 #ifdef ASM_OUTPUT_EXTERNAL
1724   if (TREE_CODE_CLASS (TREE_CODE (decl)) == 'd'
1725       && DECL_EXTERNAL (decl) && TREE_PUBLIC (decl))
1726     {
1727       rtx rtl = DECL_RTL (decl);
1728
1729       if (GET_CODE (rtl) == MEM && GET_CODE (XEXP (rtl, 0)) == SYMBOL_REF
1730           && ! SYMBOL_REF_USED (XEXP (rtl, 0)))
1731         {
1732           /* Some systems do require some output.  */
1733           SYMBOL_REF_USED (XEXP (rtl, 0)) = 1;
1734           ASM_OUTPUT_EXTERNAL (asm_out_file, decl, XSTR (XEXP (rtl, 0), 0));
1735         }
1736     }
1737 #endif
1738 }
1739
1740 /* Similar, for calling a library function FUN.  */
1741
1742 void
1743 assemble_external_libcall (fun)
1744      rtx fun ATTRIBUTE_UNUSED;
1745 {
1746 #ifdef ASM_OUTPUT_EXTERNAL_LIBCALL
1747   /* Declare library function name external when first used, if nec.  */
1748   if (! SYMBOL_REF_USED (fun))
1749     {
1750       SYMBOL_REF_USED (fun) = 1;
1751       ASM_OUTPUT_EXTERNAL_LIBCALL (asm_out_file, fun);
1752     }
1753 #endif
1754 }
1755
1756 /* Declare the label NAME global.  */
1757
1758 void
1759 assemble_global (name)
1760      const char *name;
1761 {
1762   ASM_GLOBALIZE_LABEL (asm_out_file, name);
1763 }
1764
1765 /* Assemble a label named NAME.  */
1766
1767 void
1768 assemble_label (name)
1769      const char *name;
1770 {
1771   ASM_OUTPUT_LABEL (asm_out_file, name);
1772 }
1773
1774 /* Output to FILE a reference to the assembler name of a C-level name NAME.
1775    If NAME starts with a *, the rest of NAME is output verbatim.
1776    Otherwise NAME is transformed in an implementation-defined way
1777    (usually by the addition of an underscore).
1778    Many macros in the tm file are defined to call this function.  */
1779
1780 void
1781 assemble_name (file, name)
1782      FILE *file;
1783      const char *name;
1784 {
1785   const char *real_name;
1786   tree id;
1787
1788   STRIP_NAME_ENCODING (real_name, name);
1789   if (flag_prefix_function_name
1790       && ! bcmp (real_name, CHKR_PREFIX, CHKR_PREFIX_SIZE))
1791     real_name = real_name + CHKR_PREFIX_SIZE;
1792
1793   id = maybe_get_identifier (real_name);
1794   if (id)
1795     TREE_SYMBOL_REFERENCED (id) = 1;
1796
1797   if (name[0] == '*')
1798     fputs (&name[1], file);
1799   else
1800     ASM_OUTPUT_LABELREF (file, name);
1801 }
1802
1803 /* Allocate SIZE bytes writable static space with a gensym name
1804    and return an RTX to refer to its address.  */
1805
1806 rtx
1807 assemble_static_space (size)
1808      int size;
1809 {
1810   char name[12];
1811   char *namestring;
1812   rtx x;
1813
1814 #if 0
1815   if (flag_shared_data)
1816     data_section ();
1817 #endif
1818
1819   ASM_GENERATE_INTERNAL_LABEL (name, "LF", const_labelno);
1820   ++const_labelno;
1821   namestring = ggc_alloc_string (name, -1);
1822
1823   x = gen_rtx_SYMBOL_REF (Pmode, namestring);
1824
1825 #ifdef ASM_OUTPUT_ALIGNED_DECL_LOCAL
1826   ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file, NULL_TREE, name, size,
1827                                  BIGGEST_ALIGNMENT);
1828 #else
1829 #ifdef ASM_OUTPUT_ALIGNED_LOCAL
1830   ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, BIGGEST_ALIGNMENT);
1831 #else
1832   {
1833     /* Round size up to multiple of BIGGEST_ALIGNMENT bits
1834        so that each uninitialized object starts on such a boundary.  */
1835     /* Variable `rounded' might or might not be used in ASM_OUTPUT_LOCAL. */
1836     int rounded ATTRIBUTE_UNUSED
1837       = ((size + (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1)
1838          / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
1839          * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
1840     ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
1841   }
1842 #endif
1843 #endif
1844   return x;
1845 }
1846
1847 /* Assemble the static constant template for function entry trampolines.
1848    This is done at most once per compilation.
1849    Returns an RTX for the address of the template.  */
1850
1851 #ifdef TRAMPOLINE_TEMPLATE
1852 rtx
1853 assemble_trampoline_template ()
1854 {
1855   char label[256];
1856   char *name;
1857   int align;
1858
1859   /* By default, put trampoline templates in read-only data section.  */
1860
1861 #ifdef TRAMPOLINE_SECTION
1862   TRAMPOLINE_SECTION ();
1863 #else
1864   readonly_data_section ();
1865 #endif
1866
1867   /* Write the assembler code to define one.  */
1868   align = floor_log2 (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT);
1869   if (align > 0)
1870     ASM_OUTPUT_ALIGN (asm_out_file, align);
1871
1872   ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LTRAMP", 0);
1873   TRAMPOLINE_TEMPLATE (asm_out_file);
1874
1875   /* Record the rtl to refer to it.  */
1876   ASM_GENERATE_INTERNAL_LABEL (label, "LTRAMP", 0);
1877   name = ggc_alloc_string (label, -1);
1878   return gen_rtx_SYMBOL_REF (Pmode, name);
1879 }
1880 #endif
1881 \f
1882 /* Assemble the integer constant X into an object of SIZE bytes.
1883    X must be either a CONST_INT or CONST_DOUBLE.
1884
1885    Return 1 if we were able to output the constant, otherwise 0.  If FORCE is
1886    non-zero, abort if we can't output the constant.  */
1887
1888 int
1889 assemble_integer (x, size, force)
1890      rtx x;
1891      int size;
1892      int force;
1893 {
1894   /* First try to use the standard 1, 2, 4, 8, and 16 byte
1895      ASM_OUTPUT... macros.  */
1896
1897   switch (size)
1898     {
1899 #ifdef ASM_OUTPUT_CHAR
1900     case 1:
1901       ASM_OUTPUT_CHAR (asm_out_file, x);
1902       return 1;
1903 #endif
1904
1905 #ifdef ASM_OUTPUT_SHORT
1906     case 2:
1907       ASM_OUTPUT_SHORT (asm_out_file, x);
1908       return 1;
1909 #endif
1910
1911 #ifdef ASM_OUTPUT_INT
1912     case 4:
1913       ASM_OUTPUT_INT (asm_out_file, x);
1914       return 1;
1915 #endif
1916
1917 #ifdef ASM_OUTPUT_DOUBLE_INT
1918     case 8:
1919       ASM_OUTPUT_DOUBLE_INT (asm_out_file, x);
1920       return 1;
1921 #endif
1922
1923 #ifdef ASM_OUTPUT_QUADRUPLE_INT
1924     case 16:
1925       ASM_OUTPUT_QUADRUPLE_INT (asm_out_file, x);
1926       return 1;
1927 #endif
1928     }
1929
1930   /* If we couldn't do it that way, there are two other possibilities: First,
1931      if the machine can output an explicit byte and this is a 1 byte constant,
1932      we can use ASM_OUTPUT_BYTE.  */
1933
1934 #ifdef ASM_OUTPUT_BYTE
1935   if (size == 1 && GET_CODE (x) == CONST_INT)
1936     {
1937       ASM_OUTPUT_BYTE (asm_out_file, INTVAL (x));
1938       return 1;
1939     }
1940 #endif
1941
1942   /* Finally, if SIZE is larger than a single word, try to output the constant
1943      one word at a time.  */
1944
1945   if (size > UNITS_PER_WORD)
1946     {
1947       int i;
1948       enum machine_mode mode
1949         = mode_for_size (size * BITS_PER_UNIT, MODE_INT, 0);
1950       rtx word;
1951
1952       for (i = 0; i < size / UNITS_PER_WORD; i++)
1953         {
1954           word = operand_subword (x, i, 0, mode);
1955
1956           if (word == 0)
1957             break;
1958
1959           if (! assemble_integer (word, UNITS_PER_WORD, 0))
1960             break;
1961         }
1962
1963       if (i == size / UNITS_PER_WORD)
1964         return 1;
1965       /* If we output at least one word and then could not finish,
1966          there is no valid way to continue.  */
1967       if (i > 0)
1968         abort ();
1969     }
1970
1971   if (force)
1972     abort ();
1973
1974   return 0;
1975 }
1976 \f
1977 /* Assemble the floating-point constant D into an object of size MODE.  */
1978
1979 void
1980 assemble_real (d, mode)
1981      REAL_VALUE_TYPE d;
1982      enum machine_mode mode;
1983 {
1984   jmp_buf output_constant_handler;
1985
1986   if (setjmp (output_constant_handler))
1987     {
1988       error ("floating point trap outputting a constant");
1989 #ifdef REAL_IS_NOT_DOUBLE
1990       bzero ((char *) &d, sizeof d);
1991       d = dconst0;
1992 #else
1993       d = 0;
1994 #endif
1995     }
1996
1997   set_float_handler (output_constant_handler);
1998
1999   switch (mode)
2000     {
2001 #ifdef ASM_OUTPUT_BYTE_FLOAT
2002     case QFmode:
2003       ASM_OUTPUT_BYTE_FLOAT (asm_out_file, d);
2004       break;
2005 #endif
2006 #ifdef ASM_OUTPUT_SHORT_FLOAT
2007     case HFmode:
2008       ASM_OUTPUT_SHORT_FLOAT (asm_out_file, d);
2009       break;
2010 #endif
2011 #ifdef ASM_OUTPUT_THREE_QUARTER_FLOAT
2012     case TQFmode:
2013       ASM_OUTPUT_THREE_QUARTER_FLOAT (asm_out_file, d);
2014       break;
2015 #endif
2016 #ifdef ASM_OUTPUT_FLOAT
2017     case SFmode:
2018       ASM_OUTPUT_FLOAT (asm_out_file, d);
2019       break;
2020 #endif
2021
2022 #ifdef ASM_OUTPUT_DOUBLE
2023     case DFmode:
2024       ASM_OUTPUT_DOUBLE (asm_out_file, d);
2025       break;
2026 #endif
2027
2028 #ifdef ASM_OUTPUT_LONG_DOUBLE
2029     case XFmode:
2030     case TFmode:
2031       ASM_OUTPUT_LONG_DOUBLE (asm_out_file, d);
2032       break;
2033 #endif
2034
2035     default:
2036       abort ();
2037     }
2038
2039   set_float_handler (NULL_PTR);
2040 }
2041 \f
2042 /* Here we combine duplicate floating constants to make
2043    CONST_DOUBLE rtx's, and force those out to memory when necessary.  */
2044
2045 /* Return a CONST_DOUBLE or CONST_INT for a value specified as a pair of ints.
2046    For an integer, I0 is the low-order word and I1 is the high-order word.
2047    For a real number, I0 is the word with the low address
2048    and I1 is the word with the high address.  */
2049
2050 rtx
2051 immed_double_const (i0, i1, mode)
2052      HOST_WIDE_INT i0, i1;
2053      enum machine_mode mode;
2054 {
2055   register rtx r;
2056
2057   if (GET_MODE_CLASS (mode) == MODE_INT
2058       || GET_MODE_CLASS (mode) == MODE_PARTIAL_INT)
2059     {
2060       /* We clear out all bits that don't belong in MODE, unless they and our
2061          sign bit are all one.  So we get either a reasonable negative value
2062          or a reasonable unsigned value for this mode.  */
2063       int width = GET_MODE_BITSIZE (mode);
2064       if (width < HOST_BITS_PER_WIDE_INT
2065           && ((i0 & ((HOST_WIDE_INT) (-1) << (width - 1)))
2066               != ((HOST_WIDE_INT) (-1) << (width - 1))))
2067         i0 &= ((HOST_WIDE_INT) 1 << width) - 1, i1 = 0;
2068       else if (width == HOST_BITS_PER_WIDE_INT
2069                && ! (i1 == ~0 && i0 < 0))
2070         i1 = 0;
2071       else if (width > 2 * HOST_BITS_PER_WIDE_INT)
2072         /* We cannot represent this value as a constant.  */
2073         abort ();
2074
2075       /* If this would be an entire word for the target, but is not for
2076          the host, then sign-extend on the host so that the number will look
2077          the same way on the host that it would on the target.
2078
2079          For example, when building a 64 bit alpha hosted 32 bit sparc
2080          targeted compiler, then we want the 32 bit unsigned value -1 to be
2081          represented as a 64 bit value -1, and not as 0x00000000ffffffff.
2082          The later confuses the sparc backend.  */
2083
2084       if (BITS_PER_WORD < HOST_BITS_PER_WIDE_INT && BITS_PER_WORD == width
2085           && (i0 & ((HOST_WIDE_INT) 1 << (width - 1))))
2086         i0 |= ((HOST_WIDE_INT) (-1) << width);
2087
2088       /* If MODE fits within HOST_BITS_PER_WIDE_INT, always use a CONST_INT.
2089
2090          ??? Strictly speaking, this is wrong if we create a CONST_INT
2091          for a large unsigned constant with the size of MODE being
2092          HOST_BITS_PER_WIDE_INT and later try to interpret that constant in a
2093          wider mode.  In that case we will mis-interpret it as a negative
2094          number.
2095
2096          Unfortunately, the only alternative is to make a CONST_DOUBLE
2097          for any constant in any mode if it is an unsigned constant larger
2098          than the maximum signed integer in an int on the host.  However,
2099          doing this will break everyone that always expects to see a CONST_INT
2100          for SImode and smaller.
2101
2102          We have always been making CONST_INTs in this case, so nothing new
2103          is being broken.  */
2104
2105       if (width <= HOST_BITS_PER_WIDE_INT)
2106         i1 = (i0 < 0) ? ~(HOST_WIDE_INT) 0 : 0;
2107
2108       /* If this integer fits in one word, return a CONST_INT.  */
2109       if ((i1 == 0 && i0 >= 0)
2110           || (i1 == ~0 && i0 < 0))
2111         return GEN_INT (i0);
2112
2113       /* We use VOIDmode for integers.  */
2114       mode = VOIDmode;
2115     }
2116
2117   /* Search the chain for an existing CONST_DOUBLE with the right value.
2118      If one is found, return it.  */
2119   if (cfun != 0)
2120     for (r = const_double_chain; r; r = CONST_DOUBLE_CHAIN (r))
2121       if (CONST_DOUBLE_LOW (r) == i0 && CONST_DOUBLE_HIGH (r) == i1
2122           && GET_MODE (r) == mode)
2123         return r;
2124
2125   /* No; make a new one and add it to the chain.
2126
2127      We may be called by an optimizer which may be discarding any memory
2128      allocated during its processing (such as combine and loop).  However,
2129      we will be leaving this constant on the chain, so we cannot tolerate
2130      freed memory.  So switch to saveable_obstack for this allocation
2131      and then switch back if we were in current_obstack.  */
2132
2133   push_obstacks_nochange ();
2134   rtl_in_saveable_obstack ();
2135   r = gen_rtx_CONST_DOUBLE (mode, NULL_RTX, i0, i1);
2136   pop_obstacks ();
2137
2138   /* Don't touch const_double_chain if not inside any function.  */
2139   if (current_function_decl != 0)
2140     {
2141       CONST_DOUBLE_CHAIN (r) = const_double_chain;
2142       const_double_chain = r;
2143     }
2144
2145   /* Store const0_rtx in mem-slot since this CONST_DOUBLE is on the chain.
2146      Actual use of mem-slot is only through force_const_mem.  */
2147
2148   CONST_DOUBLE_MEM (r) = const0_rtx;
2149
2150   return r;
2151 }
2152
2153 /* Return a CONST_DOUBLE for a specified `double' value
2154    and machine mode.  */
2155
2156 rtx
2157 immed_real_const_1 (d, mode)
2158      REAL_VALUE_TYPE d;
2159      enum machine_mode mode;
2160 {
2161   union real_extract u;
2162   register rtx r;
2163
2164   /* Get the desired `double' value as a sequence of ints
2165      since that is how they are stored in a CONST_DOUBLE.  */
2166
2167   u.d = d;
2168
2169   /* Detect special cases.  */
2170
2171   if (REAL_VALUES_IDENTICAL (dconst0, d))
2172     return CONST0_RTX (mode);
2173   /* Check for NaN first, because some ports (specifically the i386) do not
2174      emit correct ieee-fp code by default, and thus will generate a core
2175      dump here if we pass a NaN to REAL_VALUES_EQUAL and if REAL_VALUES_EQUAL
2176      does a floating point comparison.  */
2177   else if (! REAL_VALUE_ISNAN (d) && REAL_VALUES_EQUAL (dconst1, d))
2178     return CONST1_RTX (mode);
2179
2180   if (sizeof u == sizeof (HOST_WIDE_INT))
2181     return immed_double_const (u.i[0], 0, mode);
2182   if (sizeof u == 2 * sizeof (HOST_WIDE_INT))
2183     return immed_double_const (u.i[0], u.i[1], mode);
2184
2185   /* The rest of this function handles the case where
2186      a float value requires more than 2 ints of space.
2187      It will be deleted as dead code on machines that don't need it.  */
2188
2189   /* Search the chain for an existing CONST_DOUBLE with the right value.
2190      If one is found, return it.  */
2191   if (cfun != 0)
2192     for (r = const_double_chain; r; r = CONST_DOUBLE_CHAIN (r))
2193       if (! bcmp ((char *) &CONST_DOUBLE_LOW (r), (char *) &u, sizeof u)
2194           && GET_MODE (r) == mode)
2195         return r;
2196
2197   /* No; make a new one and add it to the chain.
2198
2199      We may be called by an optimizer which may be discarding any memory
2200      allocated during its processing (such as combine and loop).  However,
2201      we will be leaving this constant on the chain, so we cannot tolerate
2202      freed memory.  So switch to saveable_obstack for this allocation
2203      and then switch back if we were in current_obstack.  */
2204   push_obstacks_nochange ();
2205   rtl_in_saveable_obstack ();
2206   r = rtx_alloc (CONST_DOUBLE);
2207   pop_obstacks ();
2208   PUT_MODE (r, mode);
2209   bcopy ((char *) &u, (char *) &CONST_DOUBLE_LOW (r), sizeof u);
2210
2211   /* Don't touch const_double_chain if not inside any function.  */
2212   if (current_function_decl != 0)
2213     {
2214       CONST_DOUBLE_CHAIN (r) = const_double_chain;
2215       const_double_chain = r;
2216     }
2217
2218   /* Store const0_rtx in CONST_DOUBLE_MEM since this CONST_DOUBLE is on the
2219      chain, but has not been allocated memory.  Actual use of CONST_DOUBLE_MEM
2220      is only through force_const_mem.  */
2221
2222   CONST_DOUBLE_MEM (r) = const0_rtx;
2223
2224   return r;
2225 }
2226
2227 /* Return a CONST_DOUBLE rtx for a value specified by EXP,
2228    which must be a REAL_CST tree node.  */
2229
2230 rtx
2231 immed_real_const (exp)
2232      tree exp;
2233 {
2234   return immed_real_const_1 (TREE_REAL_CST (exp), TYPE_MODE (TREE_TYPE (exp)));
2235 }
2236
2237 /* At the end of a function, forget the memory-constants
2238    previously made for CONST_DOUBLEs.  Mark them as not on real_constant_chain.
2239    Also clear out real_constant_chain and clear out all the chain-pointers.  */
2240
2241 void
2242 clear_const_double_mem ()
2243 {
2244   register rtx r, next;
2245
2246   for (r = const_double_chain; r; r = next)
2247     {
2248       next = CONST_DOUBLE_CHAIN (r);
2249       CONST_DOUBLE_CHAIN (r) = 0;
2250       CONST_DOUBLE_MEM (r) = cc0_rtx;
2251     }
2252   const_double_chain = 0;
2253 }
2254 \f
2255 /* Given an expression EXP with a constant value,
2256    reduce it to the sum of an assembler symbol and an integer.
2257    Store them both in the structure *VALUE.
2258    Abort if EXP does not reduce.  */
2259
2260 struct addr_const
2261 {
2262   rtx base;
2263   HOST_WIDE_INT offset;
2264 };
2265
2266 static void
2267 decode_addr_const (exp, value)
2268      tree exp;
2269      struct addr_const *value;
2270 {
2271   register tree target = TREE_OPERAND (exp, 0);
2272   register int offset = 0;
2273   register rtx x;
2274
2275   while (1)
2276     {
2277       if (TREE_CODE (target) == COMPONENT_REF
2278           && (TREE_CODE (DECL_FIELD_BITPOS (TREE_OPERAND (target, 1)))
2279               == INTEGER_CST))
2280         {
2281           offset += TREE_INT_CST_LOW (DECL_FIELD_BITPOS (TREE_OPERAND (target, 1))) / BITS_PER_UNIT;
2282           target = TREE_OPERAND (target, 0);
2283         }
2284       else if (TREE_CODE (target) == ARRAY_REF)
2285         {
2286           if (TREE_CODE (TREE_OPERAND (target, 1)) != INTEGER_CST
2287               || TREE_CODE (TYPE_SIZE (TREE_TYPE (target))) != INTEGER_CST)
2288             abort ();
2289           offset += ((TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (target)))
2290                       * TREE_INT_CST_LOW (TREE_OPERAND (target, 1)))
2291                      / BITS_PER_UNIT);
2292           target = TREE_OPERAND (target, 0);
2293         }
2294       else
2295         break;
2296     }
2297
2298   switch (TREE_CODE (target))
2299     {
2300     case VAR_DECL:
2301     case FUNCTION_DECL:
2302       x = DECL_RTL (target);
2303       break;
2304
2305     case LABEL_DECL:
2306       x = gen_rtx_MEM (FUNCTION_MODE,
2307                        gen_rtx_LABEL_REF (VOIDmode,
2308                                           label_rtx (TREE_OPERAND (exp, 0))));
2309       break;
2310
2311     case REAL_CST:
2312     case STRING_CST:
2313     case COMPLEX_CST:
2314     case CONSTRUCTOR:
2315     case INTEGER_CST:
2316       x = TREE_CST_RTL (target);
2317       break;
2318
2319     default:
2320       abort ();
2321     }
2322
2323   if (GET_CODE (x) != MEM)
2324     abort ();
2325   x = XEXP (x, 0);
2326
2327   value->base = x;
2328   value->offset = offset;
2329 }
2330 \f
2331 /* Uniquize all constants that appear in memory.
2332    Each constant in memory thus far output is recorded
2333    in `const_hash_table' with a `struct constant_descriptor'
2334    that contains a polish representation of the value of
2335    the constant.
2336
2337    We cannot store the trees in the hash table
2338    because the trees may be temporary.  */
2339
2340 struct constant_descriptor
2341 {
2342   struct constant_descriptor *next;
2343   char *label;
2344   rtx rtl;
2345   char contents[1];
2346 };
2347
2348 #define HASHBITS 30
2349 #define MAX_HASH_TABLE 1009
2350 static struct constant_descriptor *const_hash_table[MAX_HASH_TABLE];
2351
2352 /* Mark a const_hash_table descriptor for GC.  */
2353
2354 static void
2355 mark_const_hash_entry (ptr)
2356      void *ptr;
2357 {
2358   struct constant_descriptor *desc = * (struct constant_descriptor **) ptr;
2359
2360   while (desc)
2361     {
2362       ggc_mark_string (desc->label);
2363       ggc_mark_rtx (desc->rtl);
2364       desc = desc->next;
2365     }
2366 }
2367
2368 /* Compute a hash code for a constant expression.  */
2369
2370 static int
2371 const_hash (exp)
2372      tree exp;
2373 {
2374   register char *p;
2375   register int len, hi, i;
2376   register enum tree_code code = TREE_CODE (exp);
2377
2378   /* Either set P and LEN to the address and len of something to hash and
2379      exit the switch or return a value.  */
2380
2381   switch (code)
2382     {
2383     case INTEGER_CST:
2384       p = (char *) &TREE_INT_CST_LOW (exp);
2385       len = 2 * sizeof TREE_INT_CST_LOW (exp);
2386       break;
2387
2388     case REAL_CST:
2389       p = (char *) &TREE_REAL_CST (exp);
2390       len = sizeof TREE_REAL_CST (exp);
2391       break;
2392
2393     case STRING_CST:
2394       p = TREE_STRING_POINTER (exp);
2395       len = TREE_STRING_LENGTH (exp);
2396       break;
2397
2398     case COMPLEX_CST:
2399       return (const_hash (TREE_REALPART (exp)) * 5
2400               + const_hash (TREE_IMAGPART (exp)));
2401
2402     case CONSTRUCTOR:
2403       if (TREE_CODE (TREE_TYPE (exp)) == SET_TYPE)
2404         {
2405           len = int_size_in_bytes (TREE_TYPE (exp));
2406           p = (char *) alloca (len);
2407           get_set_constructor_bytes (exp, (unsigned char *) p, len);
2408           break;
2409         }
2410       else
2411         {
2412           register tree link;
2413
2414           /* For record type, include the type in the hashing.
2415              We do not do so for array types
2416              because (1) the sizes of the elements are sufficient
2417              and (2) distinct array types can have the same constructor.
2418              Instead, we include the array size because the constructor could
2419              be shorter.  */
2420           if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
2421             hi = ((unsigned long) TREE_TYPE (exp) & ((1 << HASHBITS) - 1))
2422               % MAX_HASH_TABLE;
2423           else
2424             hi = ((5 + int_size_in_bytes (TREE_TYPE (exp)))
2425                   & ((1 << HASHBITS) - 1)) % MAX_HASH_TABLE;
2426
2427           for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
2428             if (TREE_VALUE (link))
2429               hi
2430                 = (hi * 603 + const_hash (TREE_VALUE (link))) % MAX_HASH_TABLE;
2431
2432           return hi;
2433         }
2434
2435     case ADDR_EXPR:
2436       {
2437         struct addr_const value;
2438
2439         decode_addr_const (exp, &value);
2440         if (GET_CODE (value.base) == SYMBOL_REF)
2441           {
2442             /* Don't hash the address of the SYMBOL_REF;
2443                only use the offset and the symbol name.  */
2444             hi = value.offset;
2445             p = XSTR (value.base, 0);
2446             for (i = 0; p[i] != 0; i++)
2447               hi = ((hi * 613) + (unsigned) (p[i]));
2448           }
2449         else if (GET_CODE (value.base) == LABEL_REF)
2450           hi = value.offset + CODE_LABEL_NUMBER (XEXP (value.base, 0)) * 13;
2451         else
2452           abort();
2453
2454         hi &= (1 << HASHBITS) - 1;
2455         hi %= MAX_HASH_TABLE;
2456       }
2457       return hi;
2458
2459     case PLUS_EXPR:
2460     case MINUS_EXPR:
2461       return (const_hash (TREE_OPERAND (exp, 0)) * 9
2462               + const_hash (TREE_OPERAND (exp, 1)));
2463
2464     case NOP_EXPR:
2465     case CONVERT_EXPR:
2466     case NON_LVALUE_EXPR:
2467       return const_hash (TREE_OPERAND (exp, 0)) * 7 + 2;
2468
2469     default:
2470       abort ();
2471     }
2472
2473   /* Compute hashing function */
2474   hi = len;
2475   for (i = 0; i < len; i++)
2476     hi = ((hi * 613) + (unsigned) (p[i]));
2477
2478   hi &= (1 << HASHBITS) - 1;
2479   hi %= MAX_HASH_TABLE;
2480   return hi;
2481 }
2482 \f
2483 /* Compare a constant expression EXP with a constant-descriptor DESC.
2484    Return 1 if DESC describes a constant with the same value as EXP.  */
2485
2486 static int
2487 compare_constant (exp, desc)
2488      tree exp;
2489      struct constant_descriptor *desc;
2490 {
2491   return 0 != compare_constant_1 (exp, desc->contents);
2492 }
2493
2494 /* Compare constant expression EXP with a substring P of a constant descriptor.
2495    If they match, return a pointer to the end of the substring matched.
2496    If they do not match, return 0.
2497
2498    Since descriptors are written in polish prefix notation,
2499    this function can be used recursively to test one operand of EXP
2500    against a subdescriptor, and if it succeeds it returns the
2501    address of the subdescriptor for the next operand.  */
2502
2503 static char *
2504 compare_constant_1 (exp, p)
2505      tree exp;
2506      char *p;
2507 {
2508   register char *strp;
2509   register int len;
2510   register enum tree_code code = TREE_CODE (exp);
2511
2512   if (code != (enum tree_code) *p++)
2513     return 0;
2514
2515   /* Either set STRP, P and LEN to pointers and length to compare and exit the
2516      switch, or return the result of the comparison.  */
2517
2518   switch (code)
2519     {
2520     case INTEGER_CST:
2521       /* Integer constants are the same only if the same width of type.  */
2522       if (*p++ != TYPE_PRECISION (TREE_TYPE (exp)))
2523         return 0;
2524
2525       strp = (char *) &TREE_INT_CST_LOW (exp);
2526       len = 2 * sizeof TREE_INT_CST_LOW (exp);
2527       break;
2528
2529     case REAL_CST:
2530       /* Real constants are the same only if the same width of type.  */
2531       if (*p++ != TYPE_PRECISION (TREE_TYPE (exp)))
2532         return 0;
2533
2534       strp = (char *) &TREE_REAL_CST (exp);
2535       len = sizeof TREE_REAL_CST (exp);
2536       break;
2537
2538     case STRING_CST:
2539       if (flag_writable_strings)
2540         return 0;
2541
2542       if (*p++ != TYPE_MODE (TREE_TYPE (exp)))
2543         return 0;
2544
2545       strp = TREE_STRING_POINTER (exp);
2546       len = TREE_STRING_LENGTH (exp);
2547       if (bcmp ((char *) &TREE_STRING_LENGTH (exp), p,
2548                 sizeof TREE_STRING_LENGTH (exp)))
2549         return 0;
2550
2551       p += sizeof TREE_STRING_LENGTH (exp);
2552       break;
2553
2554     case COMPLEX_CST:
2555       p = compare_constant_1 (TREE_REALPART (exp), p);
2556       if (p == 0)
2557         return 0;
2558
2559       return compare_constant_1 (TREE_IMAGPART (exp), p);
2560
2561     case CONSTRUCTOR:
2562       if (TREE_CODE (TREE_TYPE (exp)) == SET_TYPE)
2563         {
2564           int xlen = len = int_size_in_bytes (TREE_TYPE (exp));
2565
2566           strp = (char *) alloca (len);
2567           get_set_constructor_bytes (exp, (unsigned char *) strp, len);
2568           if (bcmp ((char *) &xlen, p, sizeof xlen))
2569             return 0;
2570
2571           p += sizeof xlen;
2572           break;
2573         }
2574       else
2575         {
2576           register tree link;
2577           int length = list_length (CONSTRUCTOR_ELTS (exp));
2578           tree type;
2579           enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
2580           int have_purpose = 0;
2581
2582           for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
2583             if (TREE_PURPOSE (link))
2584               have_purpose = 1;
2585
2586           if (bcmp ((char *) &length, p, sizeof length))
2587             return 0;
2588
2589           p += sizeof length;
2590
2591           /* For record constructors, insist that the types match.
2592              For arrays, just verify both constructors are for arrays.
2593              Then insist that either both or none have any TREE_PURPOSE
2594              values.  */
2595           if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
2596             type = TREE_TYPE (exp);
2597           else
2598             type = 0;
2599
2600           if (bcmp ((char *) &type, p, sizeof type))
2601             return 0;
2602
2603           if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
2604             {
2605               if (bcmp ((char *) &mode, p, sizeof mode))
2606                 return 0;
2607
2608               p += sizeof mode;
2609             }
2610
2611           p += sizeof type;
2612
2613           if (bcmp ((char *) &have_purpose, p, sizeof have_purpose))
2614             return 0;
2615
2616           p += sizeof have_purpose;
2617
2618           /* For arrays, insist that the size in bytes match.  */
2619           if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
2620             {
2621               HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (exp));
2622
2623               if (bcmp ((char *) &size, p, sizeof size))
2624                 return 0;
2625
2626               p += sizeof size;
2627             }
2628
2629           for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
2630             {
2631               if (TREE_VALUE (link))
2632                 {
2633                   if ((p = compare_constant_1 (TREE_VALUE (link), p)) == 0)
2634                     return 0;
2635                 }
2636               else
2637                 {
2638                   tree zero = 0;
2639
2640                   if (bcmp ((char *) &zero, p, sizeof zero))
2641                     return 0;
2642
2643                   p += sizeof zero;
2644                 }
2645
2646               if (TREE_PURPOSE (link)
2647                   && TREE_CODE (TREE_PURPOSE (link)) == FIELD_DECL)
2648                 {
2649                   if (bcmp ((char *) &TREE_PURPOSE (link), p,
2650                             sizeof TREE_PURPOSE (link)))
2651                     return 0;
2652
2653                   p += sizeof TREE_PURPOSE (link);
2654                 }
2655               else if (TREE_PURPOSE (link))
2656                 {
2657                   if ((p = compare_constant_1 (TREE_PURPOSE (link), p)) == 0)
2658                     return 0;
2659                 }
2660               else if (have_purpose)
2661                 {
2662                   int zero = 0;
2663
2664                   if (bcmp ((char *) &zero, p, sizeof zero))
2665                     return 0;
2666
2667                   p += sizeof zero;
2668                 }
2669             }
2670
2671           return p;
2672         }
2673
2674     case ADDR_EXPR:
2675       {
2676         struct addr_const value;
2677
2678         decode_addr_const (exp, &value);
2679         strp = (char *) &value.offset;
2680         len = sizeof value.offset;
2681         /* Compare the offset.  */
2682         while (--len >= 0)
2683           if (*p++ != *strp++)
2684             return 0;
2685
2686         /* Compare symbol name.  */
2687         strp = XSTR (value.base, 0);
2688         len = strlen (strp) + 1;
2689       }
2690       break;
2691
2692     case PLUS_EXPR:
2693     case MINUS_EXPR:
2694     case RANGE_EXPR:
2695       p = compare_constant_1 (TREE_OPERAND (exp, 0), p);
2696       if (p == 0)
2697         return 0;
2698
2699       return compare_constant_1 (TREE_OPERAND (exp, 1), p);
2700
2701     case NOP_EXPR:
2702     case CONVERT_EXPR:
2703     case NON_LVALUE_EXPR:
2704       return compare_constant_1 (TREE_OPERAND (exp, 0), p);
2705
2706     default:
2707       abort ();
2708     }
2709
2710   /* Compare constant contents.  */
2711   while (--len >= 0)
2712     if (*p++ != *strp++)
2713       return 0;
2714
2715   return p;
2716 }
2717 \f
2718 /* Construct a constant descriptor for the expression EXP.
2719    It is up to the caller to enter the descriptor in the hash table.  */
2720
2721 static struct constant_descriptor *
2722 record_constant (exp)
2723      tree exp;
2724 {
2725   struct constant_descriptor *next = 0;
2726   char *label = 0;
2727   rtx rtl = 0;
2728
2729   /* Make a struct constant_descriptor.  The first three pointers will
2730      be filled in later.  Here we just leave space for them.  */
2731
2732   obstack_grow (&permanent_obstack, (char *) &next, sizeof next);
2733   obstack_grow (&permanent_obstack, (char *) &label, sizeof label);
2734   obstack_grow (&permanent_obstack, (char *) &rtl, sizeof rtl);
2735   record_constant_1 (exp);
2736   return (struct constant_descriptor *) obstack_finish (&permanent_obstack);
2737 }
2738
2739 /* Add a description of constant expression EXP
2740    to the object growing in `permanent_obstack'.
2741    No need to return its address; the caller will get that
2742    from the obstack when the object is complete.  */
2743
2744 static void
2745 record_constant_1 (exp)
2746      tree exp;
2747 {
2748   register char *strp;
2749   register int len;
2750   register enum tree_code code = TREE_CODE (exp);
2751
2752   obstack_1grow (&permanent_obstack, (unsigned int) code);
2753
2754   switch (code)
2755     {
2756     case INTEGER_CST:
2757       obstack_1grow (&permanent_obstack, TYPE_PRECISION (TREE_TYPE (exp)));
2758       strp = (char *) &TREE_INT_CST_LOW (exp);
2759       len = 2 * sizeof TREE_INT_CST_LOW (exp);
2760       break;
2761
2762     case REAL_CST:
2763       obstack_1grow (&permanent_obstack, TYPE_PRECISION (TREE_TYPE (exp)));
2764       strp = (char *) &TREE_REAL_CST (exp);
2765       len = sizeof TREE_REAL_CST (exp);
2766       break;
2767
2768     case STRING_CST:
2769       if (flag_writable_strings)
2770         return;
2771
2772       obstack_1grow (&permanent_obstack, TYPE_MODE (TREE_TYPE (exp)));
2773       strp = TREE_STRING_POINTER (exp);
2774       len = TREE_STRING_LENGTH (exp);
2775       obstack_grow (&permanent_obstack, (char *) &TREE_STRING_LENGTH (exp),
2776                     sizeof TREE_STRING_LENGTH (exp));
2777       break;
2778
2779     case COMPLEX_CST:
2780       record_constant_1 (TREE_REALPART (exp));
2781       record_constant_1 (TREE_IMAGPART (exp));
2782       return;
2783
2784     case CONSTRUCTOR:
2785       if (TREE_CODE (TREE_TYPE (exp)) == SET_TYPE)
2786         {
2787           int nbytes = int_size_in_bytes (TREE_TYPE (exp));
2788           obstack_grow (&permanent_obstack, &nbytes, sizeof (nbytes));
2789           obstack_blank (&permanent_obstack, nbytes);
2790           get_set_constructor_bytes
2791             (exp, (unsigned char *) permanent_obstack.next_free-nbytes,
2792              nbytes);
2793           return;
2794         }
2795       else
2796         {
2797           register tree link;
2798           int length = list_length (CONSTRUCTOR_ELTS (exp));
2799           enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
2800           tree type;
2801           int have_purpose = 0;
2802
2803           for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
2804             if (TREE_PURPOSE (link))
2805               have_purpose = 1;
2806
2807           obstack_grow (&permanent_obstack, (char *) &length, sizeof length);
2808
2809           /* For record constructors, insist that the types match.
2810              For arrays, just verify both constructors are for arrays
2811              of the same mode.  Then insist that either both or none
2812              have any TREE_PURPOSE values.  */
2813           if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
2814             type = TREE_TYPE (exp);
2815           else
2816             type = 0;
2817
2818           obstack_grow (&permanent_obstack, (char *) &type, sizeof type);
2819           if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
2820             obstack_grow (&permanent_obstack, &mode, sizeof mode);
2821
2822           obstack_grow (&permanent_obstack, (char *) &have_purpose,
2823                         sizeof have_purpose);
2824
2825           /* For arrays, insist that the size in bytes match.  */
2826           if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
2827             {
2828               HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (exp));
2829               obstack_grow (&permanent_obstack, (char *) &size, sizeof size);
2830             }
2831
2832           for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
2833             {
2834               if (TREE_VALUE (link))
2835                 record_constant_1 (TREE_VALUE (link));
2836               else
2837                 {
2838                   tree zero = 0;
2839
2840                   obstack_grow (&permanent_obstack,
2841                                 (char *) &zero, sizeof zero);
2842                 }
2843
2844               if (TREE_PURPOSE (link)
2845                   && TREE_CODE (TREE_PURPOSE (link)) == FIELD_DECL)
2846                 obstack_grow (&permanent_obstack,
2847                               (char *) &TREE_PURPOSE (link),
2848                               sizeof TREE_PURPOSE (link));
2849               else if (TREE_PURPOSE (link))
2850                 record_constant_1 (TREE_PURPOSE (link));
2851               else if (have_purpose)
2852                 {
2853                   int zero = 0;
2854
2855                   obstack_grow (&permanent_obstack,
2856                                 (char *) &zero, sizeof zero);
2857                 }
2858             }
2859         }
2860       return;
2861
2862     case ADDR_EXPR:
2863       {
2864         struct addr_const value;
2865
2866         decode_addr_const (exp, &value);
2867         /* Record the offset.  */
2868         obstack_grow (&permanent_obstack,
2869                       (char *) &value.offset, sizeof value.offset);
2870         /* Record the symbol name.  */
2871         obstack_grow (&permanent_obstack, XSTR (value.base, 0),
2872                       strlen (XSTR (value.base, 0)) + 1);
2873       }
2874       return;
2875
2876     case PLUS_EXPR:
2877     case MINUS_EXPR:
2878     case RANGE_EXPR:
2879       record_constant_1 (TREE_OPERAND (exp, 0));
2880       record_constant_1 (TREE_OPERAND (exp, 1));
2881       return;
2882
2883     case NOP_EXPR:
2884     case CONVERT_EXPR:
2885     case NON_LVALUE_EXPR:
2886       record_constant_1 (TREE_OPERAND (exp, 0));
2887       return;
2888
2889     default:
2890       abort ();
2891     }
2892
2893   /* Record constant contents.  */
2894   obstack_grow (&permanent_obstack, strp, len);
2895 }
2896 \f
2897 /* Record a list of constant expressions that were passed to
2898    output_constant_def but that could not be output right away.  */
2899
2900 struct deferred_constant
2901 {
2902   struct deferred_constant *next;
2903   tree exp;
2904   int reloc;
2905   int labelno;
2906 };
2907
2908 static struct deferred_constant *deferred_constants;
2909
2910 /* Another list of constants which should be output after the
2911    function.  */
2912 static struct deferred_constant *after_function_constants;
2913
2914 /* Nonzero means defer output of addressed subconstants
2915    (i.e., those for which output_constant_def is called.)  */
2916 static int defer_addressed_constants_flag;
2917
2918 /* Start deferring output of subconstants.  */
2919
2920 void
2921 defer_addressed_constants ()
2922 {
2923   defer_addressed_constants_flag++;
2924 }
2925
2926 /* Stop deferring output of subconstants,
2927    and output now all those that have been deferred.  */
2928
2929 void
2930 output_deferred_addressed_constants ()
2931 {
2932   struct deferred_constant *p, *next;
2933
2934   defer_addressed_constants_flag--;
2935
2936   if (defer_addressed_constants_flag > 0)
2937     return;
2938
2939   for (p = deferred_constants; p; p = next)
2940     {
2941       output_constant_def_contents (p->exp, p->reloc, p->labelno);
2942       next = p->next;
2943       free (p);
2944     }
2945
2946   deferred_constants = 0;
2947 }
2948
2949 /* Output any constants which should appear after a function.  */
2950
2951 static void
2952 output_after_function_constants ()
2953 {
2954   struct deferred_constant *p, *next;
2955
2956   for (p = after_function_constants; p; p = next)
2957     {
2958       output_constant_def_contents (p->exp, p->reloc, p->labelno);
2959       next = p->next;
2960       free (p);
2961     }
2962
2963   after_function_constants = 0;
2964 }
2965
2966 /* Make a copy of the whole tree structure for a constant.
2967    This handles the same types of nodes that compare_constant
2968    and record_constant handle.  */
2969
2970 static tree
2971 copy_constant (exp)
2972      tree exp;
2973 {
2974   switch (TREE_CODE (exp))
2975     {
2976     case ADDR_EXPR:
2977       /* For ADDR_EXPR, we do not want to copy the decl whose address
2978          is requested.  We do want to copy constants though.  */
2979       if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 0))) == 'c')
2980         return build1 (TREE_CODE (exp), TREE_TYPE (exp),
2981                        copy_constant (TREE_OPERAND (exp, 0)));
2982       else
2983         return copy_node (exp);
2984
2985     case INTEGER_CST:
2986     case REAL_CST:
2987     case STRING_CST:
2988       return copy_node (exp);
2989
2990     case COMPLEX_CST:
2991       return build_complex (TREE_TYPE (exp),
2992                             copy_constant (TREE_REALPART (exp)),
2993                             copy_constant (TREE_IMAGPART (exp)));
2994
2995     case PLUS_EXPR:
2996     case MINUS_EXPR:
2997       return build (TREE_CODE (exp), TREE_TYPE (exp),
2998                     copy_constant (TREE_OPERAND (exp, 0)),
2999                     copy_constant (TREE_OPERAND (exp, 1)));
3000
3001     case NOP_EXPR:
3002     case CONVERT_EXPR:
3003     case NON_LVALUE_EXPR:
3004       return build1 (TREE_CODE (exp), TREE_TYPE (exp),
3005                      copy_constant (TREE_OPERAND (exp, 0)));
3006
3007     case CONSTRUCTOR:
3008       {
3009         tree copy = copy_node (exp);
3010         tree list = copy_list (CONSTRUCTOR_ELTS (exp));
3011         tree tail;
3012
3013         CONSTRUCTOR_ELTS (copy) = list;
3014         for (tail = list; tail; tail = TREE_CHAIN (tail))
3015           TREE_VALUE (tail) = copy_constant (TREE_VALUE (tail));
3016         if (TREE_CODE (TREE_TYPE (exp)) == SET_TYPE)
3017           for (tail = list; tail; tail = TREE_CHAIN (tail))
3018             TREE_PURPOSE (tail) = copy_constant (TREE_PURPOSE (tail));
3019
3020         return copy;
3021       }
3022
3023     default:
3024       abort ();
3025     }
3026 }
3027 \f
3028 /* Return an rtx representing a reference to constant data in memory
3029    for the constant expression EXP.
3030
3031    If assembler code for such a constant has already been output,
3032    return an rtx to refer to it.
3033    Otherwise, output such a constant in memory (or defer it for later)
3034    and generate an rtx for it.
3035
3036    The TREE_CST_RTL of EXP is set up to point to that rtx.
3037    The const_hash_table records which constants already have label strings.  */
3038
3039 rtx
3040 output_constant_def (exp)
3041      tree exp;
3042 {
3043   register int hash;
3044   register struct constant_descriptor *desc;
3045   char label[256];
3046   int reloc;
3047   int found = 1;
3048
3049   if (TREE_CST_RTL (exp))
3050     return TREE_CST_RTL (exp);
3051
3052   /* Make sure any other constants whose addresses appear in EXP
3053      are assigned label numbers.  */
3054
3055   reloc = output_addressed_constants (exp);
3056
3057   /* Compute hash code of EXP.  Search the descriptors for that hash code
3058      to see if any of them describes EXP.  If yes, the descriptor records
3059      the label number already assigned.  */
3060
3061   hash = const_hash (exp) % MAX_HASH_TABLE;
3062
3063   for (desc = const_hash_table[hash]; desc; desc = desc->next)
3064     if (compare_constant (exp, desc))
3065       break;
3066
3067   if (desc == 0)
3068     {
3069       /* No constant equal to EXP is known to have been output.
3070          Make a constant descriptor to enter EXP in the hash table.
3071          Assign the label number and record it in the descriptor for
3072          future calls to this function to find.  */
3073
3074       /* Create a string containing the label name, in LABEL.  */
3075       ASM_GENERATE_INTERNAL_LABEL (label, "LC", const_labelno);
3076
3077       desc = record_constant (exp);
3078       desc->next = const_hash_table[hash];
3079       desc->label = ggc_alloc_string (label, -1);
3080       const_hash_table[hash] = desc;
3081
3082       /* We have a symbol name; construct the SYMBOL_REF and the MEM
3083          in the permanent obstack.  We could also construct this in the
3084          obstack of EXP and put it into TREE_CST_RTL, but we have no way
3085          of knowing what obstack it is (e.g., it might be in a function
3086          obstack of a function we are nested inside).  */
3087
3088       push_obstacks_nochange ();
3089       end_temporary_allocation ();
3090
3091       desc->rtl
3092         = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (exp)),
3093                        gen_rtx_SYMBOL_REF (Pmode, desc->label));
3094
3095       RTX_UNCHANGING_P (desc->rtl) = 1;
3096       if (AGGREGATE_TYPE_P (TREE_TYPE (exp)))
3097         MEM_SET_IN_STRUCT_P (desc->rtl, 1);
3098
3099       pop_obstacks ();
3100
3101       found = 0;
3102     }
3103
3104   TREE_CST_RTL (exp) = desc->rtl;
3105
3106   /* Optionally set flags or add text to the name to record information
3107      such as that it is a function name.  If the name is changed, the macro
3108      ASM_OUTPUT_LABELREF will have to know how to strip this information.  */
3109 #ifdef ENCODE_SECTION_INFO
3110   ENCODE_SECTION_INFO (exp);
3111 #endif
3112
3113   /* If this is the first time we've seen this particular constant,
3114      output it (or defer its output for later).  */
3115   if (! found)
3116     {
3117       int after_function = 0;
3118
3119 #ifdef CONSTANT_AFTER_FUNCTION_P
3120       if (current_function_decl != 0
3121           && CONSTANT_AFTER_FUNCTION_P (exp))
3122         after_function = 1;
3123 #endif
3124
3125       if (defer_addressed_constants_flag || after_function)
3126         {
3127           struct deferred_constant *p;
3128           p = (struct deferred_constant *) xmalloc (sizeof (struct deferred_constant));
3129
3130           push_obstacks_nochange ();
3131           suspend_momentary ();
3132           p->exp = copy_constant (exp);
3133           pop_obstacks ();
3134           p->reloc = reloc;
3135           p->labelno = const_labelno++;
3136           if (after_function)
3137             {
3138               p->next = after_function_constants;
3139               after_function_constants = p;
3140             }
3141           else
3142             {
3143               p->next = deferred_constants;
3144               deferred_constants = p;
3145             }
3146         }
3147       else
3148         {
3149           /* Do no output if -fsyntax-only.  */
3150           if (! flag_syntax_only)
3151             output_constant_def_contents (exp, reloc, const_labelno);
3152           ++const_labelno;
3153         }
3154     }
3155
3156   return TREE_CST_RTL (exp);
3157 }
3158
3159 /* Now output assembler code to define the label for EXP,
3160    and follow it with the data of EXP.  */
3161
3162 static void
3163 output_constant_def_contents (exp, reloc, labelno)
3164      tree exp;
3165      int reloc;
3166      int labelno;
3167 {
3168   int align;
3169
3170   if (IN_NAMED_SECTION (exp))
3171     named_section (exp, NULL, reloc);
3172   else
3173     {
3174       /* First switch to text section, except for writable strings.  */
3175 #ifdef SELECT_SECTION
3176       SELECT_SECTION (exp, reloc);
3177 #else
3178       if (((TREE_CODE (exp) == STRING_CST) && flag_writable_strings)
3179           || (flag_pic && reloc))
3180         data_section ();
3181       else
3182         readonly_data_section ();
3183 #endif
3184     }
3185
3186   /* Align the location counter as required by EXP's data type.  */
3187   align = TYPE_ALIGN (TREE_TYPE (exp));
3188 #ifdef CONSTANT_ALIGNMENT
3189   align = CONSTANT_ALIGNMENT (exp, align);
3190 #endif
3191
3192   if (align > BITS_PER_UNIT)
3193     ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
3194
3195   /* Output the label itself.  */
3196   ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LC", labelno);
3197
3198   /* Output the value of EXP.  */
3199   output_constant (exp,
3200                    (TREE_CODE (exp) == STRING_CST
3201                     ? TREE_STRING_LENGTH (exp)
3202                     : int_size_in_bytes (TREE_TYPE (exp))));
3203
3204 }
3205 \f
3206 /* Structure to represent sufficient information about a constant so that
3207    it can be output when the constant pool is output, so that function
3208    integration can be done, and to simplify handling on machines that reference
3209    constant pool as base+displacement.  */
3210
3211 struct pool_constant
3212 {
3213   struct constant_descriptor *desc;
3214   struct pool_constant *next;
3215   enum machine_mode mode;
3216   rtx constant;
3217   int labelno;
3218   int align;
3219   int offset;
3220   int mark;
3221 };
3222
3223 /* Structure used to maintain hash table mapping symbols used to their
3224    corresponding constants.  */
3225
3226 struct pool_sym
3227 {
3228   char *label;
3229   struct pool_constant *pool;
3230   struct pool_sym *next;
3231 };
3232
3233 /* Hash code for a SYMBOL_REF with CONSTANT_POOL_ADDRESS_P true.
3234    The argument is XSTR (... , 0)  */
3235
3236 #define SYMHASH(LABEL)  \
3237   ((((unsigned long) (LABEL)) & ((1 << HASHBITS) - 1))  % MAX_RTX_HASH_TABLE)
3238 \f
3239 /* Initialize constant pool hashing for a new function.  */
3240
3241 void
3242 init_varasm_status (f)
3243      struct function *f;
3244 {
3245   struct varasm_status *p;
3246   p = (struct varasm_status *) xmalloc (sizeof (struct varasm_status));
3247   f->varasm = p;
3248   p->x_const_rtx_hash_table
3249     = ((struct constant_descriptor **)
3250        xmalloc (MAX_RTX_HASH_TABLE * sizeof (struct constant_descriptor *)));
3251   p->x_const_rtx_sym_hash_table
3252     = ((struct pool_sym **)
3253        xmalloc (MAX_RTX_HASH_TABLE * sizeof (struct pool_sym *)));
3254   bzero ((char *) p->x_const_rtx_hash_table,
3255          MAX_RTX_HASH_TABLE * sizeof (struct constant_descriptor *));
3256   bzero ((char *) p->x_const_rtx_sym_hash_table,
3257          MAX_RTX_HASH_TABLE * sizeof (struct pool_sym *));
3258
3259   p->x_first_pool = p->x_last_pool = 0;
3260   p->x_pool_offset = 0;
3261   p->x_const_double_chain = 0;
3262 }
3263
3264 /* Mark PC for GC.  */
3265
3266 static void
3267 mark_pool_constant (pc)
3268      struct pool_constant *pc;
3269 {
3270   while (pc)
3271     {
3272       ggc_mark_rtx (pc->constant);
3273       pc = pc->next;
3274     }
3275 }
3276
3277 /* Mark PPS for GC.  */
3278
3279 static void
3280 mark_pool_sym_hash_table (pps)
3281      struct pool_sym **pps;
3282 {
3283   struct pool_sym *ps;
3284   int i;
3285
3286   for (i = 0; i < MAX_RTX_HASH_TABLE; ++i)
3287     for (ps = pps[i]; ps ; ps = ps->next)
3288       ggc_mark_string (ps->label);
3289 }
3290
3291 /* Mark P for GC.  */
3292
3293 void
3294 mark_varasm_status (p)
3295      struct varasm_status *p;
3296 {
3297   if (p == NULL)
3298     return;
3299
3300   mark_pool_constant (p->x_first_pool);
3301   mark_pool_sym_hash_table (p->x_const_rtx_sym_hash_table);
3302   ggc_mark_rtx (p->x_const_double_chain);
3303 }
3304
3305 /* Clear out all parts of the state in F that can safely be discarded
3306    after the function has been compiled, to let garbage collection
3307    reclaim the memory.  */
3308
3309 void
3310 free_varasm_status (f)
3311      struct function *f;
3312 {
3313   struct varasm_status *p;
3314
3315   p = f->varasm;
3316   free (p->x_const_rtx_hash_table);
3317   free (p->x_const_rtx_sym_hash_table);
3318   free (p);
3319   f->varasm = NULL;
3320 }
3321 \f
3322 enum kind { RTX_DOUBLE, RTX_INT };
3323
3324 struct rtx_const
3325 {
3326 #ifdef ONLY_INT_FIELDS
3327   unsigned int kind : 16;
3328   unsigned int mode : 16;
3329 #else
3330   enum kind kind : 16;
3331   enum machine_mode mode : 16;
3332 #endif
3333   union {
3334     union real_extract du;
3335     struct addr_const addr;
3336     struct {HOST_WIDE_INT high, low;} di;
3337   } un;
3338 };
3339
3340 /* Express an rtx for a constant integer (perhaps symbolic)
3341    as the sum of a symbol or label plus an explicit integer.
3342    They are stored into VALUE.  */
3343
3344 static void
3345 decode_rtx_const (mode, x, value)
3346      enum machine_mode mode;
3347      rtx x;
3348      struct rtx_const *value;
3349 {
3350   /* Clear the whole structure, including any gaps.  */
3351
3352   {
3353     int *p = (int *) value;
3354     int *end = (int *) (value + 1);
3355     while (p < end)
3356       *p++ = 0;
3357   }
3358
3359   value->kind = RTX_INT;        /* Most usual kind.  */
3360   value->mode = mode;
3361
3362   switch (GET_CODE (x))
3363     {
3364     case CONST_DOUBLE:
3365       value->kind = RTX_DOUBLE;
3366       if (GET_MODE (x) != VOIDmode)
3367         {
3368           value->mode = GET_MODE (x);
3369           bcopy ((char *) &CONST_DOUBLE_LOW (x),
3370                  (char *) &value->un.du, sizeof value->un.du);
3371         }
3372       else
3373         {
3374           value->un.di.low = CONST_DOUBLE_LOW (x);
3375           value->un.di.high = CONST_DOUBLE_HIGH (x);
3376         }
3377       break;
3378
3379     case CONST_INT:
3380       value->un.addr.offset = INTVAL (x);
3381       break;
3382
3383     case SYMBOL_REF:
3384     case LABEL_REF:
3385     case PC:
3386       value->un.addr.base = x;
3387       break;
3388
3389     case CONST:
3390       x = XEXP (x, 0);
3391       if (GET_CODE (x) == PLUS)
3392         {
3393           value->un.addr.base = XEXP (x, 0);
3394           if (GET_CODE (XEXP (x, 1)) != CONST_INT)
3395             abort ();
3396           value->un.addr.offset = INTVAL (XEXP (x, 1));
3397         }
3398       else if (GET_CODE (x) == MINUS)
3399         {
3400           value->un.addr.base = XEXP (x, 0);
3401           if (GET_CODE (XEXP (x, 1)) != CONST_INT)
3402             abort ();
3403           value->un.addr.offset = - INTVAL (XEXP (x, 1));
3404         }
3405       else
3406         abort ();
3407       break;
3408
3409     default:
3410       abort ();
3411     }
3412
3413   if (value->kind == RTX_INT && value->un.addr.base != 0)
3414     switch (GET_CODE (value->un.addr.base))
3415       {
3416       case SYMBOL_REF:
3417         /* Use the string's address, not the SYMBOL_REF's address,
3418            for the sake of addresses of library routines.  */
3419         value->un.addr.base = (rtx) XSTR (value->un.addr.base, 0);
3420         break;
3421
3422       case LABEL_REF:
3423         /* For a LABEL_REF, compare labels.  */
3424         value->un.addr.base = XEXP (value->un.addr.base, 0);
3425
3426       default:
3427         break;
3428       }
3429 }
3430
3431 /* Given a MINUS expression, simplify it if both sides
3432    include the same symbol.  */
3433
3434 rtx
3435 simplify_subtraction (x)
3436      rtx x;
3437 {
3438   struct rtx_const val0, val1;
3439
3440   decode_rtx_const (GET_MODE (x), XEXP (x, 0), &val0);
3441   decode_rtx_const (GET_MODE (x), XEXP (x, 1), &val1);
3442
3443   if (val0.un.addr.base == val1.un.addr.base)
3444     return GEN_INT (val0.un.addr.offset - val1.un.addr.offset);
3445   return x;
3446 }
3447
3448 /* Compute a hash code for a constant RTL expression.  */
3449
3450 static int
3451 const_hash_rtx (mode, x)
3452      enum machine_mode mode;
3453      rtx x;
3454 {
3455   register int hi;
3456   register size_t i;
3457
3458   struct rtx_const value;
3459   decode_rtx_const (mode, x, &value);
3460
3461   /* Compute hashing function */
3462   hi = 0;
3463   for (i = 0; i < sizeof value / sizeof (int); i++)
3464     hi += ((int *) &value)[i];
3465
3466   hi &= (1 << HASHBITS) - 1;
3467   hi %= MAX_RTX_HASH_TABLE;
3468   return hi;
3469 }
3470
3471 /* Compare a constant rtl object X with a constant-descriptor DESC.
3472    Return 1 if DESC describes a constant with the same value as X.  */
3473
3474 static int
3475 compare_constant_rtx (mode, x, desc)
3476      enum machine_mode mode;
3477      rtx x;
3478      struct constant_descriptor *desc;
3479 {
3480   register int *p = (int *) desc->contents;
3481   register int *strp;
3482   register int len;
3483   struct rtx_const value;
3484
3485   decode_rtx_const (mode, x, &value);
3486   strp = (int *) &value;
3487   len = sizeof value / sizeof (int);
3488
3489   /* Compare constant contents.  */
3490   while (--len >= 0)
3491     if (*p++ != *strp++)
3492       return 0;
3493
3494   return 1;
3495 }
3496
3497 /* Construct a constant descriptor for the rtl-expression X.
3498    It is up to the caller to enter the descriptor in the hash table.  */
3499
3500 static struct constant_descriptor *
3501 record_constant_rtx (mode, x)
3502      enum machine_mode mode;
3503      rtx x;
3504 {
3505   struct constant_descriptor *ptr;
3506   char *label;
3507   rtx rtl;
3508   struct rtx_const value;
3509
3510   decode_rtx_const (mode, x, &value);
3511
3512   /* Put these things in the saveable obstack so we can ensure it won't
3513      be freed if we are called from combine or some other phase that discards
3514      memory allocated from function_obstack (current_obstack).  */
3515   obstack_grow (saveable_obstack, &ptr, sizeof ptr);
3516   obstack_grow (saveable_obstack, &label, sizeof label);
3517   obstack_grow (saveable_obstack, &rtl, sizeof rtl);
3518
3519   /* Record constant contents.  */
3520   obstack_grow (saveable_obstack, &value, sizeof value);
3521
3522   return (struct constant_descriptor *) obstack_finish (saveable_obstack);
3523 }
3524 \f
3525 /* Given a constant rtx X, make (or find) a memory constant for its value
3526    and return a MEM rtx to refer to it in memory.  */
3527
3528 rtx
3529 force_const_mem (mode, x)
3530      enum machine_mode mode;
3531      rtx x;
3532 {
3533   register int hash;
3534   register struct constant_descriptor *desc;
3535   char label[256];
3536   char *found = 0;
3537   rtx def;
3538
3539   /* If we want this CONST_DOUBLE in the same mode as it is in memory
3540      (this will always be true for floating CONST_DOUBLEs that have been
3541      placed in memory, but not for VOIDmode (integer) CONST_DOUBLEs),
3542      use the previous copy.  Otherwise, make a new one.  Note that in
3543      the unlikely event that this same CONST_DOUBLE is used in two different
3544      modes in an alternating fashion, we will allocate a lot of different
3545      memory locations, but this should be extremely rare.  */
3546
3547   if (GET_CODE (x) == CONST_DOUBLE
3548       && GET_CODE (CONST_DOUBLE_MEM (x)) == MEM
3549       && GET_MODE (CONST_DOUBLE_MEM (x)) == mode)
3550     return CONST_DOUBLE_MEM (x);
3551
3552   /* Compute hash code of X.  Search the descriptors for that hash code
3553      to see if any of them describes X.  If yes, the descriptor records
3554      the label number already assigned.  */
3555
3556   hash = const_hash_rtx (mode, x);
3557
3558   for (desc = const_rtx_hash_table[hash]; desc; desc = desc->next)
3559     if (compare_constant_rtx (mode, x, desc))
3560       {
3561         found = desc->label;
3562         break;
3563       }
3564
3565   if (found == 0)
3566     {
3567       register struct pool_constant *pool;
3568       register struct pool_sym *sym;
3569       int align;
3570
3571       /* No constant equal to X is known to have been output.
3572          Make a constant descriptor to enter X in the hash table.
3573          Assign the label number and record it in the descriptor for
3574          future calls to this function to find.  */
3575
3576       desc = record_constant_rtx (mode, x);
3577       desc->next = const_rtx_hash_table[hash];
3578       const_rtx_hash_table[hash] = desc;
3579
3580       /* Align the location counter as required by EXP's data type.  */
3581       align = (mode == VOIDmode) ? UNITS_PER_WORD : GET_MODE_SIZE (mode);
3582       if (align > BIGGEST_ALIGNMENT / BITS_PER_UNIT)
3583         align = BIGGEST_ALIGNMENT / BITS_PER_UNIT;
3584 #ifdef CONSTANT_ALIGNMENT
3585       align = CONSTANT_ALIGNMENT (make_tree (type_for_mode (mode, 0), x),
3586                                  align * BITS_PER_UNIT) / BITS_PER_UNIT;
3587 #endif
3588
3589       pool_offset += align - 1;
3590       pool_offset &= ~ (align - 1);
3591
3592       /* If RTL is not being placed into the saveable obstack, make a
3593          copy of X that is in the saveable obstack in case we are
3594          being called from combine or some other phase that discards
3595          memory it allocates.  We used to only do this if it is a
3596          CONST; however, reload can allocate a CONST_INT when
3597          eliminating registers.  */
3598       if (rtl_obstack != saveable_obstack
3599           && (GET_CODE (x) == CONST || GET_CODE (x) == CONST_INT))
3600         {
3601           push_obstacks_nochange ();
3602           rtl_in_saveable_obstack ();
3603
3604           if (GET_CODE (x) == CONST)
3605             x = gen_rtx_CONST (GET_MODE (x),
3606                                gen_rtx_PLUS (GET_MODE (x),
3607                                              XEXP (XEXP (x, 0), 0),
3608                                              XEXP (XEXP (x, 0), 1)));
3609           else
3610             x = GEN_INT (INTVAL (x));
3611
3612           pop_obstacks ();
3613         }
3614
3615       /* Allocate a pool constant descriptor, fill it in, and chain it in.  */
3616
3617       pool = (struct pool_constant *) savealloc (sizeof (struct pool_constant));
3618       pool->desc = desc;
3619       pool->constant = x;
3620       pool->mode = mode;
3621       pool->labelno = const_labelno;
3622       pool->align = align;
3623       pool->offset = pool_offset;
3624       pool->mark = 1;
3625       pool->next = 0;
3626
3627       if (last_pool == 0)
3628         first_pool = pool;
3629       else
3630         last_pool->next = pool;
3631
3632       last_pool = pool;
3633       pool_offset += GET_MODE_SIZE (mode);
3634
3635       /* Create a string containing the label name, in LABEL.  */
3636       ASM_GENERATE_INTERNAL_LABEL (label, "LC", const_labelno);
3637
3638       ++const_labelno;
3639
3640       desc->label = found = ggc_alloc_string (label, -1);
3641
3642       /* Add label to symbol hash table.  */
3643       hash = SYMHASH (found);
3644       sym = (struct pool_sym *) savealloc (sizeof (struct pool_sym));
3645       sym->label = found;
3646       sym->pool = pool;
3647       sym->next = const_rtx_sym_hash_table[hash];
3648       const_rtx_sym_hash_table[hash] = sym;
3649     }
3650
3651   /* We have a symbol name; construct the SYMBOL_REF and the MEM.  */
3652
3653   def = gen_rtx_MEM (mode, gen_rtx_SYMBOL_REF (Pmode, found));
3654
3655   RTX_UNCHANGING_P (def) = 1;
3656   /* Mark the symbol_ref as belonging to this constants pool.  */
3657   CONSTANT_POOL_ADDRESS_P (XEXP (def, 0)) = 1;
3658   current_function_uses_const_pool = 1;
3659
3660   if (GET_CODE (x) == CONST_DOUBLE)
3661     {
3662       if (CONST_DOUBLE_MEM (x) == cc0_rtx)
3663         {
3664           CONST_DOUBLE_CHAIN (x) = const_double_chain;
3665           const_double_chain = x;
3666         }
3667       CONST_DOUBLE_MEM (x) = def;
3668     }
3669
3670   return def;
3671 }
3672 \f
3673 /* Given a SYMBOL_REF with CONSTANT_POOL_ADDRESS_P true, return a pointer to
3674    the corresponding pool_constant structure.  */
3675
3676 static struct pool_constant *
3677 find_pool_constant (f, addr)
3678      struct function *f;
3679      rtx addr;
3680 {
3681   struct pool_sym *sym;
3682   char *label = XSTR (addr, 0);
3683
3684   for (sym = f->varasm->x_const_rtx_sym_hash_table[SYMHASH (label)]; sym; sym = sym->next)
3685     if (sym->label == label)
3686       return sym->pool;
3687
3688   abort ();
3689 }
3690
3691 /* Given a constant pool SYMBOL_REF, return the corresponding constant.  */
3692
3693 rtx
3694 get_pool_constant (addr)
3695      rtx addr;
3696 {
3697   return (find_pool_constant (cfun, addr))->constant;
3698 }
3699
3700 /* Likewise, but for the constant pool of a specific function.  */
3701
3702 rtx
3703 get_pool_constant_for_function (f, addr)
3704      struct function *f;
3705      rtx addr;
3706 {
3707   return (find_pool_constant (f, addr))->constant;
3708 }
3709
3710 /* Similar, return the mode.  */
3711
3712 enum machine_mode
3713 get_pool_mode (addr)
3714      rtx addr;
3715 {
3716   return (find_pool_constant (cfun, addr))->mode;
3717 }
3718
3719 enum machine_mode
3720 get_pool_mode_for_function (f, addr)
3721      struct function *f;
3722      rtx addr;
3723 {
3724   return (find_pool_constant (f, addr))->mode;
3725 }
3726
3727 /* Similar, return the offset in the constant pool.  */
3728
3729 int
3730 get_pool_offset (addr)
3731      rtx addr;
3732 {
3733   return (find_pool_constant (cfun, addr))->offset;
3734 }
3735
3736 /* Return the size of the constant pool.  */
3737
3738 int
3739 get_pool_size ()
3740 {
3741   return pool_offset;
3742 }
3743 \f
3744 /* Write all the constants in the constant pool.  */
3745
3746 void
3747 output_constant_pool (fnname, fndecl)
3748   const char *fnname ATTRIBUTE_UNUSED;
3749   tree fndecl ATTRIBUTE_UNUSED;
3750 {
3751   struct pool_constant *pool;
3752   rtx x;
3753   union real_extract u;
3754
3755   /* It is possible for gcc to call force_const_mem and then to later
3756      discard the instructions which refer to the constant.  In such a
3757      case we do not need to output the constant.  */
3758   mark_constant_pool ();
3759
3760 #ifdef ASM_OUTPUT_POOL_PROLOGUE
3761   ASM_OUTPUT_POOL_PROLOGUE (asm_out_file, fnname, fndecl, pool_offset);
3762 #endif
3763
3764   for (pool = first_pool; pool; pool = pool->next)
3765     {
3766       x = pool->constant;
3767
3768       if (! pool->mark)
3769         continue;
3770
3771       /* See if X is a LABEL_REF (or a CONST referring to a LABEL_REF)
3772          whose CODE_LABEL has been deleted.  This can occur if a jump table
3773          is eliminated by optimization.  If so, write a constant of zero
3774          instead.  Note that this can also happen by turning the
3775          CODE_LABEL into a NOTE.  */
3776       if (((GET_CODE (x) == LABEL_REF
3777             && (INSN_DELETED_P (XEXP (x, 0))
3778                 || GET_CODE (XEXP (x, 0)) == NOTE)))
3779           || (GET_CODE (x) == CONST && GET_CODE (XEXP (x, 0)) == PLUS
3780               && GET_CODE (XEXP (XEXP (x, 0), 0)) == LABEL_REF
3781               && (INSN_DELETED_P (XEXP (XEXP (XEXP (x, 0), 0), 0))
3782                   || GET_CODE (XEXP (XEXP (XEXP (x, 0), 0), 0)) == NOTE)))
3783         x = const0_rtx;
3784
3785       /* First switch to correct section.  */
3786 #ifdef SELECT_RTX_SECTION
3787       SELECT_RTX_SECTION (pool->mode, x);
3788 #else
3789       readonly_data_section ();
3790 #endif
3791
3792 #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
3793       ASM_OUTPUT_SPECIAL_POOL_ENTRY (asm_out_file, x, pool->mode,
3794                                      pool->align, pool->labelno, done);
3795 #endif
3796
3797       if (pool->align > 1)
3798         ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (pool->align));
3799
3800       /* Output the label.  */
3801       ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LC", pool->labelno);
3802
3803       /* Output the value of the constant itself.  */
3804       switch (GET_MODE_CLASS (pool->mode))
3805         {
3806         case MODE_FLOAT:
3807           if (GET_CODE (x) != CONST_DOUBLE)
3808             abort ();
3809
3810           bcopy ((char *) &CONST_DOUBLE_LOW (x), (char *) &u, sizeof u);
3811           assemble_real (u.d, pool->mode);
3812           break;
3813
3814         case MODE_INT:
3815         case MODE_PARTIAL_INT:
3816           assemble_integer (x, GET_MODE_SIZE (pool->mode), 1);
3817           break;
3818
3819         default:
3820           abort ();
3821         }
3822
3823 #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
3824     done: ;
3825 #endif
3826
3827     }
3828
3829 #ifdef ASM_OUTPUT_POOL_EPILOGUE
3830   ASM_OUTPUT_POOL_EPILOGUE (asm_out_file, fnname, fndecl, pool_offset);
3831 #endif
3832
3833   /* Done with this pool.  */
3834   first_pool = last_pool = 0;
3835 }
3836
3837 /* Look through the instructions for this function, and mark all the
3838    entries in the constant pool which are actually being used.  */
3839
3840 static void
3841 mark_constant_pool ()
3842 {
3843   register rtx insn;
3844   struct pool_constant *pool;
3845
3846   if (first_pool == 0)
3847     return;
3848
3849   for (pool = first_pool; pool; pool = pool->next)
3850     pool->mark = 0;
3851
3852   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
3853     if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
3854       mark_constants (PATTERN (insn));
3855
3856   for (insn = current_function_epilogue_delay_list;
3857        insn;
3858        insn = XEXP (insn, 1))
3859     if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
3860       mark_constants (PATTERN (insn));
3861
3862   /* It's possible that the only reference to a symbol is in a symbol
3863      that's in the constant pool.  This happens in Fortran under some
3864      situations.  (When the constant contains the address of another
3865      constant, and only the first is used directly in an insn.)
3866      This is potentially suboptimal if there's ever a possibility of
3867      backwards (in pool order) 2'd level references.  However, it's
3868      not clear that 2'd level references can happen. */
3869   for (pool = first_pool; pool; pool = pool->next)
3870     {
3871       struct pool_sym *sym;
3872       char *label;
3873
3874       /* skip unmarked entries; no insn refers to them. */
3875       if (!pool->mark)
3876           continue;
3877
3878       /* Skip everything except SYMBOL_REFs.  */
3879       if (GET_CODE (pool->constant) != SYMBOL_REF)
3880         continue;
3881       label = XSTR (pool->constant, 0);
3882
3883       /* Be sure the symbol's value is marked. */
3884       for (sym = const_rtx_sym_hash_table[SYMHASH (label)]; sym;
3885            sym = sym->next)
3886           if (sym->label == label)
3887             sym->pool->mark = 1;
3888       /* If we didn't find it, there's something truly wrong here, but it
3889          will be announced by the assembler. */
3890     }
3891 }
3892
3893 static void
3894 mark_constants (x)
3895      register rtx x;
3896 {
3897   register int i;
3898   register const char *format_ptr;
3899
3900   if (x == 0)
3901     return;
3902
3903   if (GET_CODE (x) == SYMBOL_REF)
3904     {
3905       if (CONSTANT_POOL_ADDRESS_P (x))
3906         find_pool_constant (cfun, x)->mark = 1;
3907       return;
3908     }
3909   /* Never search inside a CONST_DOUBLE, because CONST_DOUBLE_MEM may be
3910      a MEM, but does not constitute a use of that MEM.  */
3911   else if (GET_CODE (x) == CONST_DOUBLE)
3912     return;
3913
3914   /* Insns may appear inside a SEQUENCE.  Only check the patterns of
3915      insns, not any notes that may be attached.  We don't want to mark
3916      a constant just because it happens to appear in a REG_EQUIV note.  */
3917   if (GET_RTX_CLASS (GET_CODE (x)) == 'i')
3918     {
3919       mark_constants (PATTERN (x));
3920       return;
3921     }
3922
3923   format_ptr = GET_RTX_FORMAT (GET_CODE (x));
3924
3925   for (i = 0; i < GET_RTX_LENGTH (GET_CODE (x)); i++)
3926     {
3927       switch (*format_ptr++)
3928         {
3929         case 'e':
3930           mark_constants (XEXP (x, i));
3931           break;
3932
3933         case 'E':
3934           if (XVEC (x, i) != 0)
3935             {
3936               register int j;
3937
3938               for (j = 0; j < XVECLEN (x, i); j++)
3939                 mark_constants (XVECEXP (x, i, j));
3940             }
3941           break;
3942
3943         case 'S':
3944         case 's':
3945         case '0':
3946         case 'i':
3947         case 'w':
3948         case 'n':
3949         case 'u':
3950           break;
3951
3952         default:
3953           abort ();
3954         }
3955     }
3956 }
3957 \f
3958 /* Find all the constants whose addresses are referenced inside of EXP,
3959    and make sure assembler code with a label has been output for each one.
3960    Indicate whether an ADDR_EXPR has been encountered.  */
3961
3962 static int
3963 output_addressed_constants (exp)
3964      tree exp;
3965 {
3966   int reloc = 0;
3967
3968   switch (TREE_CODE (exp))
3969     {
3970     case ADDR_EXPR:
3971       {
3972         register tree constant = TREE_OPERAND (exp, 0);
3973
3974         while (TREE_CODE (constant) == COMPONENT_REF)
3975           {
3976             constant = TREE_OPERAND (constant, 0);
3977           }
3978
3979         if (TREE_CODE_CLASS (TREE_CODE (constant)) == 'c'
3980             || TREE_CODE (constant) == CONSTRUCTOR)
3981           /* No need to do anything here
3982              for addresses of variables or functions.  */
3983           output_constant_def (constant);
3984       }
3985       reloc = 1;
3986       break;
3987
3988     case PLUS_EXPR:
3989     case MINUS_EXPR:
3990       reloc = output_addressed_constants (TREE_OPERAND (exp, 0));
3991       reloc |= output_addressed_constants (TREE_OPERAND (exp, 1));
3992       break;
3993
3994     case NOP_EXPR:
3995     case CONVERT_EXPR:
3996     case NON_LVALUE_EXPR:
3997       reloc = output_addressed_constants (TREE_OPERAND (exp, 0));
3998       break;
3999
4000     case CONSTRUCTOR:
4001       {
4002         register tree link;
4003         for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
4004           if (TREE_VALUE (link) != 0)
4005             reloc |= output_addressed_constants (TREE_VALUE (link));
4006       }
4007       break;
4008
4009     default:
4010       break;
4011     }
4012   return reloc;
4013 }
4014 \f
4015 /* Return nonzero if VALUE is a valid constant-valued expression
4016    for use in initializing a static variable; one that can be an
4017    element of a "constant" initializer.
4018
4019    Return null_pointer_node if the value is absolute;
4020    if it is relocatable, return the variable that determines the relocation.
4021    We assume that VALUE has been folded as much as possible;
4022    therefore, we do not need to check for such things as
4023    arithmetic-combinations of integers.  */
4024
4025 tree
4026 initializer_constant_valid_p (value, endtype)
4027      tree value;
4028      tree endtype;
4029 {
4030   switch (TREE_CODE (value))
4031     {
4032     case CONSTRUCTOR:
4033       if ((TREE_CODE (TREE_TYPE (value)) == UNION_TYPE
4034            || TREE_CODE (TREE_TYPE (value)) == RECORD_TYPE)
4035           && TREE_CONSTANT (value)
4036           && CONSTRUCTOR_ELTS (value))
4037         return
4038           initializer_constant_valid_p (TREE_VALUE (CONSTRUCTOR_ELTS (value)),
4039                                         endtype);
4040
4041       return TREE_STATIC (value) ? null_pointer_node : 0;
4042
4043     case INTEGER_CST:
4044     case REAL_CST:
4045     case STRING_CST:
4046     case COMPLEX_CST:
4047       return null_pointer_node;
4048
4049     case ADDR_EXPR:
4050       return TREE_OPERAND (value, 0);
4051
4052     case NON_LVALUE_EXPR:
4053       return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
4054
4055     case CONVERT_EXPR:
4056     case NOP_EXPR:
4057       /* Allow conversions between pointer types.  */
4058       if (POINTER_TYPE_P (TREE_TYPE (value))
4059           && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (value, 0))))
4060         return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
4061
4062       /* Allow conversions between real types.  */
4063       if (FLOAT_TYPE_P (TREE_TYPE (value))
4064           && FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (value, 0))))
4065         return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
4066
4067       /* Allow length-preserving conversions between integer types.  */
4068       if (INTEGRAL_TYPE_P (TREE_TYPE (value))
4069           && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (value, 0)))
4070           && (TYPE_PRECISION (TREE_TYPE (value))
4071               == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value, 0)))))
4072         return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
4073
4074       /* Allow conversions between other integer types only if
4075          explicit value.  */
4076       if (INTEGRAL_TYPE_P (TREE_TYPE (value))
4077           && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (value, 0))))
4078         {
4079           tree inner = initializer_constant_valid_p (TREE_OPERAND (value, 0),
4080                                                      endtype);
4081           if (inner == null_pointer_node)
4082             return null_pointer_node;
4083           break;
4084         }
4085
4086       /* Allow (int) &foo provided int is as wide as a pointer.  */
4087       if (INTEGRAL_TYPE_P (TREE_TYPE (value))
4088           && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (value, 0)))
4089           && (TYPE_PRECISION (TREE_TYPE (value))
4090               >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value, 0)))))
4091         return initializer_constant_valid_p (TREE_OPERAND (value, 0),
4092                                              endtype);
4093
4094       /* Likewise conversions from int to pointers, but also allow
4095          conversions from 0.  */
4096       if (POINTER_TYPE_P (TREE_TYPE (value))
4097           && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (value, 0))))
4098         {
4099           if (integer_zerop (TREE_OPERAND (value, 0)))
4100             return null_pointer_node;
4101           else if (TYPE_PRECISION (TREE_TYPE (value))
4102                    <= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value, 0))))
4103             return initializer_constant_valid_p (TREE_OPERAND (value, 0),
4104                                                  endtype);
4105         }
4106
4107       /* Allow conversions to union types if the value inside is okay.  */
4108       if (TREE_CODE (TREE_TYPE (value)) == UNION_TYPE)
4109         return initializer_constant_valid_p (TREE_OPERAND (value, 0),
4110                                              endtype);
4111       break;
4112
4113     case PLUS_EXPR:
4114       if (! INTEGRAL_TYPE_P (endtype)
4115           || TYPE_PRECISION (endtype) >= POINTER_SIZE)
4116         {
4117           tree valid0 = initializer_constant_valid_p (TREE_OPERAND (value, 0),
4118                                                       endtype);
4119           tree valid1 = initializer_constant_valid_p (TREE_OPERAND (value, 1),
4120                                                       endtype);
4121           /* If either term is absolute, use the other terms relocation.  */
4122           if (valid0 == null_pointer_node)
4123             return valid1;
4124           if (valid1 == null_pointer_node)
4125             return valid0;
4126         }
4127       break;
4128
4129     case MINUS_EXPR:
4130       if (! INTEGRAL_TYPE_P (endtype)
4131           || TYPE_PRECISION (endtype) >= POINTER_SIZE)
4132         {
4133           tree valid0 = initializer_constant_valid_p (TREE_OPERAND (value, 0),
4134                                                       endtype);
4135           tree valid1 = initializer_constant_valid_p (TREE_OPERAND (value, 1),
4136                                                       endtype);
4137           /* Win if second argument is absolute.  */
4138           if (valid1 == null_pointer_node)
4139             return valid0;
4140           /* Win if both arguments have the same relocation.
4141              Then the value is absolute.  */
4142           if (valid0 == valid1 && valid0 != 0)
4143             return null_pointer_node;
4144         }
4145
4146       /* Support differences between labels.  */
4147       if (INTEGRAL_TYPE_P (endtype))
4148         {
4149           tree op0, op1;
4150           op0 = TREE_OPERAND (value, 0);
4151           op1 = TREE_OPERAND (value, 1);
4152           STRIP_NOPS (op0);
4153           STRIP_NOPS (op1);
4154
4155           if (TREE_CODE (op0) == ADDR_EXPR
4156               && TREE_CODE (TREE_OPERAND (op0, 0)) == LABEL_DECL
4157               && TREE_CODE (op1) == ADDR_EXPR
4158               && TREE_CODE (TREE_OPERAND (op1, 0)) == LABEL_DECL)
4159             return null_pointer_node;
4160         }
4161       break;
4162
4163     default:
4164       break;
4165     }
4166
4167   return 0;
4168 }
4169 \f
4170 /* Output assembler code for constant EXP to FILE, with no label.
4171    This includes the pseudo-op such as ".int" or ".byte", and a newline.
4172    Assumes output_addressed_constants has been done on EXP already.
4173
4174    Generate exactly SIZE bytes of assembler data, padding at the end
4175    with zeros if necessary.  SIZE must always be specified.
4176
4177    SIZE is important for structure constructors,
4178    since trailing members may have been omitted from the constructor.
4179    It is also important for initialization of arrays from string constants
4180    since the full length of the string constant might not be wanted.
4181    It is also needed for initialization of unions, where the initializer's
4182    type is just one member, and that may not be as long as the union.
4183
4184    There a case in which we would fail to output exactly SIZE bytes:
4185    for a structure constructor that wants to produce more than SIZE bytes.
4186    But such constructors will never be generated for any possible input.  */
4187
4188 void
4189 output_constant (exp, size)
4190      register tree exp;
4191      register int size;
4192 {
4193   register enum tree_code code = TREE_CODE (TREE_TYPE (exp));
4194
4195   /* Some front-ends use constants other than the standard
4196      language-indepdent varieties, but which may still be output
4197      directly.  Give the front-end a chance to convert EXP to a
4198      language-independent representation.  */
4199   if (lang_expand_constant)
4200     exp = (*lang_expand_constant) (exp);
4201
4202   if (size == 0 || flag_syntax_only)
4203     return;
4204
4205   /* Eliminate the NON_LVALUE_EXPR_EXPR that makes a cast not be an lvalue.
4206      That way we get the constant (we hope) inside it.  Also, strip off any
4207      NOP_EXPR that converts between two record, union, array, or set types.  */
4208   while ((TREE_CODE (exp) == NOP_EXPR
4209           && (TREE_TYPE (exp) == TREE_TYPE (TREE_OPERAND (exp, 0))
4210               || AGGREGATE_TYPE_P (TREE_TYPE (exp))))
4211          || TREE_CODE (exp) == NON_LVALUE_EXPR)
4212     exp = TREE_OPERAND (exp, 0);
4213
4214   /* Allow a constructor with no elements for any data type.
4215      This means to fill the space with zeros.  */
4216   if (TREE_CODE (exp) == CONSTRUCTOR && CONSTRUCTOR_ELTS (exp) == 0)
4217     {
4218       assemble_zeros (size);
4219       return;
4220     }
4221
4222   switch (code)
4223     {
4224     case CHAR_TYPE:
4225     case BOOLEAN_TYPE:
4226     case INTEGER_TYPE:
4227     case ENUMERAL_TYPE:
4228     case POINTER_TYPE:
4229     case REFERENCE_TYPE:
4230       /* ??? What about       (int)((float)(int)&foo + 4)    */
4231       while (TREE_CODE (exp) == NOP_EXPR || TREE_CODE (exp) == CONVERT_EXPR
4232              || TREE_CODE (exp) == NON_LVALUE_EXPR)
4233         exp = TREE_OPERAND (exp, 0);
4234
4235       if (! assemble_integer (expand_expr (exp, NULL_RTX, VOIDmode,
4236                                            EXPAND_INITIALIZER),
4237                               size, 0))
4238         error ("initializer for integer value is too complicated");
4239       size = 0;
4240       break;
4241
4242     case REAL_TYPE:
4243       if (TREE_CODE (exp) != REAL_CST)
4244         error ("initializer for floating value is not a floating constant");
4245
4246       assemble_real (TREE_REAL_CST (exp),
4247                      mode_for_size (size * BITS_PER_UNIT, MODE_FLOAT, 0));
4248       size = 0;
4249       break;
4250
4251     case COMPLEX_TYPE:
4252       output_constant (TREE_REALPART (exp), size / 2);
4253       output_constant (TREE_IMAGPART (exp), size / 2);
4254       size -= (size / 2) * 2;
4255       break;
4256
4257     case ARRAY_TYPE:
4258       if (TREE_CODE (exp) == CONSTRUCTOR)
4259         {
4260           output_constructor (exp, size);
4261           return;
4262         }
4263       else if (TREE_CODE (exp) == STRING_CST)
4264         {
4265           int excess = 0;
4266
4267           if (size > TREE_STRING_LENGTH (exp))
4268             {
4269               excess = size - TREE_STRING_LENGTH (exp);
4270               size = TREE_STRING_LENGTH (exp);
4271             }
4272
4273           assemble_string (TREE_STRING_POINTER (exp), size);
4274           size = excess;
4275         }
4276       else
4277         abort ();
4278       break;
4279
4280     case RECORD_TYPE:
4281     case UNION_TYPE:
4282       if (TREE_CODE (exp) == CONSTRUCTOR)
4283         output_constructor (exp, size);
4284       else
4285         abort ();
4286       return;
4287
4288     case SET_TYPE:
4289       if (TREE_CODE (exp) == INTEGER_CST)
4290         assemble_integer (expand_expr (exp, NULL_RTX,
4291                                        VOIDmode, EXPAND_INITIALIZER),
4292                           size, 1);
4293       else if (TREE_CODE (exp) == CONSTRUCTOR)
4294         {
4295           unsigned char *buffer = (unsigned char *) alloca (size);
4296           if (get_set_constructor_bytes (exp, buffer, size))
4297             abort ();
4298           assemble_string ((char *) buffer, size);
4299         }
4300       else
4301         error ("unknown set constructor type");
4302       return;
4303
4304     default:
4305       break; /* ??? */
4306     }
4307
4308   if (size > 0)
4309     assemble_zeros (size);
4310 }
4311
4312 \f
4313 /* Subroutine of output_constant, used for CONSTRUCTORs
4314    (aggregate constants).
4315    Generate at least SIZE bytes, padding if necessary.  */
4316
4317 static void
4318 output_constructor (exp, size)
4319      tree exp;
4320      int size;
4321 {
4322   register tree link, field = 0;
4323   HOST_WIDE_INT min_index = 0;
4324   /* Number of bytes output or skipped so far.
4325      In other words, current position within the constructor.  */
4326   int total_bytes = 0;
4327   /* Non-zero means BYTE contains part of a byte, to be output.  */
4328   int byte_buffer_in_use = 0;
4329   register int byte = 0;
4330
4331   if (HOST_BITS_PER_WIDE_INT < BITS_PER_UNIT)
4332     abort ();
4333
4334   if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
4335     field = TYPE_FIELDS (TREE_TYPE (exp));
4336
4337   if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE
4338       && TYPE_DOMAIN (TREE_TYPE (exp)) != 0)
4339     min_index
4340       = TREE_INT_CST_LOW (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (exp))));
4341
4342   /* As LINK goes through the elements of the constant,
4343      FIELD goes through the structure fields, if the constant is a structure.
4344      if the constant is a union, then we override this,
4345      by getting the field from the TREE_LIST element.
4346      But the constant could also be an array.  Then FIELD is zero.
4347
4348      There is always a maximum of one element in the chain LINK for unions
4349      (even if the initializer in a source program incorrectly contains
4350      more one). */
4351   for (link = CONSTRUCTOR_ELTS (exp);
4352        link;
4353        link = TREE_CHAIN (link),
4354        field = field ? TREE_CHAIN (field) : 0)
4355     {
4356       tree val = TREE_VALUE (link);
4357       tree index = 0;
4358
4359       /* the element in a union constructor specifies the proper field.  */
4360
4361       if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE
4362           || TREE_CODE (TREE_TYPE (exp)) == UNION_TYPE)
4363         {
4364           /* if available, use the type given by link */
4365           if (TREE_PURPOSE (link) != 0)
4366             field = TREE_PURPOSE (link);
4367         }
4368
4369       if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
4370         index = TREE_PURPOSE (link);
4371
4372       /* Eliminate the marker that makes a cast not be an lvalue.  */
4373       if (val != 0)
4374         STRIP_NOPS (val);
4375
4376       if (index && TREE_CODE (index) == RANGE_EXPR)
4377         {
4378           register int fieldsize
4379             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (exp)));
4380           HOST_WIDE_INT lo_index = TREE_INT_CST_LOW (TREE_OPERAND (index, 0));
4381           HOST_WIDE_INT hi_index = TREE_INT_CST_LOW (TREE_OPERAND (index, 1));
4382           HOST_WIDE_INT index;
4383           for (index = lo_index; index <= hi_index; index++)
4384             {
4385               /* Output the element's initial value.  */
4386               if (val == 0)
4387                 assemble_zeros (fieldsize);
4388               else
4389                 output_constant (val, fieldsize);
4390
4391               /* Count its size.  */
4392               total_bytes += fieldsize;
4393             }
4394         }
4395       else if (field == 0 || !DECL_BIT_FIELD (field))
4396         {
4397           /* An element that is not a bit-field.  */
4398
4399           register int fieldsize;
4400           /* Since this structure is static,
4401              we know the positions are constant.  */
4402           int bitpos = (field ? (TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field))
4403                                  / BITS_PER_UNIT)
4404                         : 0);
4405           if (index != 0)
4406             bitpos = (TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (val)))
4407                       / BITS_PER_UNIT
4408                       * (TREE_INT_CST_LOW (index) - min_index));
4409
4410           /* Output any buffered-up bit-fields preceding this element.  */
4411           if (byte_buffer_in_use)
4412             {
4413               ASM_OUTPUT_BYTE (asm_out_file, byte);
4414               total_bytes++;
4415               byte_buffer_in_use = 0;
4416             }
4417
4418           /* Advance to offset of this element.
4419              Note no alignment needed in an array, since that is guaranteed
4420              if each element has the proper size.  */
4421           if ((field != 0 || index != 0) && bitpos != total_bytes)
4422             {
4423               assemble_zeros (bitpos - total_bytes);
4424               total_bytes = bitpos;
4425             }
4426
4427           /* Determine size this element should occupy.  */
4428           if (field)
4429             {
4430               if (TREE_CODE (DECL_SIZE (field)) != INTEGER_CST)
4431                 abort ();
4432               if (TREE_INT_CST_LOW (DECL_SIZE (field)) > 100000)
4433                 {
4434                   /* This avoids overflow trouble.  */
4435                   tree size_tree = size_binop (CEIL_DIV_EXPR,
4436                                                DECL_SIZE (field),
4437                                                size_int (BITS_PER_UNIT));
4438                   fieldsize = TREE_INT_CST_LOW (size_tree);
4439                 }
4440               else
4441                 {
4442                   fieldsize = TREE_INT_CST_LOW (DECL_SIZE (field));
4443                   fieldsize = (fieldsize + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
4444                 }
4445             }
4446           else
4447             fieldsize = int_size_in_bytes (TREE_TYPE (TREE_TYPE (exp)));
4448
4449           /* Output the element's initial value.  */
4450           if (val == 0)
4451             assemble_zeros (fieldsize);
4452           else
4453             output_constant (val, fieldsize);
4454
4455           /* Count its size.  */
4456           total_bytes += fieldsize;
4457         }
4458       else if (val != 0 && TREE_CODE (val) != INTEGER_CST)
4459         error ("invalid initial value for member `%s'",
4460                IDENTIFIER_POINTER (DECL_NAME (field)));
4461       else
4462         {
4463           /* Element that is a bit-field.  */
4464
4465           int next_offset = TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field));
4466           int end_offset
4467             = (next_offset + TREE_INT_CST_LOW (DECL_SIZE (field)));
4468
4469           if (val == 0)
4470             val = integer_zero_node;
4471
4472           /* If this field does not start in this (or, next) byte,
4473              skip some bytes.  */
4474           if (next_offset / BITS_PER_UNIT != total_bytes)
4475             {
4476               /* Output remnant of any bit field in previous bytes.  */
4477               if (byte_buffer_in_use)
4478                 {
4479                   ASM_OUTPUT_BYTE (asm_out_file, byte);
4480                   total_bytes++;
4481                   byte_buffer_in_use = 0;
4482                 }
4483
4484               /* If still not at proper byte, advance to there.  */
4485               if (next_offset / BITS_PER_UNIT != total_bytes)
4486                 {
4487                   assemble_zeros (next_offset / BITS_PER_UNIT - total_bytes);
4488                   total_bytes = next_offset / BITS_PER_UNIT;
4489                 }
4490             }
4491
4492           if (! byte_buffer_in_use)
4493             byte = 0;
4494
4495           /* We must split the element into pieces that fall within
4496              separate bytes, and combine each byte with previous or
4497              following bit-fields.  */
4498
4499           /* next_offset is the offset n fbits from the beginning of
4500              the structure to the next bit of this element to be processed.
4501              end_offset is the offset of the first bit past the end of
4502              this element.  */
4503           while (next_offset < end_offset)
4504             {
4505               int this_time;
4506               int shift;
4507               HOST_WIDE_INT value;
4508               int next_byte = next_offset / BITS_PER_UNIT;
4509               int next_bit = next_offset % BITS_PER_UNIT;
4510
4511               /* Advance from byte to byte
4512                  within this element when necessary.  */
4513               while (next_byte != total_bytes)
4514                 {
4515                   ASM_OUTPUT_BYTE (asm_out_file, byte);
4516                   total_bytes++;
4517                   byte = 0;
4518                 }
4519
4520               /* Number of bits we can process at once
4521                  (all part of the same byte).  */
4522               this_time = MIN (end_offset - next_offset,
4523                                BITS_PER_UNIT - next_bit);
4524               if (BYTES_BIG_ENDIAN)
4525                 {
4526                   /* On big-endian machine, take the most significant bits
4527                      first (of the bits that are significant)
4528                      and put them into bytes from the most significant end.  */
4529                   shift = end_offset - next_offset - this_time;
4530                   /* Don't try to take a bunch of bits that cross
4531                      the word boundary in the INTEGER_CST. We can
4532                      only select bits from the LOW or HIGH part
4533                      not from both.  */
4534                   if (shift < HOST_BITS_PER_WIDE_INT
4535                       && shift + this_time > HOST_BITS_PER_WIDE_INT)
4536                     {
4537                       this_time = shift + this_time - HOST_BITS_PER_WIDE_INT;
4538                       shift = HOST_BITS_PER_WIDE_INT;
4539                     }
4540
4541                   /* Now get the bits from the appropriate constant word.  */
4542                   if (shift < HOST_BITS_PER_WIDE_INT)
4543                     {
4544                       value = TREE_INT_CST_LOW (val);
4545                     }
4546                   else if (shift < 2 * HOST_BITS_PER_WIDE_INT)
4547                     {
4548                       value = TREE_INT_CST_HIGH (val);
4549                       shift -= HOST_BITS_PER_WIDE_INT;
4550                     }
4551                   else
4552                     abort ();
4553                   /* Get the result. This works only when:
4554                      1 <= this_time <= HOST_BITS_PER_WIDE_INT.  */
4555                   byte |= (((value >> shift)
4556                             & (((HOST_WIDE_INT) 2 << (this_time - 1)) - 1))
4557                            << (BITS_PER_UNIT - this_time - next_bit));
4558                 }
4559               else
4560                 {
4561                   /* On little-endian machines,
4562                      take first the least significant bits of the value
4563                      and pack them starting at the least significant
4564                      bits of the bytes.  */
4565                   shift = (next_offset
4566                            - TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field)));
4567                   /* Don't try to take a bunch of bits that cross
4568                      the word boundary in the INTEGER_CST. We can
4569                      only select bits from the LOW or HIGH part
4570                      not from both.  */
4571                   if (shift < HOST_BITS_PER_WIDE_INT
4572                       && shift + this_time > HOST_BITS_PER_WIDE_INT)
4573                     {
4574                       this_time = (HOST_BITS_PER_WIDE_INT - shift);
4575                     }
4576
4577                   /* Now get the bits from the appropriate constant word.  */
4578                   if (shift < HOST_BITS_PER_WIDE_INT)
4579                     value = TREE_INT_CST_LOW (val);
4580                   else if (shift < 2 * HOST_BITS_PER_WIDE_INT)
4581                     {
4582                       value = TREE_INT_CST_HIGH (val);
4583                       shift -= HOST_BITS_PER_WIDE_INT;
4584                     }
4585                   else
4586                     abort ();
4587                   /* Get the result. This works only when:
4588                      1 <= this_time <= HOST_BITS_PER_WIDE_INT.  */
4589                   byte |= (((value >> shift)
4590                             & (((HOST_WIDE_INT) 2 << (this_time - 1)) - 1))
4591                            << next_bit);
4592                 }
4593               next_offset += this_time;
4594               byte_buffer_in_use = 1;
4595             }
4596         }
4597     }
4598   if (byte_buffer_in_use)
4599     {
4600       ASM_OUTPUT_BYTE (asm_out_file, byte);
4601       total_bytes++;
4602     }
4603   if (total_bytes < size)
4604     assemble_zeros (size - total_bytes);
4605 }
4606
4607 #ifdef HANDLE_PRAGMA_WEAK
4608 /* Add function NAME to the weak symbols list.  VALUE is a weak alias
4609    associatd with NAME.  */
4610
4611 int
4612 add_weak (name, value)
4613      char *name;
4614      char *value;
4615 {
4616   struct weak_syms *weak;
4617
4618   weak = (struct weak_syms *) permalloc (sizeof (struct weak_syms));
4619
4620   if (weak == NULL)
4621     return 0;
4622
4623   weak->next = weak_decls;
4624   weak->name = name;
4625   weak->value = value;
4626   weak_decls = weak;
4627
4628   return 1;
4629 }
4630 #endif /* HANDLE_PRAGMA_WEAK */
4631
4632 /* Declare DECL to be a weak symbol.  */
4633
4634 void
4635 declare_weak (decl)
4636      tree decl;
4637 {
4638   if (! TREE_PUBLIC (decl))
4639     error_with_decl (decl, "weak declaration of `%s' must be public");
4640   else if (TREE_ASM_WRITTEN (decl))
4641     error_with_decl (decl, "weak declaration of `%s' must precede definition");
4642   else if (SUPPORTS_WEAK)
4643     DECL_WEAK (decl) = 1;
4644 #ifdef HANDLE_PRAGMA_WEAK
4645    add_weak (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)), NULL);
4646 #endif
4647 }
4648
4649 /* Emit any pending weak declarations.  */
4650
4651 #ifdef HANDLE_PRAGMA_WEAK
4652 struct weak_syms * weak_decls;
4653 #endif
4654
4655 void
4656 weak_finish ()
4657 {
4658 #ifdef HANDLE_PRAGMA_WEAK
4659   if (HANDLE_PRAGMA_WEAK)
4660     {
4661       struct weak_syms *t;
4662       for (t = weak_decls; t; t = t->next)
4663         {
4664           if (t->name)
4665             {
4666               ASM_WEAKEN_LABEL (asm_out_file, t->name);
4667               if (t->value)
4668                 ASM_OUTPUT_DEF (asm_out_file, t->name, t->value);
4669             }
4670         }
4671     }
4672 #endif
4673 }
4674
4675 /* Remove NAME from the pending list of weak symbols.  This prevents
4676    the compiler from emitting multiple .weak directives which confuses
4677    some assemblers.  */
4678 #ifdef ASM_WEAKEN_LABEL
4679 static void
4680 remove_from_pending_weak_list (name)
4681      char *name ATTRIBUTE_UNUSED;
4682 {
4683 #ifdef HANDLE_PRAGMA_WEAK
4684   if (HANDLE_PRAGMA_WEAK)
4685     {
4686       struct weak_syms *t;
4687       for (t = weak_decls; t; t = t->next)
4688         {
4689           if (t->name && strcmp (name, t->name) == 0)
4690             t->name = NULL;
4691         }
4692     }
4693 #endif
4694 }
4695 #endif
4696
4697 void
4698 assemble_alias (decl, target)
4699      tree decl, target ATTRIBUTE_UNUSED;
4700 {
4701   char *name;
4702
4703   make_decl_rtl (decl, (char *) 0, 1);
4704   name = XSTR (XEXP (DECL_RTL (decl), 0), 0);
4705
4706 #ifdef ASM_OUTPUT_DEF
4707   /* Make name accessible from other files, if appropriate.  */
4708
4709   if (TREE_PUBLIC (decl))
4710     {
4711 #ifdef ASM_WEAKEN_LABEL
4712       if (DECL_WEAK (decl))
4713         {
4714           ASM_WEAKEN_LABEL (asm_out_file, name);
4715           /* Remove this function from the pending weak list so that
4716              we do not emit multiple .weak directives for it.  */
4717           remove_from_pending_weak_list
4718             (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
4719         }
4720       else
4721 #endif
4722         ASM_GLOBALIZE_LABEL (asm_out_file, name);
4723     }
4724
4725 #ifdef ASM_OUTPUT_DEF_FROM_DECLS
4726   ASM_OUTPUT_DEF_FROM_DECLS (asm_out_file, decl, target);
4727 #else
4728   ASM_OUTPUT_DEF (asm_out_file, name, IDENTIFIER_POINTER (target));
4729 #endif
4730   TREE_ASM_WRITTEN (decl) = 1;
4731 #else
4732 #ifdef ASM_OUTPUT_WEAK_ALIAS
4733   if (! DECL_WEAK (decl))
4734     warning ("only weak aliases are supported in this configuration");
4735
4736   ASM_OUTPUT_WEAK_ALIAS (asm_out_file, name, IDENTIFIER_POINTER (target));
4737   TREE_ASM_WRITTEN (decl) = 1;
4738 #else
4739   warning ("alias definitions not supported in this configuration; ignored");
4740 #endif
4741 #endif
4742 }
4743
4744 /* This determines whether or not we support link-once semantics.  */
4745 #ifndef SUPPORTS_ONE_ONLY
4746 #ifdef MAKE_DECL_ONE_ONLY
4747 #define SUPPORTS_ONE_ONLY 1
4748 #else
4749 #define SUPPORTS_ONE_ONLY 0
4750 #endif
4751 #endif
4752
4753 /* Returns 1 if the target configuration supports defining public symbols
4754    so that one of them will be chosen at link time instead of generating a
4755    multiply-defined symbol error, whether through the use of weak symbols or
4756    a target-specific mechanism for having duplicates discarded.  */
4757
4758 int
4759 supports_one_only ()
4760 {
4761   if (SUPPORTS_ONE_ONLY)
4762     return 1;
4763   return SUPPORTS_WEAK;
4764 }
4765
4766 /* Set up DECL as a public symbol that can be defined in multiple
4767    translation units without generating a linker error.  */
4768
4769 void
4770 make_decl_one_only (decl)
4771      tree decl;
4772 {
4773   if (TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != FUNCTION_DECL)
4774     abort ();
4775
4776   TREE_PUBLIC (decl) = 1;
4777
4778   if (TREE_CODE (decl) == VAR_DECL
4779       && (DECL_INITIAL (decl) == 0 || DECL_INITIAL (decl) == error_mark_node))
4780     DECL_COMMON (decl) = 1;
4781   else if (SUPPORTS_ONE_ONLY)
4782     {
4783 #ifdef MAKE_DECL_ONE_ONLY
4784       MAKE_DECL_ONE_ONLY (decl);
4785 #endif
4786       DECL_ONE_ONLY (decl) = 1;
4787     }
4788   else if (SUPPORTS_WEAK)
4789     DECL_WEAK (decl) = 1;
4790   else
4791     abort ();
4792 }
4793
4794 void
4795 init_varasm_once ()
4796 {
4797   ggc_add_root (const_hash_table, MAX_HASH_TABLE, sizeof const_hash_table[0],
4798                 mark_const_hash_entry);
4799   ggc_add_string_root (&in_named_name, 1);
4800 }