gcc/varasm.c

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