gcc/varasm.c

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