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