gcc/varasm.c

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