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