gcc/varasm.c

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