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