gcc/varasm.c

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