gcc/varasm.c

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