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