gcc/varasm.c

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