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 /* Output assembler code for the constant pool of a function and associated
 903    with defining the name of the function.  DECL describes the function.
 904    NAME is the function's name.  For the constant pool, we use the current
 905    constant pool data.  */
 906
 907 void
 908 assemble_start_function (decl, fnname)
 909      tree decl;
 910      char *fnname;
 911 {
 912   int align;
 913
 914   /* The following code does not need preprocessing in the assembler.  */
 915
 916   app_disable ();
 917
 918   output_constant_pool (fnname, decl);
 919
 920 #ifdef ASM_OUTPUT_SECTION_NAME
 921   /* If the function is to be put in its own section and it's not in a section
 922      already, indicate so.  */
 923   if (flag_function_sections
 924       && DECL_SECTION_NAME (decl) == NULL_TREE)
 925     {
 926 #ifdef UNIQUE_SECTION
 927       DECL_SECTION_NAME(decl) = UNIQUE_SECTION (decl);
 928 #else
 929       char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
 930       /* Strip off any encoding in name.  */
 931       STRIP_NAME_ENCODING (name, name);
 932       DECL_SECTION_NAME (decl) = build_string (strlen (name), name);
 933 #endif
 934     }
 935 #endif
 936
 937   function_section (decl);
 938
 939   /* Tell assembler to move to target machine's alignment for functions.  */
 940   align = floor_log2 (FUNCTION_BOUNDARY / BITS_PER_UNIT);
 941   if (align > 0)
 942     {
 943       if (output_bytecode)
 944         BC_OUTPUT_ALIGN (asm_out_file, align);
 945       else
 946         ASM_OUTPUT_ALIGN (asm_out_file, align);
 947     }
 948
 949 #ifdef ASM_OUTPUT_FUNCTION_PREFIX
 950   ASM_OUTPUT_FUNCTION_PREFIX (asm_out_file, fnname);
 951 #endif
 952
 953 #ifdef SDB_DEBUGGING_INFO
 954   /* Output SDB definition of the function.  */
 955   if (write_symbols == SDB_DEBUG)
 956     sdbout_mark_begin_function ();
 957 #endif
 958
 959 #ifdef DBX_DEBUGGING_INFO
 960   /* Output DBX definition of the function.  */
 961   if (write_symbols == DBX_DEBUG)
 962     dbxout_begin_function (decl);
 963 #endif
 964
 965   /* Make function name accessible from other files, if appropriate.  */
 966
 967   if (TREE_PUBLIC (decl))
 968     {
 969       if (!first_global_object_name && ! DECL_WEAK (decl)
 970           && ! DECL_ONE_ONLY (decl))
 971         {
 972           char *p;
 973
 974           STRIP_NAME_ENCODING (p, fnname);
 975           first_global_object_name = permalloc (strlen (p) + 1);
 976           strcpy (first_global_object_name, p);
 977         }
 978
 979 #ifdef ASM_WEAKEN_LABEL
 980       if (DECL_WEAK (decl))
 981         ASM_WEAKEN_LABEL (asm_out_file, fnname);
 982       else
 983 #endif
 984       if (output_bytecode)
 985         BC_GLOBALIZE_LABEL (asm_out_file, fnname);
 986       else
 987         ASM_GLOBALIZE_LABEL (asm_out_file, fnname);
 988     }
 989
 990   /* Do any machine/system dependent processing of the function name */
 991   if (output_bytecode)
 992     BC_OUTPUT_LABEL (asm_out_file, fnname);
 993   else
 994     {
 995 #ifdef ASM_DECLARE_FUNCTION_NAME
 996       ASM_DECLARE_FUNCTION_NAME (asm_out_file, fnname, current_function_decl);
 997 #else
 998       /* Standard thing is just output label for the function.  */
 999       ASM_OUTPUT_LABEL (asm_out_file, fnname);
1000 #endif /* ASM_DECLARE_FUNCTION_NAME */
1001     }
1002 }
1003
1004 /* Output assembler code associated with defining the size of the
1005    function.  DECL describes the function.  NAME is the function's name.  */
1006
1007 void
1008 assemble_end_function (decl, fnname)
1009      tree decl;
1010      char *fnname;
1011 {
1012 #ifdef ASM_DECLARE_FUNCTION_SIZE
1013   ASM_DECLARE_FUNCTION_SIZE (asm_out_file, fnname, decl);
1014 #endif
1015 }
1016 \f
1017 /* Assemble code to leave SIZE bytes of zeros.  */
1018
1019 void
1020 assemble_zeros (size)
1021      int size;
1022 {
1023   if (output_bytecode)
1024     {
1025       bc_emit_const_skip (size);
1026       return;
1027     }
1028
1029 #ifdef ASM_NO_SKIP_IN_TEXT
1030   /* The `space' pseudo in the text section outputs nop insns rather than 0s,
1031      so we must output 0s explicitly in the text section.  */
1032   if (ASM_NO_SKIP_IN_TEXT && in_text_section ())
1033     {
1034       int i;
1035
1036       for (i = 0; i < size - 20; i += 20)
1037         {
1038 #ifdef ASM_BYTE_OP
1039           fprintf (asm_out_file,
1040                    "%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);
1041 #else
1042           fprintf (asm_out_file,
1043                    "\tbyte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0\n");
1044 #endif
1045         }
1046       if (i < size)
1047         {
1048 #ifdef ASM_BYTE_OP
1049           fprintf (asm_out_file, "%s 0", ASM_BYTE_OP);
1050 #else
1051           fprintf (asm_out_file, "\tbyte 0");
1052 #endif
1053           i++;
1054           for (; i < size; i++)
1055             fprintf (asm_out_file, ",0");
1056           fprintf (asm_out_file, "\n");
1057         }
1058     }
1059   else
1060 #endif
1061     if (size > 0)
1062       {
1063         if (output_bytecode)
1064           BC_OUTPUT_SKIP (asm_out_file, size);
1065         else
1066           ASM_OUTPUT_SKIP (asm_out_file, size);
1067       }
1068 }
1069
1070 /* Assemble an alignment pseudo op for an ALIGN-bit boundary.  */
1071
1072 void
1073 assemble_align (align)
1074      int align;
1075 {
1076   if (align > BITS_PER_UNIT)
1077     ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
1078 }
1079
1080 /* Assemble a string constant with the specified C string as contents.  */
1081
1082 void
1083 assemble_string (p, size)
1084      char *p;
1085      int size;
1086 {
1087   register int i;
1088   int pos = 0;
1089   int maximum = 2000;
1090
1091   if (output_bytecode)
1092     {
1093       bc_emit (p, size);
1094       return;
1095     }
1096
1097   /* If the string is very long, split it up.  */
1098
1099   while (pos < size)
1100     {
1101       int thissize = size - pos;
1102       if (thissize > maximum)
1103         thissize = maximum;
1104
1105       if (output_bytecode)
1106         bc_output_ascii (asm_out_file, p, thissize);
1107       else
1108         {
1109           ASM_OUTPUT_ASCII (asm_out_file, p, thissize);
1110         }
1111
1112       pos += thissize;
1113       p += thissize;
1114     }
1115 }
1116
1117 static void
1118 bc_output_ascii (file, p, size)
1119      FILE *file;
1120      char *p;
1121      int size;
1122 {
1123   BC_OUTPUT_ASCII (file, p, size);
1124 }
1125 \f
1126 /* Assemble everything that is needed for a variable or function declaration.
1127    Not used for automatic variables, and not used for function definitions.
1128    Should not be called for variables of incomplete structure type.
1129
1130    TOP_LEVEL is nonzero if this variable has file scope.
1131    AT_END is nonzero if this is the special handling, at end of compilation,
1132    to define things that have had only tentative definitions.
1133    DONT_OUTPUT_DATA if nonzero means don't actually output the
1134    initial value (that will be done by the caller).  */
1135
1136 void
1137 assemble_variable (decl, top_level, at_end, dont_output_data)
1138      tree decl;
1139      int top_level;
1140      int at_end;
1141      int dont_output_data;
1142 {
1143   register char *name;
1144   int align;
1145   tree size_tree;
1146   int reloc = 0;
1147   enum in_section saved_in_section;
1148
1149   last_assemble_variable_decl = 0;
1150
1151   if (output_bytecode)
1152     return;
1153
1154   if (GET_CODE (DECL_RTL (decl)) == REG)
1155     {
1156       /* Do output symbol info for global register variables, but do nothing
1157          else for them.  */
1158
1159       if (TREE_ASM_WRITTEN (decl))
1160         return;
1161       TREE_ASM_WRITTEN (decl) = 1;
1162
1163       if (!output_bytecode)
1164         {
1165 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
1166           /* File-scope global variables are output here.  */
1167           if ((write_symbols == DBX_DEBUG || write_symbols == XCOFF_DEBUG)
1168               && top_level)
1169             dbxout_symbol (decl, 0);
1170 #endif
1171 #ifdef SDB_DEBUGGING_INFO
1172           if (write_symbols == SDB_DEBUG && top_level
1173               /* Leave initialized global vars for end of compilation;
1174                  see comment in compile_file.  */
1175               && (TREE_PUBLIC (decl) == 0 || DECL_INITIAL (decl) == 0))
1176             sdbout_symbol (decl, 0);
1177 #endif
1178 #ifdef DWARF_DEBUGGING_INFO
1179           if (write_symbols == DWARF_DEBUG && top_level
1180               && DECL_CONTEXT (decl))
1181             dwarfout_file_scope_decl (decl, 0);
1182 #endif
1183         }
1184
1185       /* Only output DWARF debugging information for record-scope variables
1186          here.  In the case of function-scope variables, the information
1187          for them is output when we do our recursive traversal of the tree
1188          representation for the entire containing function.  In the case of
1189          file-scope variables, we output information for all of them at the
1190          very end of compilation while we are doing our final traversal of
1191          the chain of file-scope declarations.  */
1192
1193       return;
1194     }
1195
1196   /* Normally no need to say anything here for external references,
1197      since assemble_external is called by the language-specific code
1198      when a declaration is first seen.  */
1199
1200   if (DECL_EXTERNAL (decl))
1201     return;
1202
1203   /* Output no assembler code for a function declaration.
1204      Only definitions of functions output anything.  */
1205
1206   if (TREE_CODE (decl) == FUNCTION_DECL)
1207     return;
1208
1209   /* If type was incomplete when the variable was declared,
1210      see if it is complete now.  */
1211
1212   if (DECL_SIZE (decl) == 0)
1213     layout_decl (decl, 0);
1214
1215   /* Still incomplete => don't allocate it; treat the tentative defn
1216      (which is what it must have been) as an `extern' reference.  */
1217
1218   if (!dont_output_data && DECL_SIZE (decl) == 0)
1219     {
1220       error_with_file_and_line (DECL_SOURCE_FILE (decl),
1221                                 DECL_SOURCE_LINE (decl),
1222                                 "storage size of `%s' isn't known",
1223                                 IDENTIFIER_POINTER (DECL_NAME (decl)));
1224       TREE_ASM_WRITTEN (decl) = 1;
1225       return;
1226     }
1227
1228   /* The first declaration of a variable that comes through this function
1229      decides whether it is global (in C, has external linkage)
1230      or local (in C, has internal linkage).  So do nothing more
1231      if this function has already run.  */
1232
1233   if (TREE_ASM_WRITTEN (decl))
1234     return;
1235
1236   TREE_ASM_WRITTEN (decl) = 1;
1237
1238   app_disable ();
1239
1240   if (! dont_output_data)
1241     {
1242       if (TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST)
1243         goto finish;
1244
1245       /* This is better than explicit arithmetic, since it avoids overflow.  */
1246       size_tree = size_binop (CEIL_DIV_EXPR,
1247                               DECL_SIZE (decl), size_int (BITS_PER_UNIT));
1248
1249       if (TREE_INT_CST_HIGH (size_tree) != 0)
1250         {
1251           error_with_decl (decl, "size of variable `%s' is too large");
1252           goto finish;
1253         }
1254     }
1255
1256   name = XSTR (XEXP (DECL_RTL (decl), 0), 0);
1257
1258   if (TREE_PUBLIC (decl) && DECL_NAME (decl)
1259       && ! first_global_object_name
1260       && ! (DECL_COMMON (decl) && (DECL_INITIAL (decl) == 0
1261                                    || DECL_INITIAL (decl) == error_mark_node))
1262       && ! DECL_WEAK (decl)
1263       && ! DECL_ONE_ONLY (decl))
1264     {
1265       char *p;
1266
1267       STRIP_NAME_ENCODING (p, name);
1268       first_global_object_name = permalloc (strlen (p) + 1);
1269       strcpy (first_global_object_name, p);
1270     }
1271
1272   /* Handle uninitialized definitions.  */
1273
1274   if ((DECL_INITIAL (decl) == 0 || DECL_INITIAL (decl) == error_mark_node)
1275       /* If the target can't output uninitialized but not common global data
1276          in .bss, then we have to use .data.  */
1277 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
1278       && DECL_COMMON (decl)
1279 #endif
1280       && ! dont_output_data)
1281     {
1282       int size = TREE_INT_CST_LOW (size_tree);
1283       int rounded = size;
1284
1285       /* Don't allocate zero bytes of common,
1286          since that means "undefined external" in the linker.  */
1287       if (size == 0) rounded = 1;
1288       /* Round size up to multiple of BIGGEST_ALIGNMENT bits
1289          so that each uninitialized object starts on such a boundary.  */
1290       rounded += (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1;
1291       rounded = (rounded / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
1292                  * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
1293
1294 #ifdef DBX_DEBUGGING_INFO
1295       /* File-scope global variables are output here.  */
1296       if (write_symbols == DBX_DEBUG && top_level)
1297         dbxout_symbol (decl, 0);
1298 #endif
1299 #ifdef SDB_DEBUGGING_INFO
1300       if (write_symbols == SDB_DEBUG && top_level
1301           /* Leave initialized global vars for end of compilation;
1302              see comment in compile_file.  */
1303           && (TREE_PUBLIC (decl) == 0 || DECL_INITIAL (decl) == 0))
1304         sdbout_symbol (decl, 0);
1305 #endif
1306 #ifdef DWARF_DEBUGGING_INFO
1307       if (write_symbols == DWARF_DEBUG && top_level
1308           && DECL_CONTEXT (decl))
1309         dwarfout_file_scope_decl (decl, 0);
1310 #endif
1311
1312       /* Only output DWARF debugging information for record-scope variables
1313          here.  In the case of function-scope variables, the information
1314          for them is output when we do our recursive traversal of the tree
1315          representation for the entire containing function.  In the case of
1316          file-scope variables, we output information for all of them at the
1317          very end of compilation while we are doing our final traversal of
1318          the chain of file-scope declarations.  */
1319
1320 #if 0 /* ??? We should either delete this or add a comment describing what
1321          it was intended to do and why we shouldn't delete it.  */
1322       if (flag_shared_data)
1323         data_section ();
1324 #endif
1325
1326       if (TREE_PUBLIC (decl)
1327 #if defined (ASM_OUTPUT_BSS) || defined (ASM_OUTPUT_ALIGNED_BSS)
1328           && DECL_COMMON (decl)
1329 #endif
1330           )
1331         {
1332 #ifdef ASM_OUTPUT_SHARED_COMMON
1333           if (flag_shared_data)
1334             ASM_OUTPUT_SHARED_COMMON (asm_out_file, name, size, rounded);
1335           else
1336 #endif
1337             if (output_bytecode)
1338               {
1339                 BC_OUTPUT_COMMON (asm_out_file, name, size, rounded);
1340               }
1341             else
1342               {
1343 #ifdef ASM_OUTPUT_ALIGNED_COMMON
1344                 ASM_OUTPUT_ALIGNED_COMMON (asm_out_file, name, size,
1345                                            DECL_ALIGN (decl));
1346 #else
1347                 ASM_OUTPUT_COMMON (asm_out_file, name, size, rounded);
1348 #endif
1349               }
1350         }
1351 #if defined (ASM_OUTPUT_BSS) || defined (ASM_OUTPUT_ALIGNED_BSS)
1352       else if (TREE_PUBLIC (decl))
1353         {
1354 #ifdef ASM_OUTPUT_SHARED_BSS
1355           if (flag_shared_data)
1356             ASM_OUTPUT_SHARED_BSS (asm_out_file, decl, name, size, rounded);
1357           else
1358 #endif
1359             if (output_bytecode)
1360               {
1361                 BC_OUTPUT_BSS (asm_out_file, name, size, rounded);
1362               }
1363             else
1364               {
1365 #ifdef ASM_OUTPUT_ALIGNED_BSS
1366                 ASM_OUTPUT_ALIGNED_BSS (asm_out_file, decl, name, size,
1367                                         DECL_ALIGN (decl));
1368 #else
1369                 ASM_OUTPUT_BSS (asm_out_file, decl, name, size, rounded);
1370 #endif
1371               }
1372         }
1373 #endif /* ASM_OUTPUT_BSS || ASM_OUTPUT_ALIGNED_BSS */
1374       else
1375         {
1376 #ifdef ASM_OUTPUT_SHARED_LOCAL
1377           if (flag_shared_data)
1378             ASM_OUTPUT_SHARED_LOCAL (asm_out_file, name, size, rounded);
1379           else
1380 #endif
1381             if (output_bytecode)
1382               {
1383                 BC_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
1384               }
1385             else
1386               {
1387 #ifdef ASM_OUTPUT_ALIGNED_LOCAL
1388                 ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size,
1389                                           DECL_ALIGN (decl));
1390 #else
1391                 ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
1392 #endif
1393               }
1394         }
1395       goto finish;
1396     }
1397
1398   /* Handle initialized definitions.
1399      Also handle uninitialized global definitions if -fno-common and the
1400      target doesn't support ASM_OUTPUT_BSS.  */
1401
1402   /* First make the assembler name(s) global if appropriate.  */
1403   if (TREE_PUBLIC (decl) && DECL_NAME (decl))
1404     {
1405 #ifdef ASM_WEAKEN_LABEL
1406       if (DECL_WEAK (decl))
1407         ASM_WEAKEN_LABEL (asm_out_file, name);
1408       else
1409 #endif
1410       ASM_GLOBALIZE_LABEL (asm_out_file, name);
1411     }
1412 #if 0
1413   for (d = equivalents; d; d = TREE_CHAIN (d))
1414     {
1415       tree e = TREE_VALUE (d);
1416       if (TREE_PUBLIC (e) && DECL_NAME (e))
1417         ASM_GLOBALIZE_LABEL (asm_out_file,
1418                              XSTR (XEXP (DECL_RTL (e), 0), 0));
1419     }
1420 #endif
1421
1422   /* Output any data that we will need to use the address of.  */
1423   if (DECL_INITIAL (decl) == error_mark_node)
1424     reloc = contains_pointers_p (TREE_TYPE (decl));
1425   else if (DECL_INITIAL (decl))
1426     reloc = output_addressed_constants (DECL_INITIAL (decl));
1427
1428   /* Switch to the appropriate section.  */
1429   variable_section (decl, reloc);
1430
1431   /* dbxout.c needs to know this.  */
1432   if (in_text_section ())
1433     DECL_IN_TEXT_SECTION (decl) = 1;
1434
1435   /* Record current section so we can restore it if dbxout.c clobbers it.  */
1436   saved_in_section = in_section;
1437
1438   /* Output the dbx info now that we have chosen the section.  */
1439
1440 #ifdef DBX_DEBUGGING_INFO
1441   /* File-scope global variables are output here.  */
1442   if (write_symbols == DBX_DEBUG && top_level)
1443     dbxout_symbol (decl, 0);
1444 #endif
1445 #ifdef SDB_DEBUGGING_INFO
1446   if (write_symbols == SDB_DEBUG && top_level
1447       /* Leave initialized global vars for end of compilation;
1448          see comment in compile_file.  */
1449       && (TREE_PUBLIC (decl) == 0 || DECL_INITIAL (decl) == 0))
1450     sdbout_symbol (decl, 0);
1451 #endif
1452
1453   /* Don't output any DWARF debugging information for variables here.
1454      In the case of local variables, the information for them is output
1455      when we do our recursive traversal of the tree representation for
1456      the entire containing function.  In the case of file-scope variables,
1457      we output information for all of them at the very end of compilation
1458      while we are doing our final traversal of the chain of file-scope
1459      declarations.  */
1460
1461   /* If the debugging output changed sections, reselect the section
1462      that's supposed to be selected.  */
1463   if (in_section != saved_in_section)
1464     variable_section (decl, reloc);
1465
1466   /* Compute and output the alignment of this data.  */
1467
1468   align = DECL_ALIGN (decl);
1469   /* In the case for initialing an array whose length isn't specified,
1470      where we have not yet been able to do the layout,
1471      figure out the proper alignment now.  */
1472   if (dont_output_data && DECL_SIZE (decl) == 0
1473       && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
1474     align = MAX (align, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (decl))));
1475
1476   /* Some object file formats have a maximum alignment which they support.
1477      In particular, a.out format supports a maximum alignment of 4.  */
1478 #ifndef MAX_OFILE_ALIGNMENT
1479 #define MAX_OFILE_ALIGNMENT BIGGEST_ALIGNMENT
1480 #endif
1481   if (align > MAX_OFILE_ALIGNMENT)
1482     {
1483       warning_with_decl (decl,
1484           "alignment of `%s' is greater than maximum object file alignment");
1485       align = MAX_OFILE_ALIGNMENT;
1486     }
1487 #ifdef DATA_ALIGNMENT
1488   /* On some machines, it is good to increase alignment sometimes.  */
1489   align = DATA_ALIGNMENT (TREE_TYPE (decl), align);
1490 #endif
1491 #ifdef CONSTANT_ALIGNMENT
1492   if (DECL_INITIAL (decl))
1493     align = CONSTANT_ALIGNMENT (DECL_INITIAL (decl), align);
1494 #endif
1495
1496   /* Reset the alignment in case we have made it tighter, so we can benefit
1497      from it in get_pointer_alignment.  */
1498   DECL_ALIGN (decl) = align;
1499
1500   if (align > BITS_PER_UNIT)
1501     {
1502       if (output_bytecode)
1503         BC_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
1504       else
1505         ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
1506     }
1507
1508   /* Do any machine/system dependent processing of the object.  */
1509   if (output_bytecode)
1510     BC_OUTPUT_LABEL (asm_out_file, name);
1511   else
1512     {
1513 #ifdef ASM_DECLARE_OBJECT_NAME
1514       last_assemble_variable_decl = decl;
1515       ASM_DECLARE_OBJECT_NAME (asm_out_file, name, decl);
1516 #else
1517       /* Standard thing is just output label for the object.  */
1518       ASM_OUTPUT_LABEL (asm_out_file, name);
1519 #endif /* ASM_DECLARE_OBJECT_NAME */
1520     }
1521
1522   if (!dont_output_data)
1523     {
1524       if (DECL_INITIAL (decl))
1525         /* Output the actual data.  */
1526         output_constant (DECL_INITIAL (decl), TREE_INT_CST_LOW (size_tree));
1527       else
1528         /* Leave space for it.  */
1529         assemble_zeros (TREE_INT_CST_LOW (size_tree));
1530     }
1531
1532  finish:
1533 #ifdef XCOFF_DEBUGGING_INFO
1534   /* Unfortunately, the IBM assembler cannot handle stabx before the actual
1535      declaration.  When something like ".stabx  "aa:S-2",aa,133,0" is emitted
1536      and `aa' hasn't been output yet, the assembler generates a stab entry with
1537      a value of zero, in addition to creating an unnecessary external entry
1538      for `aa'.  Hence, we must postpone dbxout_symbol to here at the end.  */
1539
1540   /* File-scope global variables are output here.  */
1541   if (write_symbols == XCOFF_DEBUG && top_level)
1542     {
1543       saved_in_section = in_section;
1544
1545       dbxout_symbol (decl, 0);
1546
1547       if (in_section != saved_in_section)
1548         variable_section (decl, reloc);
1549     }
1550 #else
1551   /* There must be a statement after a label.  */
1552   ;
1553 #endif
1554 }
1555
1556 /* Return 1 if type TYPE contains any pointers.  */
1557
1558 static int
1559 contains_pointers_p (type)
1560      tree type;
1561 {
1562   switch (TREE_CODE (type))
1563     {
1564     case POINTER_TYPE:
1565     case REFERENCE_TYPE:
1566       /* I'm not sure whether OFFSET_TYPE needs this treatment,
1567          so I'll play safe and return 1.  */
1568     case OFFSET_TYPE:
1569       return 1;
1570
1571     case RECORD_TYPE:
1572     case UNION_TYPE:
1573     case QUAL_UNION_TYPE:
1574       {
1575         tree fields;
1576         /* For a type that has fields, see if the fields have pointers.  */
1577         for (fields = TYPE_FIELDS (type); fields; fields = TREE_CHAIN (fields))
1578           if (TREE_CODE (fields) == FIELD_DECL
1579               && contains_pointers_p (TREE_TYPE (fields)))
1580             return 1;
1581         return 0;
1582       }
1583
1584     case ARRAY_TYPE:
1585       /* An array type contains pointers if its element type does.  */
1586       return contains_pointers_p (TREE_TYPE (type));
1587
1588     default:
1589       return 0;
1590     }
1591 }
1592
1593 /* Output text storage for constructor CONSTR.  */
1594
1595 void
1596 bc_output_constructor (constr, size)
1597      tree constr;
1598      int size;
1599 {
1600   int i;
1601
1602   /* Must always be a literal; non-literal constructors are handled
1603      differently.  */
1604
1605   if (!TREE_CONSTANT (constr))
1606     abort ();
1607
1608   /* Always const */
1609   text_section ();
1610
1611   /* Align */
1612   for (i = 0; TYPE_ALIGN (constr) >= BITS_PER_UNIT << (i + 1); i++)
1613     ;
1614
1615   if (i > 0)
1616     BC_OUTPUT_ALIGN (asm_out_file, i);
1617
1618   /* Output data */
1619   output_constant (constr, size);
1620 }
1621
1622 /* Create storage for constructor CONSTR.  */
1623
1624 void
1625 bc_output_data_constructor (constr)
1626     tree constr;
1627 {
1628   int i;
1629
1630   /* Put in data section */
1631   data_section ();
1632
1633   /* Align */
1634   for (i = 0; TYPE_ALIGN (constr) >= BITS_PER_UNIT << (i + 1); i++);
1635   if (i > 0)
1636     BC_OUTPUT_ALIGN (asm_out_file, i);
1637
1638   /* The constructor is filled in at runtime.  */
1639   BC_OUTPUT_SKIP (asm_out_file, int_size_in_bytes (TREE_TYPE (constr)));
1640 }
1641
1642 /* Output something to declare an external symbol to the assembler.
1643    (Most assemblers don't need this, so we normally output nothing.)
1644    Do nothing if DECL is not external.  */
1645
1646 void
1647 assemble_external (decl)
1648      tree decl;
1649 {
1650   if (output_bytecode)
1651     return;
1652
1653 #ifdef ASM_OUTPUT_EXTERNAL
1654   if (TREE_CODE_CLASS (TREE_CODE (decl)) == 'd'
1655       && DECL_EXTERNAL (decl) && TREE_PUBLIC (decl))
1656     {
1657       rtx rtl = DECL_RTL (decl);
1658
1659       if (GET_CODE (rtl) == MEM && GET_CODE (XEXP (rtl, 0)) == SYMBOL_REF
1660           && ! SYMBOL_REF_USED (XEXP (rtl, 0)))
1661         {
1662           /* Some systems do require some output.  */
1663           SYMBOL_REF_USED (XEXP (rtl, 0)) = 1;
1664           ASM_OUTPUT_EXTERNAL (asm_out_file, decl, XSTR (XEXP (rtl, 0), 0));
1665         }
1666     }
1667 #endif
1668 }
1669
1670 /* Similar, for calling a library function FUN.  */
1671
1672 void
1673 assemble_external_libcall (fun)
1674      rtx fun;
1675 {
1676 #ifdef ASM_OUTPUT_EXTERNAL_LIBCALL
1677   if (!output_bytecode)
1678     {
1679       /* Declare library function name external when first used, if nec.  */
1680       if (! SYMBOL_REF_USED (fun))
1681         {
1682           SYMBOL_REF_USED (fun) = 1;
1683           ASM_OUTPUT_EXTERNAL_LIBCALL (asm_out_file, fun);
1684         }
1685     }
1686 #endif
1687 }
1688
1689 /* Declare the label NAME global.  */
1690
1691 void
1692 assemble_global (name)
1693      char *name;
1694 {
1695   ASM_GLOBALIZE_LABEL (asm_out_file, name);
1696 }
1697
1698 /* Assemble a label named NAME.  */
1699
1700 void
1701 assemble_label (name)
1702      char *name;
1703 {
1704   if (output_bytecode)
1705     BC_OUTPUT_LABEL (asm_out_file, name);
1706   else
1707     ASM_OUTPUT_LABEL (asm_out_file, name);
1708 }
1709
1710 /* Output to FILE a reference to the assembler name of a C-level name NAME.
1711    If NAME starts with a *, the rest of NAME is output verbatim.
1712    Otherwise NAME is transformed in an implementation-defined way
1713    (usually by the addition of an underscore).
1714    Many macros in the tm file are defined to call this function.  */
1715
1716 void
1717 assemble_name (file, name)
1718      FILE *file;
1719      char *name;
1720 {
1721   char *real_name;
1722   int save_warn_id_clash = warn_id_clash;
1723
1724   STRIP_NAME_ENCODING (real_name, name);
1725
1726   /* Don't warn about an identifier name length clash on this name, since
1727      it can be a user symbol suffixed by a number.  */
1728   warn_id_clash = 0;
1729   TREE_SYMBOL_REFERENCED (get_identifier (real_name)) = 1;
1730   warn_id_clash = save_warn_id_clash;
1731
1732   if (name[0] == '*')
1733     {
1734       if (output_bytecode)
1735         bc_emit_labelref (name, 0);
1736       else
1737         fputs (&name[1], file);
1738     }
1739   else
1740     {
1741       if (output_bytecode)
1742         BC_OUTPUT_LABELREF (file, name);
1743       else
1744         ASM_OUTPUT_LABELREF (file, name);
1745     }
1746 }
1747
1748 /* Allocate SIZE bytes writable static space with a gensym name
1749    and return an RTX to refer to its address.  */
1750
1751 rtx
1752 assemble_static_space (size)
1753      int size;
1754 {
1755   char name[12];
1756   char *namestring;
1757   rtx x;
1758   /* Round size up to multiple of BIGGEST_ALIGNMENT bits
1759      so that each uninitialized object starts on such a boundary.  */
1760   int rounded = ((size + (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1)
1761                  / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
1762                  * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
1763
1764 #if 0
1765   if (flag_shared_data)
1766     data_section ();
1767 #endif
1768
1769   ASM_GENERATE_INTERNAL_LABEL (name, "LF", const_labelno);
1770   ++const_labelno;
1771
1772   namestring = (char *) obstack_alloc (saveable_obstack,
1773                                        strlen (name) + 2);
1774   strcpy (namestring, name);
1775
1776   if (output_bytecode)
1777     x = bc_gen_rtx (namestring, 0, (struct bc_label *) 0);
1778   else
1779     x = gen_rtx (SYMBOL_REF, Pmode, namestring);
1780
1781   if (output_bytecode)
1782     {
1783       BC_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
1784     }
1785   else
1786     {
1787 #ifdef ASM_OUTPUT_ALIGNED_LOCAL
1788       ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, BIGGEST_ALIGNMENT);
1789 #else
1790       ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
1791 #endif
1792     }
1793   return x;
1794 }
1795
1796 /* Assemble the static constant template for function entry trampolines.
1797    This is done at most once per compilation.
1798    Returns an RTX for the address of the template.  */
1799
1800 #ifdef TRAMPOLINE_TEMPLATE
1801 rtx
1802 assemble_trampoline_template ()
1803 {
1804   char label[256];
1805   char *name;
1806   int align;
1807
1808   /* Shouldn't get here */
1809   if (output_bytecode)
1810     abort ();
1811
1812   /* By default, put trampoline templates in read-only data section.  */
1813
1814 #ifdef TRAMPOLINE_SECTION
1815   TRAMPOLINE_SECTION ();
1816 #else
1817   readonly_data_section ();
1818 #endif
1819
1820   /* Write the assembler code to define one.  */
1821   align = floor_log2 (FUNCTION_BOUNDARY / BITS_PER_UNIT);
1822   if (align > 0)
1823     ASM_OUTPUT_ALIGN (asm_out_file, align);
1824
1825   ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LTRAMP", 0);
1826   TRAMPOLINE_TEMPLATE (asm_out_file);
1827
1828   /* Record the rtl to refer to it.  */
1829   ASM_GENERATE_INTERNAL_LABEL (label, "LTRAMP", 0);
1830   name
1831     = (char *) obstack_copy0 (&permanent_obstack, label, strlen (label));
1832   return gen_rtx (SYMBOL_REF, Pmode, name);
1833 }
1834 #endif
1835 \f
1836 /* Assemble the integer constant X into an object of SIZE bytes.
1837    X must be either a CONST_INT or CONST_DOUBLE.
1838
1839    Return 1 if we were able to output the constant, otherwise 0.  If FORCE is
1840    non-zero, abort if we can't output the constant.  */
1841
1842 int
1843 assemble_integer (x, size, force)
1844      rtx x;
1845      int size;
1846      int force;
1847 {
1848   /* First try to use the standard 1, 2, 4, 8, and 16 byte
1849      ASM_OUTPUT... macros.  */
1850
1851   switch (size)
1852     {
1853 #ifdef ASM_OUTPUT_CHAR
1854     case 1:
1855       ASM_OUTPUT_CHAR (asm_out_file, x);
1856       return 1;
1857 #endif
1858
1859 #ifdef ASM_OUTPUT_SHORT
1860     case 2:
1861       ASM_OUTPUT_SHORT (asm_out_file, x);
1862       return 1;
1863 #endif
1864
1865 #ifdef ASM_OUTPUT_INT
1866     case 4:
1867       ASM_OUTPUT_INT (asm_out_file, x);
1868       return 1;
1869 #endif
1870
1871 #ifdef ASM_OUTPUT_DOUBLE_INT
1872     case 8:
1873       ASM_OUTPUT_DOUBLE_INT (asm_out_file, x);
1874       return 1;
1875 #endif
1876
1877 #ifdef ASM_OUTPUT_QUADRUPLE_INT
1878     case 16:
1879       ASM_OUTPUT_QUADRUPLE_INT (asm_out_file, x);
1880       return 1;
1881 #endif
1882     }
1883
1884   /* If we couldn't do it that way, there are two other possibilities: First,
1885      if the machine can output an explicit byte and this is a 1 byte constant,
1886      we can use ASM_OUTPUT_BYTE.  */
1887
1888 #ifdef ASM_OUTPUT_BYTE
1889   if (size == 1 && GET_CODE (x) == CONST_INT)
1890     {
1891       ASM_OUTPUT_BYTE (asm_out_file, INTVAL (x));
1892       return 1;
1893     }
1894 #endif
1895
1896   /* Finally, if SIZE is larger than a single word, try to output the constant
1897      one word at a time.  */
1898
1899   if (size > UNITS_PER_WORD)
1900     {
1901       int i;
1902       enum machine_mode mode
1903         = mode_for_size (size * BITS_PER_UNIT, MODE_INT, 0);
1904       rtx word;
1905
1906       for (i = 0; i < size / UNITS_PER_WORD; i++)
1907         {
1908           word = operand_subword (x, i, 0, mode);
1909
1910           if (word == 0)
1911             break;
1912
1913           if (! assemble_integer (word, UNITS_PER_WORD, 0))
1914             break;
1915         }
1916
1917       if (i == size / UNITS_PER_WORD)
1918         return 1;
1919       /* If we output at least one word and then could not finish,
1920          there is no valid way to continue.  */
1921       if (i > 0)
1922         abort ();
1923     }
1924
1925   if (force)
1926     abort ();
1927
1928   return 0;
1929 }
1930 \f
1931 /* Assemble the floating-point constant D into an object of size MODE.  */
1932
1933 void
1934 assemble_real (d, mode)
1935      REAL_VALUE_TYPE d;
1936      enum machine_mode mode;
1937 {
1938   jmp_buf output_constant_handler;
1939
1940   if (setjmp (output_constant_handler))
1941     {
1942       error ("floating point trap outputting a constant");
1943 #ifdef REAL_IS_NOT_DOUBLE
1944       bzero ((char *) &d, sizeof d);
1945       d = dconst0;
1946 #else
1947       d = 0;
1948 #endif
1949     }
1950
1951   set_float_handler (output_constant_handler);
1952
1953   switch (mode)
1954     {
1955 #ifdef ASM_OUTPUT_BYTE_FLOAT
1956     case QFmode:
1957       ASM_OUTPUT_BYTE_FLOAT (asm_out_file, d);
1958       break;
1959 #endif
1960 #ifdef ASM_OUTPUT_SHORT_FLOAT
1961     case HFmode:
1962       ASM_OUTPUT_SHORT_FLOAT (asm_out_file, d);
1963       break;
1964 #endif
1965 #ifdef ASM_OUTPUT_THREE_QUARTER_FLOAT
1966     case TQFmode:
1967       ASM_OUTPUT_THREE_QUARTER_FLOAT (asm_out_file, d);
1968       break;
1969 #endif
1970 #ifdef ASM_OUTPUT_FLOAT
1971     case SFmode:
1972       ASM_OUTPUT_FLOAT (asm_out_file, d);
1973       break;
1974 #endif
1975
1976 #ifdef ASM_OUTPUT_DOUBLE
1977     case DFmode:
1978       ASM_OUTPUT_DOUBLE (asm_out_file, d);
1979       break;
1980 #endif
1981
1982 #ifdef ASM_OUTPUT_LONG_DOUBLE
1983     case XFmode:
1984     case TFmode:
1985       ASM_OUTPUT_LONG_DOUBLE (asm_out_file, d);
1986       break;
1987 #endif
1988
1989     default:
1990       abort ();
1991     }
1992
1993   set_float_handler (NULL_PTR);
1994 }
1995 \f
1996 /* Here we combine duplicate floating constants to make
1997    CONST_DOUBLE rtx's, and force those out to memory when necessary.  */
1998
1999 /* Chain of all CONST_DOUBLE rtx's constructed for the current function.
2000    They are chained through the CONST_DOUBLE_CHAIN.
2001    A CONST_DOUBLE rtx has CONST_DOUBLE_MEM != cc0_rtx iff it is on this chain.
2002    In that case, CONST_DOUBLE_MEM is either a MEM,
2003    or const0_rtx if no MEM has been made for this CONST_DOUBLE yet.
2004
2005    (CONST_DOUBLE_MEM is used only for top-level functions.
2006    See force_const_mem for explanation.)  */
2007
2008 static rtx const_double_chain;
2009
2010 /* Return a CONST_DOUBLE or CONST_INT for a value specified as a pair of ints.
2011    For an integer, I0 is the low-order word and I1 is the high-order word.
2012    For a real number, I0 is the word with the low address
2013    and I1 is the word with the high address.  */
2014
2015 rtx
2016 immed_double_const (i0, i1, mode)
2017      HOST_WIDE_INT i0, i1;
2018      enum machine_mode mode;
2019 {
2020   register rtx r;
2021   int in_current_obstack;
2022
2023   if (GET_MODE_CLASS (mode) == MODE_INT
2024       || GET_MODE_CLASS (mode) == MODE_PARTIAL_INT)
2025     {
2026       /* We clear out all bits that don't belong in MODE, unless they and our
2027          sign bit are all one.  So we get either a reasonable negative value
2028          or a reasonable unsigned value for this mode.  */
2029       int width = GET_MODE_BITSIZE (mode);
2030       if (width < HOST_BITS_PER_WIDE_INT
2031           && ((i0 & ((HOST_WIDE_INT) (-1) << (width - 1)))
2032               != ((HOST_WIDE_INT) (-1) << (width - 1))))
2033         i0 &= ((HOST_WIDE_INT) 1 << width) - 1, i1 = 0;
2034       else if (width == HOST_BITS_PER_WIDE_INT
2035                && ! (i1 == ~0 && i0 < 0))
2036         i1 = 0;
2037       else if (width > 2 * HOST_BITS_PER_WIDE_INT)
2038         /* We cannot represent this value as a constant.  */
2039         abort ();
2040
2041       /* If this would be an entire word for the target, but is not for
2042          the host, then sign-extend on the host so that the number will look
2043          the same way on the host that it would on the target.
2044
2045          For example, when building a 64 bit alpha hosted 32 bit sparc
2046          targeted compiler, then we want the 32 bit unsigned value -1 to be
2047          represented as a 64 bit value -1, and not as 0x00000000ffffffff.
2048          The later confuses the sparc backend.  */
2049
2050       if (BITS_PER_WORD < HOST_BITS_PER_WIDE_INT && BITS_PER_WORD == width
2051           && (i0 & ((HOST_WIDE_INT) 1 << (width - 1))))
2052         i0 |= ((HOST_WIDE_INT) (-1) << width);
2053
2054       /* If MODE fits within HOST_BITS_PER_WIDE_INT, always use a CONST_INT.
2055
2056          ??? Strictly speaking, this is wrong if we create a CONST_INT
2057          for a large unsigned constant with the size of MODE being
2058          HOST_BITS_PER_WIDE_INT and later try to interpret that constant in a
2059          wider mode.  In that case we will mis-interpret it as a negative
2060          number.
2061
2062          Unfortunately, the only alternative is to make a CONST_DOUBLE
2063          for any constant in any mode if it is an unsigned constant larger
2064          than the maximum signed integer in an int on the host.  However,
2065          doing this will break everyone that always expects to see a CONST_INT
2066          for SImode and smaller.
2067
2068          We have always been making CONST_INTs in this case, so nothing new
2069          is being broken.  */
2070
2071       if (width <= HOST_BITS_PER_WIDE_INT)
2072         i1 = (i0 < 0) ? ~0 : 0;
2073
2074       /* If this integer fits in one word, return a CONST_INT.  */
2075       if ((i1 == 0 && i0 >= 0)
2076           || (i1 == ~0 && i0 < 0))
2077         return GEN_INT (i0);
2078
2079       /* We use VOIDmode for integers.  */
2080       mode = VOIDmode;
2081     }
2082
2083   /* Search the chain for an existing CONST_DOUBLE with the right value.
2084      If one is found, return it.  */
2085
2086   for (r = const_double_chain; r; r = CONST_DOUBLE_CHAIN (r))
2087     if (CONST_DOUBLE_LOW (r) == i0 && CONST_DOUBLE_HIGH (r) == i1
2088         && GET_MODE (r) == mode)
2089       return r;
2090
2091   /* No; make a new one and add it to the chain.
2092
2093      We may be called by an optimizer which may be discarding any memory
2094      allocated during its processing (such as combine and loop).  However,
2095      we will be leaving this constant on the chain, so we cannot tolerate
2096      freed memory.  So switch to saveable_obstack for this allocation
2097      and then switch back if we were in current_obstack.  */
2098
2099   push_obstacks_nochange ();
2100   rtl_in_saveable_obstack ();
2101   r = gen_rtx (CONST_DOUBLE, mode, 0, i0, i1);
2102   pop_obstacks ();
2103
2104   /* Don't touch const_double_chain in nested function; see force_const_mem.
2105      Also, don't touch it if not inside any function.  */
2106   if (outer_function_chain == 0 && current_function_decl != 0)
2107     {
2108       CONST_DOUBLE_CHAIN (r) = const_double_chain;
2109       const_double_chain = r;
2110     }
2111
2112   /* Store const0_rtx in mem-slot since this CONST_DOUBLE is on the chain.
2113      Actual use of mem-slot is only through force_const_mem.  */
2114
2115   CONST_DOUBLE_MEM (r) = const0_rtx;
2116
2117   return r;
2118 }
2119
2120 /* Return a CONST_DOUBLE for a specified `double' value
2121    and machine mode.  */
2122
2123 rtx
2124 immed_real_const_1 (d, mode)
2125      REAL_VALUE_TYPE d;
2126      enum machine_mode mode;
2127 {
2128   union real_extract u;
2129   register rtx r;
2130   int in_current_obstack;
2131
2132   /* Get the desired `double' value as a sequence of ints
2133      since that is how they are stored in a CONST_DOUBLE.  */
2134
2135   u.d = d;
2136
2137   /* Detect special cases.  */
2138
2139   /* Avoid REAL_VALUES_EQUAL here in order to distinguish minus zero.  */
2140   if (!bcmp ((char *) &dconst0, (char *) &d, sizeof d))
2141     return CONST0_RTX (mode);
2142   /* Check for NaN first, because some ports (specifically the i386) do not
2143      emit correct ieee-fp code by default, and thus will generate a core
2144      dump here if we pass a NaN to REAL_VALUES_EQUAL and if REAL_VALUES_EQUAL
2145      does a floating point comparison.  */
2146   else if (! REAL_VALUE_ISNAN (d) && REAL_VALUES_EQUAL (dconst1, d))
2147     return CONST1_RTX (mode);
2148
2149   if (sizeof u == 2 * sizeof (HOST_WIDE_INT))
2150     return immed_double_const (u.i[0], u.i[1], mode);
2151
2152   /* The rest of this function handles the case where
2153      a float value requires more than 2 ints of space.
2154      It will be deleted as dead code on machines that don't need it.  */
2155
2156   /* Search the chain for an existing CONST_DOUBLE with the right value.
2157      If one is found, return it.  */
2158
2159   for (r = const_double_chain; r; r = CONST_DOUBLE_CHAIN (r))
2160     if (! bcmp ((char *) &CONST_DOUBLE_LOW (r), (char *) &u, sizeof u)
2161         && GET_MODE (r) == mode)
2162       return r;
2163
2164   /* No; make a new one and add it to the chain.
2165
2166      We may be called by an optimizer which may be discarding any memory
2167      allocated during its processing (such as combine and loop).  However,
2168      we will be leaving this constant on the chain, so we cannot tolerate
2169      freed memory.  So switch to saveable_obstack for this allocation
2170      and then switch back if we were in current_obstack.  */
2171
2172   push_obstacks_nochange ();
2173   rtl_in_saveable_obstack ();
2174   r = rtx_alloc (CONST_DOUBLE);
2175   PUT_MODE (r, mode);
2176   bcopy ((char *) &u, (char *) &CONST_DOUBLE_LOW (r), sizeof u);
2177   pop_obstacks ();
2178
2179   /* Don't touch const_double_chain in nested function; see force_const_mem.
2180      Also, don't touch it if not inside any function.  */
2181   if (outer_function_chain == 0 && current_function_decl != 0)
2182     {
2183       CONST_DOUBLE_CHAIN (r) = const_double_chain;
2184       const_double_chain = r;
2185     }
2186
2187   /* Store const0_rtx in CONST_DOUBLE_MEM since this CONST_DOUBLE is on the
2188      chain, but has not been allocated memory.  Actual use of CONST_DOUBLE_MEM
2189      is only through force_const_mem.  */
2190
2191   CONST_DOUBLE_MEM (r) = const0_rtx;
2192
2193   return r;
2194 }
2195
2196 /* Return a CONST_DOUBLE rtx for a value specified by EXP,
2197    which must be a REAL_CST tree node.  */
2198
2199 rtx
2200 immed_real_const (exp)
2201      tree exp;
2202 {
2203   return immed_real_const_1 (TREE_REAL_CST (exp), TYPE_MODE (TREE_TYPE (exp)));
2204 }
2205
2206 /* At the end of a function, forget the memory-constants
2207    previously made for CONST_DOUBLEs.  Mark them as not on real_constant_chain.
2208    Also clear out real_constant_chain and clear out all the chain-pointers.  */
2209
2210 void
2211 clear_const_double_mem ()
2212 {
2213   register rtx r, next;
2214
2215   /* Don't touch CONST_DOUBLE_MEM for nested functions.
2216      See force_const_mem for explanation.  */
2217   if (outer_function_chain != 0)
2218     return;
2219
2220   for (r = const_double_chain; r; r = next)
2221     {
2222       next = CONST_DOUBLE_CHAIN (r);
2223       CONST_DOUBLE_CHAIN (r) = 0;
2224       CONST_DOUBLE_MEM (r) = cc0_rtx;
2225     }
2226   const_double_chain = 0;
2227 }
2228 \f
2229 /* Given an expression EXP with a constant value,
2230    reduce it to the sum of an assembler symbol and an integer.
2231    Store them both in the structure *VALUE.
2232    Abort if EXP does not reduce.  */
2233
2234 struct addr_const
2235 {
2236   rtx base;
2237   HOST_WIDE_INT offset;
2238 };
2239
2240 static void
2241 decode_addr_const (exp, value)
2242      tree exp;
2243      struct addr_const *value;
2244 {
2245   register tree target = TREE_OPERAND (exp, 0);
2246   register int offset = 0;
2247   register rtx x;
2248
2249   while (1)
2250     {
2251       if (TREE_CODE (target) == COMPONENT_REF
2252           && (TREE_CODE (DECL_FIELD_BITPOS (TREE_OPERAND (target, 1)))
2253               == INTEGER_CST))
2254         {
2255           offset += TREE_INT_CST_LOW (DECL_FIELD_BITPOS (TREE_OPERAND (target, 1))) / BITS_PER_UNIT;
2256           target = TREE_OPERAND (target, 0);
2257         }
2258       else if (TREE_CODE (target) == ARRAY_REF)
2259         {
2260           if (TREE_CODE (TREE_OPERAND (target, 1)) != INTEGER_CST
2261               || TREE_CODE (TYPE_SIZE (TREE_TYPE (target))) != INTEGER_CST)
2262             abort ();
2263           offset += ((TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (target)))
2264                       * TREE_INT_CST_LOW (TREE_OPERAND (target, 1)))
2265                      / BITS_PER_UNIT);
2266           target = TREE_OPERAND (target, 0);
2267         }
2268       else
2269         break;
2270     }
2271
2272   switch (TREE_CODE (target))
2273     {
2274     case VAR_DECL:
2275     case FUNCTION_DECL:
2276       x = DECL_RTL (target);
2277       break;
2278
2279     case LABEL_DECL:
2280       if (output_bytecode)
2281         /* FIXME: this may not be correct, check it */
2282         x = bc_gen_rtx (TREE_STRING_POINTER (target), 0, (struct bc_label *) 0);
2283       else
2284         x = gen_rtx (MEM, FUNCTION_MODE,
2285                      gen_rtx (LABEL_REF, VOIDmode,
2286                               label_rtx (TREE_OPERAND (exp, 0))));
2287       break;
2288
2289     case REAL_CST:
2290     case STRING_CST:
2291     case COMPLEX_CST:
2292     case CONSTRUCTOR:
2293     case INTEGER_CST:
2294       x = TREE_CST_RTL (target);
2295       break;
2296
2297     default:
2298       abort ();
2299     }
2300
2301   if (!output_bytecode)
2302     {
2303       if (GET_CODE (x) != MEM)
2304         abort ();
2305       x = XEXP (x, 0);
2306     }
2307
2308   value->base = x;
2309   value->offset = offset;
2310 }
2311 \f
2312 /* Uniquize all constants that appear in memory.
2313    Each constant in memory thus far output is recorded
2314    in `const_hash_table' with a `struct constant_descriptor'
2315    that contains a polish representation of the value of
2316    the constant.
2317
2318    We cannot store the trees in the hash table
2319    because the trees may be temporary.  */
2320
2321 struct constant_descriptor
2322 {
2323   struct constant_descriptor *next;
2324   char *label;
2325   char contents[1];
2326 };
2327
2328 #define HASHBITS 30
2329 #define MAX_HASH_TABLE 1009
2330 static struct constant_descriptor *const_hash_table[MAX_HASH_TABLE];
2331
2332 /* Compute a hash code for a constant expression.  */
2333
2334 static int
2335 const_hash (exp)
2336      tree exp;
2337 {
2338   register char *p;
2339   register int len, hi, i;
2340   register enum tree_code code = TREE_CODE (exp);
2341
2342   if (code == INTEGER_CST)
2343     {
2344       p = (char *) &TREE_INT_CST_LOW (exp);
2345       len = 2 * sizeof TREE_INT_CST_LOW (exp);
2346     }
2347   else if (code == REAL_CST)
2348     {
2349       p = (char *) &TREE_REAL_CST (exp);
2350       len = sizeof TREE_REAL_CST (exp);
2351     }
2352   else if (code == STRING_CST)
2353     p = TREE_STRING_POINTER (exp), len = TREE_STRING_LENGTH (exp);
2354   else if (code == COMPLEX_CST)
2355     return const_hash (TREE_REALPART (exp)) * 5
2356       + const_hash (TREE_IMAGPART (exp));
2357   else if (code == CONSTRUCTOR && TREE_CODE (TREE_TYPE (exp)) == SET_TYPE)
2358     {
2359       len = int_size_in_bytes (TREE_TYPE (exp));
2360       p = (char *) alloca (len);
2361       get_set_constructor_bytes (exp, (unsigned char *) p, len);
2362     }
2363   else if (code == CONSTRUCTOR)
2364     {
2365       register tree link;
2366
2367       /* For record type, include the type in the hashing.
2368          We do not do so for array types
2369          because (1) the sizes of the elements are sufficient
2370          and (2) distinct array types can have the same constructor.
2371          Instead, we include the array size because the constructor could
2372          be shorter.  */
2373       if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
2374         hi = ((HOST_WIDE_INT) TREE_TYPE (exp) & ((1 << HASHBITS) - 1))
2375           % MAX_HASH_TABLE;
2376       else
2377         hi = ((5 + int_size_in_bytes (TREE_TYPE (exp)))
2378                & ((1 << HASHBITS) - 1)) % MAX_HASH_TABLE;
2379
2380       for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
2381         if (TREE_VALUE (link))
2382           hi = (hi * 603 + const_hash (TREE_VALUE (link))) % MAX_HASH_TABLE;
2383
2384       return hi;
2385     }
2386   else if (code == ADDR_EXPR)
2387     {
2388       struct addr_const value;
2389       decode_addr_const (exp, &value);
2390       if (GET_CODE (value.base) == SYMBOL_REF)
2391         {
2392           /* Don't hash the address of the SYMBOL_REF;
2393              only use the offset and the symbol name.  */
2394           hi = value.offset;
2395           p = XSTR (value.base, 0);
2396           for (i = 0; p[i] != 0; i++)
2397             hi = ((hi * 613) + (unsigned) (p[i]));
2398         }
2399       else if (GET_CODE (value.base) == LABEL_REF)
2400         hi = value.offset + CODE_LABEL_NUMBER (XEXP (value.base, 0)) * 13;
2401
2402       hi &= (1 << HASHBITS) - 1;
2403       hi %= MAX_HASH_TABLE;
2404       return hi;
2405     }
2406   else if (code == PLUS_EXPR || code == MINUS_EXPR)
2407     return const_hash (TREE_OPERAND (exp, 0)) * 9
2408       +  const_hash (TREE_OPERAND (exp, 1));
2409   else if (code == NOP_EXPR || code == CONVERT_EXPR)
2410     return const_hash (TREE_OPERAND (exp, 0)) * 7 + 2;
2411
2412   /* Compute hashing function */
2413   hi = len;
2414   for (i = 0; i < len; i++)
2415     hi = ((hi * 613) + (unsigned) (p[i]));
2416
2417   hi &= (1 << HASHBITS) - 1;
2418   hi %= MAX_HASH_TABLE;
2419   return hi;
2420 }
2421 \f
2422 /* Compare a constant expression EXP with a constant-descriptor DESC.
2423    Return 1 if DESC describes a constant with the same value as EXP.  */
2424
2425 static int
2426 compare_constant (exp, desc)
2427      tree exp;
2428      struct constant_descriptor *desc;
2429 {
2430   return 0 != compare_constant_1 (exp, desc->contents);
2431 }
2432
2433 /* Compare constant expression EXP with a substring P of a constant descriptor.
2434    If they match, return a pointer to the end of the substring matched.
2435    If they do not match, return 0.
2436
2437    Since descriptors are written in polish prefix notation,
2438    this function can be used recursively to test one operand of EXP
2439    against a subdescriptor, and if it succeeds it returns the
2440    address of the subdescriptor for the next operand.  */
2441
2442 static char *
2443 compare_constant_1 (exp, p)
2444      tree exp;
2445      char *p;
2446 {
2447   register char *strp;
2448   register int len;
2449   register enum tree_code code = TREE_CODE (exp);
2450
2451   if (code != (enum tree_code) *p++)
2452     return 0;
2453
2454   if (code == INTEGER_CST)
2455     {
2456       /* Integer constants are the same only if the same width of type.  */
2457       if (*p++ != TYPE_PRECISION (TREE_TYPE (exp)))
2458         return 0;
2459       strp = (char *) &TREE_INT_CST_LOW (exp);
2460       len = 2 * sizeof TREE_INT_CST_LOW (exp);
2461     }
2462   else if (code == REAL_CST)
2463     {
2464       /* Real constants are the same only if the same width of type.  */
2465       if (*p++ != TYPE_PRECISION (TREE_TYPE (exp)))
2466         return 0;
2467       strp = (char *) &TREE_REAL_CST (exp);
2468       len = sizeof TREE_REAL_CST (exp);
2469     }
2470   else if (code == STRING_CST)
2471     {
2472       if (flag_writable_strings)
2473         return 0;
2474       strp = TREE_STRING_POINTER (exp);
2475       len = TREE_STRING_LENGTH (exp);
2476       if (bcmp ((char *) &TREE_STRING_LENGTH (exp), p,
2477                 sizeof TREE_STRING_LENGTH (exp)))
2478         return 0;
2479       p += sizeof TREE_STRING_LENGTH (exp);
2480     }
2481   else if (code == COMPLEX_CST)
2482     {
2483       p = compare_constant_1 (TREE_REALPART (exp), p);
2484       if (p == 0) return 0;
2485       p = compare_constant_1 (TREE_IMAGPART (exp), p);
2486       return p;
2487     }
2488   else if (code == CONSTRUCTOR && TREE_CODE (TREE_TYPE (exp)) == SET_TYPE)
2489     {
2490       int xlen = len = int_size_in_bytes (TREE_TYPE (exp));
2491       strp = (char *) alloca (len);
2492       get_set_constructor_bytes (exp, (unsigned char *) strp, len);
2493       if (bcmp ((char *) &xlen, p, sizeof xlen))
2494         return 0;
2495       p += sizeof xlen;
2496     }
2497   else if (code == CONSTRUCTOR)
2498     {
2499       register tree link;
2500       int length = list_length (CONSTRUCTOR_ELTS (exp));
2501       tree type;
2502
2503       if (bcmp ((char *) &length, p, sizeof length))
2504         return 0;
2505       p += sizeof length;
2506
2507       /* For record constructors, insist that the types match.
2508          For arrays, just verify both constructors are for arrays.  */
2509       if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
2510         type = TREE_TYPE (exp);
2511       else
2512         type = 0;
2513       if (bcmp ((char *) &type, p, sizeof type))
2514         return 0;
2515       p += sizeof type;
2516
2517       /* For arrays, insist that the size in bytes match.  */
2518       if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
2519         {
2520           int size = int_size_in_bytes (TREE_TYPE (exp));
2521           if (bcmp ((char *) &size, p, sizeof size))
2522             return 0;
2523           p += sizeof size;
2524         }
2525
2526       for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
2527         {
2528           if (TREE_VALUE (link))
2529             {
2530               if ((p = compare_constant_1 (TREE_VALUE (link), p)) == 0)
2531                 return 0;
2532             }
2533           else
2534             {
2535               tree zero = 0;
2536
2537               if (bcmp ((char *) &zero, p, sizeof zero))
2538                 return 0;
2539               p += sizeof zero;
2540             }
2541         }
2542
2543       return p;
2544     }
2545   else if (code == ADDR_EXPR)
2546     {
2547       struct addr_const value;
2548       decode_addr_const (exp, &value);
2549       strp = (char *) &value.offset;
2550       len = sizeof value.offset;
2551       /* Compare the offset.  */
2552       while (--len >= 0)
2553         if (*p++ != *strp++)
2554           return 0;
2555       /* Compare symbol name.  */
2556       strp = XSTR (value.base, 0);
2557       len = strlen (strp) + 1;
2558     }
2559   else if (code == PLUS_EXPR || code == MINUS_EXPR)
2560     {
2561       p = compare_constant_1 (TREE_OPERAND (exp, 0), p);
2562       if (p == 0) return 0;
2563       p = compare_constant_1 (TREE_OPERAND (exp, 1), p);
2564       return p;
2565     }
2566   else if (code == NOP_EXPR || code == CONVERT_EXPR)
2567     {
2568       p = compare_constant_1 (TREE_OPERAND (exp, 0), p);
2569       return p;
2570     }
2571
2572   /* Compare constant contents.  */
2573   while (--len >= 0)
2574     if (*p++ != *strp++)
2575       return 0;
2576
2577   return p;
2578 }
2579 \f
2580 /* Construct a constant descriptor for the expression EXP.
2581    It is up to the caller to enter the descriptor in the hash table.  */
2582
2583 static struct constant_descriptor *
2584 record_constant (exp)
2585      tree exp;
2586 {
2587   struct constant_descriptor *next = 0;
2588   char *label = 0;
2589
2590   /* Make a struct constant_descriptor.  The first two pointers will
2591      be filled in later.  Here we just leave space for them.  */
2592
2593   obstack_grow (&permanent_obstack, (char *) &next, sizeof next);
2594   obstack_grow (&permanent_obstack, (char *) &label, sizeof label);
2595   record_constant_1 (exp);
2596   return (struct constant_descriptor *) obstack_finish (&permanent_obstack);
2597 }
2598
2599 /* Add a description of constant expression EXP
2600    to the object growing in `permanent_obstack'.
2601    No need to return its address; the caller will get that
2602    from the obstack when the object is complete.  */
2603
2604 static void
2605 record_constant_1 (exp)
2606      tree exp;
2607 {
2608   register char *strp;
2609   register int len;
2610   register enum tree_code code = TREE_CODE (exp);
2611
2612   obstack_1grow (&permanent_obstack, (unsigned int) code);
2613
2614   switch (code)
2615     {
2616     case INTEGER_CST:
2617       obstack_1grow (&permanent_obstack, TYPE_PRECISION (TREE_TYPE (exp)));
2618       strp = (char *) &TREE_INT_CST_LOW (exp);
2619       len = 2 * sizeof TREE_INT_CST_LOW (exp);
2620       break;
2621
2622     case REAL_CST:
2623       obstack_1grow (&permanent_obstack, TYPE_PRECISION (TREE_TYPE (exp)));
2624       strp = (char *) &TREE_REAL_CST (exp);
2625       len = sizeof TREE_REAL_CST (exp);
2626       break;
2627
2628     case STRING_CST:
2629       if (flag_writable_strings)
2630         return;
2631
2632       strp = TREE_STRING_POINTER (exp);
2633       len = TREE_STRING_LENGTH (exp);
2634       obstack_grow (&permanent_obstack, (char *) &TREE_STRING_LENGTH (exp),
2635                     sizeof TREE_STRING_LENGTH (exp));
2636       break;
2637
2638     case COMPLEX_CST:
2639       record_constant_1 (TREE_REALPART (exp));
2640       record_constant_1 (TREE_IMAGPART (exp));
2641       return;
2642
2643     case CONSTRUCTOR:
2644       if (TREE_CODE (TREE_TYPE (exp)) == SET_TYPE)
2645         {
2646           int nbytes = int_size_in_bytes (TREE_TYPE (exp));
2647           obstack_grow (&permanent_obstack, &nbytes, sizeof (nbytes));
2648           obstack_blank (&permanent_obstack, nbytes);
2649           get_set_constructor_bytes
2650             (exp, (unsigned char *) permanent_obstack.next_free-nbytes,
2651              nbytes);
2652           return;
2653         }
2654       else
2655         {
2656           register tree link;
2657           int length = list_length (CONSTRUCTOR_ELTS (exp));
2658           tree type;
2659
2660           obstack_grow (&permanent_obstack, (char *) &length, sizeof length);
2661
2662           /* For record constructors, insist that the types match.
2663              For arrays, just verify both constructors are for arrays.  */
2664           if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
2665             type = TREE_TYPE (exp);
2666           else
2667             type = 0;
2668           obstack_grow (&permanent_obstack, (char *) &type, sizeof type);
2669
2670           /* For arrays, insist that the size in bytes match.  */
2671           if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
2672             {
2673               int size = int_size_in_bytes (TREE_TYPE (exp));
2674               obstack_grow (&permanent_obstack, (char *) &size, sizeof size);
2675             }
2676
2677           for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
2678             {
2679               if (TREE_VALUE (link))
2680                 record_constant_1 (TREE_VALUE (link));
2681               else
2682                 {
2683                   tree zero = 0;
2684
2685                   obstack_grow (&permanent_obstack,
2686                                 (char *) &zero, sizeof zero);
2687                 }
2688             }
2689         }
2690       return;
2691
2692     case ADDR_EXPR:
2693       {
2694         struct addr_const value;
2695
2696         decode_addr_const (exp, &value);
2697         /* Record the offset.  */
2698         obstack_grow (&permanent_obstack,
2699                       (char *) &value.offset, sizeof value.offset);
2700         /* Record the symbol name.  */
2701         obstack_grow (&permanent_obstack, XSTR (value.base, 0),
2702                       strlen (XSTR (value.base, 0)) + 1);
2703       }
2704       return;
2705
2706     case PLUS_EXPR:
2707     case MINUS_EXPR:
2708       record_constant_1 (TREE_OPERAND (exp, 0));
2709       record_constant_1 (TREE_OPERAND (exp, 1));
2710       return;
2711
2712     case NOP_EXPR:
2713     case CONVERT_EXPR:
2714     case NON_LVALUE_EXPR:
2715       record_constant_1 (TREE_OPERAND (exp, 0));
2716       return;
2717
2718     default:
2719       abort ();
2720     }
2721
2722   /* Record constant contents.  */
2723   obstack_grow (&permanent_obstack, strp, len);
2724 }
2725 \f
2726 /* Record a list of constant expressions that were passed to
2727    output_constant_def but that could not be output right away.  */
2728
2729 struct deferred_constant
2730 {
2731   struct deferred_constant *next;
2732   tree exp;
2733   int reloc;
2734   int labelno;
2735 };
2736
2737 static struct deferred_constant *deferred_constants;
2738
2739 /* Nonzero means defer output of addressed subconstants
2740    (i.e., those for which output_constant_def is called.)  */
2741 static int defer_addressed_constants_flag;
2742
2743 /* Start deferring output of subconstants.  */
2744
2745 void
2746 defer_addressed_constants ()
2747 {
2748   defer_addressed_constants_flag++;
2749 }
2750
2751 /* Stop deferring output of subconstants,
2752    and output now all those that have been deferred.  */
2753
2754 void
2755 output_deferred_addressed_constants ()
2756 {
2757   struct deferred_constant *p, *next;
2758
2759   defer_addressed_constants_flag--;
2760
2761   if (defer_addressed_constants_flag > 0)
2762     return;
2763
2764   for (p = deferred_constants; p; p = next)
2765     {
2766       output_constant_def_contents (p->exp, p->reloc, p->labelno);
2767       next = p->next;
2768       free (p);
2769     }
2770
2771   deferred_constants = 0;
2772 }
2773
2774 /* Make a copy of the whole tree structure for a constant.
2775    This handles the same types of nodes that compare_constant
2776    and record_constant handle.  */
2777
2778 static tree
2779 copy_constant (exp)
2780      tree exp;
2781 {
2782   switch (TREE_CODE (exp))
2783     {
2784     case ADDR_EXPR:
2785       /* For ADDR_EXPR, we do not want to copy the decl whose address
2786          is requested.  We do want to copy constants though.  */
2787       if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 0))) == 'c')
2788         return build1 (TREE_CODE (exp), TREE_TYPE (exp),
2789                        copy_constant (TREE_OPERAND (exp, 0)));
2790       else
2791         return copy_node (exp);
2792
2793     case INTEGER_CST:
2794     case REAL_CST:
2795     case STRING_CST:
2796       return copy_node (exp);
2797
2798     case COMPLEX_CST:
2799       return build_complex (TREE_TYPE (exp),
2800                             copy_constant (TREE_REALPART (exp)),
2801                             copy_constant (TREE_IMAGPART (exp)));
2802
2803     case PLUS_EXPR:
2804     case MINUS_EXPR:
2805       return build (TREE_CODE (exp), TREE_TYPE (exp),
2806                     copy_constant (TREE_OPERAND (exp, 0)),
2807                     copy_constant (TREE_OPERAND (exp, 1)));
2808
2809     case NOP_EXPR:
2810     case CONVERT_EXPR:
2811       return build1 (TREE_CODE (exp), TREE_TYPE (exp),
2812                      copy_constant (TREE_OPERAND (exp, 0)));
2813
2814     case CONSTRUCTOR:
2815       {
2816         tree copy = copy_node (exp);
2817         tree list = copy_list (CONSTRUCTOR_ELTS (exp));
2818         tree tail;
2819
2820         CONSTRUCTOR_ELTS (copy) = list;
2821         for (tail = list; tail; tail = TREE_CHAIN (tail))
2822           TREE_VALUE (tail) = copy_constant (TREE_VALUE (tail));
2823         if (TREE_CODE (TREE_TYPE (exp)) == SET_TYPE)
2824           for (tail = list; tail; tail = TREE_CHAIN (tail))
2825             TREE_PURPOSE (tail) = copy_constant (TREE_PURPOSE (tail));
2826
2827         return copy;
2828       }
2829
2830     default:
2831       abort ();
2832     }
2833 }
2834 \f
2835 /* Return an rtx representing a reference to constant data in memory
2836    for the constant expression EXP.
2837
2838    If assembler code for such a constant has already been output,
2839    return an rtx to refer to it.
2840    Otherwise, output such a constant in memory (or defer it for later)
2841    and generate an rtx for it.
2842
2843    The TREE_CST_RTL of EXP is set up to point to that rtx.
2844    The const_hash_table records which constants already have label strings.  */
2845
2846 rtx
2847 output_constant_def (exp)
2848      tree exp;
2849 {
2850   register int hash;
2851   register struct constant_descriptor *desc;
2852   char label[256];
2853   char *found = 0;
2854   int reloc;
2855   register rtx def;
2856
2857   if (TREE_CST_RTL (exp))
2858     return TREE_CST_RTL (exp);
2859
2860   /* Make sure any other constants whose addresses appear in EXP
2861      are assigned label numbers.  */
2862
2863   reloc = output_addressed_constants (exp);
2864
2865   /* Compute hash code of EXP.  Search the descriptors for that hash code
2866      to see if any of them describes EXP.  If yes, the descriptor records
2867      the label number already assigned.  */
2868
2869   hash = const_hash (exp) % MAX_HASH_TABLE;
2870
2871   for (desc = const_hash_table[hash]; desc; desc = desc->next)
2872     if (compare_constant (exp, desc))
2873       {
2874         found = desc->label;
2875         break;
2876       }
2877
2878   if (found == 0)
2879     {
2880       /* No constant equal to EXP is known to have been output.
2881          Make a constant descriptor to enter EXP in the hash table.
2882          Assign the label number and record it in the descriptor for
2883          future calls to this function to find.  */
2884
2885       /* Create a string containing the label name, in LABEL.  */
2886       ASM_GENERATE_INTERNAL_LABEL (label, "LC", const_labelno);
2887
2888       desc = record_constant (exp);
2889       desc->next = const_hash_table[hash];
2890       desc->label
2891         = (char *) obstack_copy0 (&permanent_obstack, label, strlen (label));
2892       const_hash_table[hash] = desc;
2893     }
2894   else
2895     {
2896       /* Create a string containing the label name, in LABEL.  */
2897       ASM_GENERATE_INTERNAL_LABEL (label, "LC", const_labelno);
2898     }
2899
2900   /* We have a symbol name; construct the SYMBOL_REF and the MEM.  */
2901
2902   push_obstacks_nochange ();
2903   if (TREE_PERMANENT (exp))
2904     end_temporary_allocation ();
2905
2906   def = gen_rtx (SYMBOL_REF, Pmode, desc->label);
2907
2908   TREE_CST_RTL (exp)
2909     = gen_rtx (MEM, TYPE_MODE (TREE_TYPE (exp)), def);
2910   RTX_UNCHANGING_P (TREE_CST_RTL (exp)) = 1;
2911   if (AGGREGATE_TYPE_P (TREE_TYPE (exp)))
2912     MEM_IN_STRUCT_P (TREE_CST_RTL (exp)) = 1;
2913
2914   pop_obstacks ();
2915
2916   /* Optionally set flags or add text to the name to record information
2917      such as that it is a function name.  If the name is changed, the macro
2918      ASM_OUTPUT_LABELREF will have to know how to strip this information.  */
2919 #ifdef ENCODE_SECTION_INFO
2920   ENCODE_SECTION_INFO (exp);
2921 #endif
2922
2923   /* If this is the first time we've seen this particular constant,
2924      output it (or defer its output for later).  */
2925   if (found == 0)
2926     {
2927       if (defer_addressed_constants_flag)
2928         {
2929           struct deferred_constant *p;
2930           p = (struct deferred_constant *) xmalloc (sizeof (struct deferred_constant));
2931
2932           push_obstacks_nochange ();
2933           suspend_momentary ();
2934           p->exp = copy_constant (exp);
2935           pop_obstacks ();
2936           p->reloc = reloc;
2937           p->labelno = const_labelno++;
2938           p->next = deferred_constants;
2939           deferred_constants = p;
2940         }
2941       else
2942         output_constant_def_contents (exp, reloc, const_labelno++);
2943     }
2944
2945   return TREE_CST_RTL (exp);
2946 }
2947
2948 /* Now output assembler code to define the label for EXP,
2949    and follow it with the data of EXP.  */
2950
2951 static void
2952 output_constant_def_contents (exp, reloc, labelno)
2953      tree exp;
2954      int reloc;
2955      int labelno;
2956 {
2957   int align;
2958
2959   if (IN_NAMED_SECTION (exp))
2960     named_section (exp, NULL);
2961   else
2962     {
2963       /* First switch to text section, except for writable strings.  */
2964 #ifdef SELECT_SECTION
2965       SELECT_SECTION (exp, reloc);
2966 #else
2967       if (((TREE_CODE (exp) == STRING_CST) && flag_writable_strings)
2968           || (flag_pic && reloc))
2969         data_section ();
2970       else
2971         readonly_data_section ();
2972 #endif
2973     }
2974
2975   /* Align the location counter as required by EXP's data type.  */
2976   align = TYPE_ALIGN (TREE_TYPE (exp));
2977 #ifdef CONSTANT_ALIGNMENT
2978   align = CONSTANT_ALIGNMENT (exp, align);
2979 #endif
2980
2981   if (align > BITS_PER_UNIT)
2982     {
2983       if (!output_bytecode)
2984         {
2985           ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
2986         }
2987       else
2988         {
2989           BC_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
2990         }
2991     }
2992
2993   /* Output the label itself.  */
2994   ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LC", labelno);
2995
2996   /* Output the value of EXP.  */
2997   output_constant (exp,
2998                    (TREE_CODE (exp) == STRING_CST
2999                     ? TREE_STRING_LENGTH (exp)
3000                     : int_size_in_bytes (TREE_TYPE (exp))));
3001
3002 }
3003 \f
3004 /* Similar hash facility for making memory-constants
3005    from constant rtl-expressions.  It is used on RISC machines
3006    where immediate integer arguments and constant addresses are restricted
3007    so that such constants must be stored in memory.
3008
3009    This pool of constants is reinitialized for each function
3010    so each function gets its own constants-pool that comes right before it.
3011
3012    All structures allocated here are discarded when functions are saved for
3013    inlining, so they do not need to be allocated permanently.  */
3014
3015 #define MAX_RTX_HASH_TABLE 61
3016 static struct constant_descriptor **const_rtx_hash_table;
3017
3018 /* Structure to represent sufficient information about a constant so that
3019    it can be output when the constant pool is output, so that function
3020    integration can be done, and to simplify handling on machines that reference
3021    constant pool as base+displacement.  */
3022
3023 struct pool_constant
3024 {
3025   struct constant_descriptor *desc;
3026   struct pool_constant *next;
3027   enum machine_mode mode;
3028   rtx constant;
3029   int labelno;
3030   int align;
3031   int offset;
3032 };
3033
3034 /* Pointers to first and last constant in pool.  */
3035
3036 static struct pool_constant *first_pool, *last_pool;
3037
3038 /* Current offset in constant pool (does not include any machine-specific
3039    header.  */
3040
3041 static int pool_offset;
3042
3043 /* Structure used to maintain hash table mapping symbols used to their
3044    corresponding constants.  */
3045
3046 struct pool_sym
3047 {
3048   char *label;
3049   struct pool_constant *pool;
3050   struct pool_sym *next;
3051 };
3052
3053 static struct pool_sym **const_rtx_sym_hash_table;
3054
3055 /* Hash code for a SYMBOL_REF with CONSTANT_POOL_ADDRESS_P true.
3056    The argument is XSTR (... , 0)  */
3057
3058 #define SYMHASH(LABEL)  \
3059   ((((HOST_WIDE_INT) (LABEL)) & ((1 << HASHBITS) - 1))  % MAX_RTX_HASH_TABLE)
3060 \f
3061 /* Initialize constant pool hashing for next function.  */
3062
3063 void
3064 init_const_rtx_hash_table ()
3065 {
3066   const_rtx_hash_table
3067     = ((struct constant_descriptor **)
3068        oballoc (MAX_RTX_HASH_TABLE * sizeof (struct constant_descriptor *)));
3069   const_rtx_sym_hash_table
3070     = ((struct pool_sym **)
3071        oballoc (MAX_RTX_HASH_TABLE * sizeof (struct pool_sym *)));
3072   bzero ((char *) const_rtx_hash_table,
3073          MAX_RTX_HASH_TABLE * sizeof (struct constant_descriptor *));
3074   bzero ((char *) const_rtx_sym_hash_table,
3075          MAX_RTX_HASH_TABLE * sizeof (struct pool_sym *));
3076
3077   first_pool = last_pool = 0;
3078   pool_offset = 0;
3079 }
3080
3081 /* Save and restore status for a nested function.  */
3082
3083 void
3084 save_varasm_status (p)
3085      struct function *p;
3086 {
3087   p->const_rtx_hash_table = const_rtx_hash_table;
3088   p->const_rtx_sym_hash_table = const_rtx_sym_hash_table;
3089   p->first_pool = first_pool;
3090   p->last_pool = last_pool;
3091   p->pool_offset = pool_offset;
3092 }
3093
3094 void
3095 restore_varasm_status (p)
3096      struct function *p;
3097 {
3098   const_rtx_hash_table = p->const_rtx_hash_table;
3099   const_rtx_sym_hash_table = p->const_rtx_sym_hash_table;
3100   first_pool = p->first_pool;
3101   last_pool = p->last_pool;
3102   pool_offset = p->pool_offset;
3103 }
3104 \f
3105 enum kind { RTX_DOUBLE, RTX_INT };
3106
3107 struct rtx_const
3108 {
3109 #ifdef ONLY_INT_FIELDS
3110   unsigned int kind : 16;
3111   unsigned int mode : 16;
3112 #else
3113   enum kind kind : 16;
3114   enum machine_mode mode : 16;
3115 #endif
3116   union {
3117     union real_extract du;
3118     struct addr_const addr;
3119     struct {HOST_WIDE_INT high, low;} di;
3120   } un;
3121 };
3122
3123 /* Express an rtx for a constant integer (perhaps symbolic)
3124    as the sum of a symbol or label plus an explicit integer.
3125    They are stored into VALUE.  */
3126
3127 static void
3128 decode_rtx_const (mode, x, value)
3129      enum machine_mode mode;
3130      rtx x;
3131      struct rtx_const *value;
3132 {
3133   /* Clear the whole structure, including any gaps.  */
3134
3135   {
3136     int *p = (int *) value;
3137     int *end = (int *) (value + 1);
3138     while (p < end)
3139       *p++ = 0;
3140   }
3141
3142   value->kind = RTX_INT;        /* Most usual kind.  */
3143   value->mode = mode;
3144
3145   switch (GET_CODE (x))
3146     {
3147     case CONST_DOUBLE:
3148       value->kind = RTX_DOUBLE;
3149       if (GET_MODE (x) != VOIDmode)
3150         {
3151           value->mode = GET_MODE (x);
3152           bcopy ((char *) &CONST_DOUBLE_LOW (x),
3153                  (char *) &value->un.du, sizeof value->un.du);
3154         }
3155       else
3156         {
3157           value->un.di.low = CONST_DOUBLE_LOW (x);
3158           value->un.di.high = CONST_DOUBLE_HIGH (x);
3159         }
3160       break;
3161
3162     case CONST_INT:
3163       value->un.addr.offset = INTVAL (x);
3164       break;
3165
3166     case SYMBOL_REF:
3167     case LABEL_REF:
3168     case PC:
3169       value->un.addr.base = x;
3170       break;
3171
3172     case CONST:
3173       x = XEXP (x, 0);
3174       if (GET_CODE (x) == PLUS)
3175         {
3176           value->un.addr.base = XEXP (x, 0);
3177           if (GET_CODE (XEXP (x, 1)) != CONST_INT)
3178             abort ();
3179           value->un.addr.offset = INTVAL (XEXP (x, 1));
3180         }
3181       else if (GET_CODE (x) == MINUS)
3182         {
3183           value->un.addr.base = XEXP (x, 0);
3184           if (GET_CODE (XEXP (x, 1)) != CONST_INT)
3185             abort ();
3186           value->un.addr.offset = - INTVAL (XEXP (x, 1));
3187         }
3188       else
3189         abort ();
3190       break;
3191
3192     default:
3193       abort ();
3194     }
3195
3196   if (value->kind == RTX_INT && value->un.addr.base != 0)
3197     switch (GET_CODE (value->un.addr.base))
3198       {
3199       case SYMBOL_REF:
3200       case LABEL_REF:
3201         /* Use the string's address, not the SYMBOL_REF's address,
3202            for the sake of addresses of library routines.
3203            For a LABEL_REF, compare labels.  */
3204         value->un.addr.base = XEXP (value->un.addr.base, 0);
3205       }
3206 }
3207
3208 /* Given a MINUS expression, simplify it if both sides
3209    include the same symbol.  */
3210
3211 rtx
3212 simplify_subtraction (x)
3213      rtx x;
3214 {
3215   struct rtx_const val0, val1;
3216
3217   decode_rtx_const (GET_MODE (x), XEXP (x, 0), &val0);
3218   decode_rtx_const (GET_MODE (x), XEXP (x, 1), &val1);
3219
3220   if (val0.un.addr.base == val1.un.addr.base)
3221     return GEN_INT (val0.un.addr.offset - val1.un.addr.offset);
3222   return x;
3223 }
3224
3225 /* Compute a hash code for a constant RTL expression.  */
3226
3227 static int
3228 const_hash_rtx (mode, x)
3229      enum machine_mode mode;
3230      rtx x;
3231 {
3232   register int hi, i;
3233
3234   struct rtx_const value;
3235   decode_rtx_const (mode, x, &value);
3236
3237   /* Compute hashing function */
3238   hi = 0;
3239   for (i = 0; i < sizeof value / sizeof (int); i++)
3240     hi += ((int *) &value)[i];
3241
3242   hi &= (1 << HASHBITS) - 1;
3243   hi %= MAX_RTX_HASH_TABLE;
3244   return hi;
3245 }
3246
3247 /* Compare a constant rtl object X with a constant-descriptor DESC.
3248    Return 1 if DESC describes a constant with the same value as X.  */
3249
3250 static int
3251 compare_constant_rtx (mode, x, desc)
3252      enum machine_mode mode;
3253      rtx x;
3254      struct constant_descriptor *desc;
3255 {
3256   register int *p = (int *) desc->contents;
3257   register int *strp;
3258   register int len;
3259   struct rtx_const value;
3260
3261   decode_rtx_const (mode, x, &value);
3262   strp = (int *) &value;
3263   len = sizeof value / sizeof (int);
3264
3265   /* Compare constant contents.  */
3266   while (--len >= 0)
3267     if (*p++ != *strp++)
3268       return 0;
3269
3270   return 1;
3271 }
3272
3273 /* Construct a constant descriptor for the rtl-expression X.
3274    It is up to the caller to enter the descriptor in the hash table.  */
3275
3276 static struct constant_descriptor *
3277 record_constant_rtx (mode, x)
3278      enum machine_mode mode;
3279      rtx x;
3280 {
3281   struct constant_descriptor *ptr;
3282   char *label;
3283   struct rtx_const value;
3284
3285   decode_rtx_const (mode, x, &value);
3286
3287   /* Put these things in the saveable obstack so we can ensure it won't
3288      be freed if we are called from combine or some other phase that discards
3289      memory allocated from function_obstack (current_obstack).  */
3290   obstack_grow (saveable_obstack, &ptr, sizeof ptr);
3291   obstack_grow (saveable_obstack, &label, sizeof label);
3292
3293   /* Record constant contents.  */
3294   obstack_grow (saveable_obstack, &value, sizeof value);
3295
3296   return (struct constant_descriptor *) obstack_finish (saveable_obstack);
3297 }
3298 \f
3299 /* Given a constant rtx X, make (or find) a memory constant for its value
3300    and return a MEM rtx to refer to it in memory.  */
3301
3302 rtx
3303 force_const_mem (mode, x)
3304      enum machine_mode mode;
3305      rtx x;
3306 {
3307   register int hash;
3308   register struct constant_descriptor *desc;
3309   char label[256];
3310   char *found = 0;
3311   rtx def;
3312
3313   /* If we want this CONST_DOUBLE in the same mode as it is in memory
3314      (this will always be true for floating CONST_DOUBLEs that have been
3315      placed in memory, but not for VOIDmode (integer) CONST_DOUBLEs),
3316      use the previous copy.  Otherwise, make a new one.  Note that in
3317      the unlikely event that this same CONST_DOUBLE is used in two different
3318      modes in an alternating fashion, we will allocate a lot of different
3319      memory locations, but this should be extremely rare.  */
3320
3321   /* Don't use CONST_DOUBLE_MEM in a nested function.
3322      Nested functions have their own constant pools,
3323      so they can't share the same values in CONST_DOUBLE_MEM
3324      with the containing function.  */
3325   if (outer_function_chain == 0)
3326     if (GET_CODE (x) == CONST_DOUBLE
3327         && GET_CODE (CONST_DOUBLE_MEM (x)) == MEM
3328         && GET_MODE (CONST_DOUBLE_MEM (x)) == mode)
3329       return CONST_DOUBLE_MEM (x);
3330
3331   /* Compute hash code of X.  Search the descriptors for that hash code
3332      to see if any of them describes X.  If yes, the descriptor records
3333      the label number already assigned.  */
3334
3335   hash = const_hash_rtx (mode, x);
3336
3337   for (desc = const_rtx_hash_table[hash]; desc; desc = desc->next)
3338     if (compare_constant_rtx (mode, x, desc))
3339       {
3340         found = desc->label;
3341         break;
3342       }
3343
3344   if (found == 0)
3345     {
3346       register struct pool_constant *pool;
3347       register struct pool_sym *sym;
3348       int align;
3349
3350       /* No constant equal to X is known to have been output.
3351          Make a constant descriptor to enter X in the hash table.
3352          Assign the label number and record it in the descriptor for
3353          future calls to this function to find.  */
3354
3355       desc = record_constant_rtx (mode, x);
3356       desc->next = const_rtx_hash_table[hash];
3357       const_rtx_hash_table[hash] = desc;
3358
3359       /* Align the location counter as required by EXP's data type.  */
3360       align = (mode == VOIDmode) ? UNITS_PER_WORD : GET_MODE_SIZE (mode);
3361       if (align > BIGGEST_ALIGNMENT / BITS_PER_UNIT)
3362         align = BIGGEST_ALIGNMENT / BITS_PER_UNIT;
3363
3364       pool_offset += align - 1;
3365       pool_offset &= ~ (align - 1);
3366
3367       /* If RTL is not being placed into the saveable obstack, make a
3368          copy of X that is in the saveable obstack in case we are being
3369          called from combine or some other phase that discards memory
3370          it allocates.  We need only do this if it is a CONST, since
3371          no other RTX should be allocated in this situation.  */
3372       if (rtl_obstack != saveable_obstack
3373           && GET_CODE (x) == CONST)
3374         {
3375           push_obstacks_nochange ();
3376           rtl_in_saveable_obstack ();
3377
3378           x = gen_rtx (CONST, GET_MODE (x),
3379                        gen_rtx (PLUS, GET_MODE (x),
3380                                 XEXP (XEXP (x, 0), 0), XEXP (XEXP (x, 0), 1)));
3381           pop_obstacks ();
3382         }
3383
3384       /* Allocate a pool constant descriptor, fill it in, and chain it in.  */
3385
3386       pool = (struct pool_constant *) savealloc (sizeof (struct pool_constant));
3387       pool->desc = desc;
3388       pool->constant = x;
3389       pool->mode = mode;
3390       pool->labelno = const_labelno;
3391       pool->align = align;
3392       pool->offset = pool_offset;
3393       pool->next = 0;
3394
3395       if (last_pool == 0)
3396         first_pool = pool;
3397       else
3398         last_pool->next = pool;
3399
3400       last_pool = pool;
3401       pool_offset += GET_MODE_SIZE (mode);
3402
3403       /* Create a string containing the label name, in LABEL.  */
3404       ASM_GENERATE_INTERNAL_LABEL (label, "LC", const_labelno);
3405
3406       ++const_labelno;
3407
3408       desc->label = found
3409         = (char *) obstack_copy0 (saveable_obstack, label, strlen (label));
3410
3411       /* Add label to symbol hash table.  */
3412       hash = SYMHASH (found);
3413       sym = (struct pool_sym *) savealloc (sizeof (struct pool_sym));
3414       sym->label = found;
3415       sym->pool = pool;
3416       sym->next = const_rtx_sym_hash_table[hash];
3417       const_rtx_sym_hash_table[hash] = sym;
3418     }
3419
3420   /* We have a symbol name; construct the SYMBOL_REF and the MEM.  */
3421
3422   def = gen_rtx (MEM, mode, gen_rtx (SYMBOL_REF, Pmode, found));
3423
3424   RTX_UNCHANGING_P (def) = 1;
3425   /* Mark the symbol_ref as belonging to this constants pool.  */
3426   CONSTANT_POOL_ADDRESS_P (XEXP (def, 0)) = 1;
3427   current_function_uses_const_pool = 1;
3428
3429   if (outer_function_chain == 0)
3430     if (GET_CODE (x) == CONST_DOUBLE)
3431       {
3432         if (CONST_DOUBLE_MEM (x) == cc0_rtx)
3433           {
3434             CONST_DOUBLE_CHAIN (x) = const_double_chain;
3435             const_double_chain = x;
3436           }
3437         CONST_DOUBLE_MEM (x) = def;
3438       }
3439
3440   return def;
3441 }
3442 \f
3443 /* Given a SYMBOL_REF with CONSTANT_POOL_ADDRESS_P true, return a pointer to
3444    the corresponding pool_constant structure.  */
3445
3446 static struct pool_constant *
3447 find_pool_constant (addr)
3448      rtx addr;
3449 {
3450   struct pool_sym *sym;
3451   char *label = XSTR (addr, 0);
3452
3453   for (sym = const_rtx_sym_hash_table[SYMHASH (label)]; sym; sym = sym->next)
3454     if (sym->label == label)
3455       return sym->pool;
3456
3457   abort ();
3458 }
3459
3460 /* Given a constant pool SYMBOL_REF, return the corresponding constant.  */
3461
3462 rtx
3463 get_pool_constant (addr)
3464      rtx addr;
3465 {
3466   return (find_pool_constant (addr))->constant;
3467 }
3468
3469 /* Similar, return the mode.  */
3470
3471 enum machine_mode
3472 get_pool_mode (addr)
3473      rtx addr;
3474 {
3475   return (find_pool_constant (addr))->mode;
3476 }
3477
3478 /* Similar, return the offset in the constant pool.  */
3479
3480 int
3481 get_pool_offset (addr)
3482      rtx addr;
3483 {
3484   return (find_pool_constant (addr))->offset;
3485 }
3486
3487 /* Return the size of the constant pool.  */
3488
3489 int
3490 get_pool_size ()
3491 {
3492   return pool_offset;
3493 }
3494 \f
3495 /* Write all the constants in the constant pool.  */
3496
3497 void
3498 output_constant_pool (fnname, fndecl)
3499      char *fnname;
3500      tree fndecl;
3501 {
3502   struct pool_constant *pool;
3503   rtx x;
3504   union real_extract u;
3505
3506 #ifdef ASM_OUTPUT_POOL_PROLOGUE
3507   ASM_OUTPUT_POOL_PROLOGUE (asm_out_file, fnname, fndecl, pool_offset);
3508 #endif
3509
3510   for (pool = first_pool; pool; pool = pool->next)
3511     {
3512       x = pool->constant;
3513
3514       /* See if X is a LABEL_REF (or a CONST referring to a LABEL_REF)
3515          whose CODE_LABEL has been deleted.  This can occur if a jump table
3516          is eliminated by optimization.  If so, write a constant of zero
3517          instead.  Note that this can also happen by turning the
3518          CODE_LABEL into a NOTE.  */
3519       if (((GET_CODE (x) == LABEL_REF
3520             && (INSN_DELETED_P (XEXP (x, 0))
3521                 || GET_CODE (XEXP (x, 0)) == NOTE)))
3522           || (GET_CODE (x) == CONST && GET_CODE (XEXP (x, 0)) == PLUS
3523               && GET_CODE (XEXP (XEXP (x, 0), 0)) == LABEL_REF
3524               && (INSN_DELETED_P (XEXP (XEXP (XEXP (x, 0), 0), 0))
3525                   || GET_CODE (XEXP (XEXP (XEXP (x, 0), 0), 0)) == NOTE)))
3526         x = const0_rtx;
3527
3528       /* First switch to correct section.  */
3529 #ifdef SELECT_RTX_SECTION
3530       SELECT_RTX_SECTION (pool->mode, x);
3531 #else
3532       readonly_data_section ();
3533 #endif
3534
3535 #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
3536       ASM_OUTPUT_SPECIAL_POOL_ENTRY (asm_out_file, x, pool->mode,
3537                                      pool->align, pool->labelno, done);
3538 #endif
3539
3540       if (pool->align > 1)
3541         ASM_OUTPUT_ALIGN (asm_out_file, exact_log2 (pool->align));
3542
3543       /* Output the label.  */
3544       ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LC", pool->labelno);
3545
3546       /* Output the value of the constant itself.  */
3547       switch (GET_MODE_CLASS (pool->mode))
3548         {
3549         case MODE_FLOAT:
3550           if (GET_CODE (x) != CONST_DOUBLE)
3551             abort ();
3552
3553           bcopy ((char *) &CONST_DOUBLE_LOW (x), (char *) &u, sizeof u);
3554           assemble_real (u.d, pool->mode);
3555           break;
3556
3557         case MODE_INT:
3558         case MODE_PARTIAL_INT:
3559           assemble_integer (x, GET_MODE_SIZE (pool->mode), 1);
3560           break;
3561
3562         default:
3563           abort ();
3564         }
3565
3566     done: ;
3567     }
3568
3569   /* Done with this pool.  */
3570   first_pool = last_pool = 0;
3571 }
3572 \f
3573 /* Find all the constants whose addresses are referenced inside of EXP,
3574    and make sure assembler code with a label has been output for each one.
3575    Indicate whether an ADDR_EXPR has been encountered.  */
3576
3577 static int
3578 output_addressed_constants (exp)
3579      tree exp;
3580 {
3581   int reloc = 0;
3582
3583   switch (TREE_CODE (exp))
3584     {
3585     case ADDR_EXPR:
3586       {
3587         register tree constant = TREE_OPERAND (exp, 0);
3588
3589         while (TREE_CODE (constant) == COMPONENT_REF)
3590           {
3591             constant = TREE_OPERAND (constant, 0);
3592           }
3593
3594         if (TREE_CODE_CLASS (TREE_CODE (constant)) == 'c'
3595             || TREE_CODE (constant) == CONSTRUCTOR)
3596           /* No need to do anything here
3597              for addresses of variables or functions.  */
3598           output_constant_def (constant);
3599       }
3600       reloc = 1;
3601       break;
3602
3603     case PLUS_EXPR:
3604     case MINUS_EXPR:
3605       reloc = output_addressed_constants (TREE_OPERAND (exp, 0));
3606       reloc |= output_addressed_constants (TREE_OPERAND (exp, 1));
3607       break;
3608
3609     case NOP_EXPR:
3610     case CONVERT_EXPR:
3611     case NON_LVALUE_EXPR:
3612       reloc = output_addressed_constants (TREE_OPERAND (exp, 0));
3613       break;
3614
3615     case CONSTRUCTOR:
3616       {
3617         register tree link;
3618         for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
3619           if (TREE_VALUE (link) != 0)
3620             reloc |= output_addressed_constants (TREE_VALUE (link));
3621       }
3622       break;
3623
3624     case ERROR_MARK:
3625       break;
3626     }
3627   return reloc;
3628 }
3629 \f
3630 /* Output assembler code for constant EXP to FILE, with no label.
3631    This includes the pseudo-op such as ".int" or ".byte", and a newline.
3632    Assumes output_addressed_constants has been done on EXP already.
3633
3634    Generate exactly SIZE bytes of assembler data, padding at the end
3635    with zeros if necessary.  SIZE must always be specified.
3636
3637    SIZE is important for structure constructors,
3638    since trailing members may have been omitted from the constructor.
3639    It is also important for initialization of arrays from string constants
3640    since the full length of the string constant might not be wanted.
3641    It is also needed for initialization of unions, where the initializer's
3642    type is just one member, and that may not be as long as the union.
3643
3644    There a case in which we would fail to output exactly SIZE bytes:
3645    for a structure constructor that wants to produce more than SIZE bytes.
3646    But such constructors will never be generated for any possible input.  */
3647
3648 void
3649 output_constant (exp, size)
3650      register tree exp;
3651      register int size;
3652 {
3653   register enum tree_code code = TREE_CODE (TREE_TYPE (exp));
3654   rtx x;
3655
3656   if (size == 0)
3657     return;
3658
3659   /* Eliminate the NON_LVALUE_EXPR_EXPR that makes a cast not be an lvalue.
3660      That way we get the constant (we hope) inside it.  Also, strip off any
3661      NOP_EXPR that converts between two record, union, array, or set types.  */
3662   while ((TREE_CODE (exp) == NOP_EXPR
3663           && (TREE_TYPE (exp) == TREE_TYPE (TREE_OPERAND (exp, 0))
3664               || AGGREGATE_TYPE_P (TREE_TYPE (exp))))
3665          || TREE_CODE (exp) == NON_LVALUE_EXPR)
3666     exp = TREE_OPERAND (exp, 0);
3667
3668   /* Allow a constructor with no elements for any data type.
3669      This means to fill the space with zeros.  */
3670   if (TREE_CODE (exp) == CONSTRUCTOR && CONSTRUCTOR_ELTS (exp) == 0)
3671     {
3672       if (output_bytecode)
3673         bc_emit_const_skip (size);
3674       else
3675         assemble_zeros (size);
3676       return;
3677     }
3678
3679   switch (code)
3680     {
3681     case CHAR_TYPE:
3682     case BOOLEAN_TYPE:
3683     case INTEGER_TYPE:
3684     case ENUMERAL_TYPE:
3685     case POINTER_TYPE:
3686     case REFERENCE_TYPE:
3687       /* ??? What about       (int)((float)(int)&foo + 4)    */
3688       while (TREE_CODE (exp) == NOP_EXPR || TREE_CODE (exp) == CONVERT_EXPR
3689              || TREE_CODE (exp) == NON_LVALUE_EXPR)
3690         exp = TREE_OPERAND (exp, 0);
3691
3692       if (! assemble_integer (expand_expr (exp, NULL_RTX, VOIDmode,
3693                                            EXPAND_INITIALIZER),
3694                               size, 0))
3695         error ("initializer for integer value is too complicated");
3696       size = 0;
3697       break;
3698
3699     case REAL_TYPE:
3700       if (TREE_CODE (exp) != REAL_CST)
3701         error ("initializer for floating value is not a floating constant");
3702
3703       assemble_real (TREE_REAL_CST (exp),
3704                      mode_for_size (size * BITS_PER_UNIT, MODE_FLOAT, 0));
3705       size = 0;
3706       break;
3707
3708     case COMPLEX_TYPE:
3709       output_constant (TREE_REALPART (exp), size / 2);
3710       output_constant (TREE_IMAGPART (exp), size / 2);
3711       size -= (size / 2) * 2;
3712       break;
3713
3714     case ARRAY_TYPE:
3715       if (TREE_CODE (exp) == CONSTRUCTOR)
3716         {
3717           output_constructor (exp, size);
3718           return;
3719         }
3720       else if (TREE_CODE (exp) == STRING_CST)
3721         {
3722           int excess = 0;
3723
3724           if (size > TREE_STRING_LENGTH (exp))
3725             {
3726               excess = size - TREE_STRING_LENGTH (exp);
3727               size = TREE_STRING_LENGTH (exp);
3728             }
3729
3730           assemble_string (TREE_STRING_POINTER (exp), size);
3731           size = excess;
3732         }
3733       else
3734         abort ();
3735       break;
3736
3737     case RECORD_TYPE:
3738     case UNION_TYPE:
3739       if (TREE_CODE (exp) == CONSTRUCTOR)
3740         output_constructor (exp, size);
3741       else
3742         abort ();
3743       return;
3744
3745     case SET_TYPE:
3746       if (TREE_CODE (exp) == INTEGER_CST)
3747         assemble_integer (expand_expr (exp, NULL_RTX,
3748                                        VOIDmode, EXPAND_INITIALIZER),
3749                           size, 1);
3750       else if (TREE_CODE (exp) == CONSTRUCTOR)
3751         {
3752           unsigned char *buffer = (unsigned char *) alloca (size);
3753           if (get_set_constructor_bytes (exp, buffer, size))
3754             abort ();
3755           assemble_string ((char *) buffer, size);
3756         }
3757       else
3758         error ("unknown set constructor type");
3759       return;
3760     }
3761
3762   if (size > 0)
3763     assemble_zeros (size);
3764 }
3765
3766 /* Bytecode specific code to output assembler for integer.  */
3767
3768 static void
3769 bc_assemble_integer (exp, size)
3770     tree exp;
3771     int size;
3772 {
3773   tree const_part;
3774   tree addr_part;
3775   tree tmp;
3776
3777   /* FIXME: is this fold() business going to be as good as the
3778      expand_expr() using EXPAND_SUM above in the RTL case?  I
3779      hate RMS.
3780      FIXME: Copied as is from BC-GCC1; may need work. Don't hate. -bson */
3781
3782   exp = fold (exp);
3783
3784   while (TREE_CODE (exp) == NOP_EXPR || TREE_CODE (exp) == CONVERT_EXPR)
3785     exp = TREE_OPERAND (exp, 0);
3786   if (TREE_CODE (exp) == INTEGER_CST)
3787     {
3788       const_part = exp;
3789       addr_part = 0;
3790     }
3791   else if (TREE_CODE (exp) == PLUS_EXPR)
3792     {
3793       const_part = TREE_OPERAND (exp, 0);
3794       while (TREE_CODE (const_part) == NOP_EXPR
3795              || TREE_CODE (const_part) == CONVERT_EXPR)
3796         const_part = TREE_OPERAND (const_part, 0);
3797       addr_part = TREE_OPERAND (exp, 1);
3798       while (TREE_CODE (addr_part) == NOP_EXPR
3799              || TREE_CODE (addr_part) == CONVERT_EXPR)
3800         addr_part = TREE_OPERAND (addr_part, 0);
3801       if (TREE_CODE (const_part) != INTEGER_CST)
3802         tmp = const_part, const_part = addr_part, addr_part = tmp;
3803       if (TREE_CODE (const_part) != INTEGER_CST
3804           || TREE_CODE (addr_part) != ADDR_EXPR)
3805         abort ();               /* FIXME: we really haven't considered
3806                                    all the possible cases here.  */
3807     }
3808   else if (TREE_CODE (exp) == ADDR_EXPR)
3809     {
3810       const_part = integer_zero_node;
3811       addr_part = exp;
3812     }
3813   else
3814     abort ();           /* FIXME: ditto previous.  */
3815
3816   if (addr_part == 0)
3817     {
3818       if (size == 1)
3819         {
3820           char c = TREE_INT_CST_LOW (const_part);
3821           bc_emit (&c, 1);
3822           size -= 1;
3823         }
3824       else if (size == 2)
3825         {
3826           short s = TREE_INT_CST_LOW (const_part);
3827           bc_emit ((char *) &s, 2);
3828           size -= 2;
3829         }
3830       else if (size == 4)
3831         {
3832           int i = TREE_INT_CST_LOW (const_part);
3833           bc_emit ((char *) &i, 4);
3834           size -= 4;
3835         }
3836       else if (size == 8)
3837         {
3838           if (WORDS_BIG_ENDIAN)
3839             {
3840               int i = TREE_INT_CST_HIGH (const_part);
3841               bc_emit ((char *) &i, 4);
3842               i = TREE_INT_CST_LOW (const_part);
3843               bc_emit ((char *) &i, 4);
3844             }
3845           else
3846             {
3847               int i = TREE_INT_CST_LOW (const_part);
3848               bc_emit ((char *) &i, 4);
3849               i = TREE_INT_CST_HIGH (const_part);
3850               bc_emit ((char *) &i, 4);
3851             }
3852           size -= 8;
3853         }
3854     }
3855   else
3856     if (size == 4
3857         && TREE_CODE (TREE_OPERAND (addr_part, 0)) == VAR_DECL)
3858       bc_emit_labelref (IDENTIFIER_POINTER
3859                         (DECL_ASSEMBLER_NAME (TREE_OPERAND (addr_part, 0))),
3860                         TREE_INT_CST_LOW (const_part));
3861     else
3862       abort ();         /* FIXME: there may be more cases.  */
3863 }
3864 \f
3865 /* Subroutine of output_constant, used for CONSTRUCTORs
3866    (aggregate constants).
3867    Generate at least SIZE bytes, padding if necessary.  */
3868
3869 static void
3870 output_constructor (exp, size)
3871      tree exp;
3872      int size;
3873 {
3874   register tree link, field = 0;
3875   HOST_WIDE_INT min_index = 0;
3876   /* Number of bytes output or skipped so far.
3877      In other words, current position within the constructor.  */
3878   int total_bytes = 0;
3879   /* Non-zero means BYTE contains part of a byte, to be output.  */
3880   int byte_buffer_in_use = 0;
3881   register int byte;
3882
3883   if (HOST_BITS_PER_WIDE_INT < BITS_PER_UNIT)
3884     abort ();
3885
3886   if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
3887     field = TYPE_FIELDS (TREE_TYPE (exp));
3888
3889   if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE
3890       && TYPE_DOMAIN (TREE_TYPE (exp)) != 0)
3891     min_index
3892       = TREE_INT_CST_LOW (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (exp))));
3893
3894   /* As LINK goes through the elements of the constant,
3895      FIELD goes through the structure fields, if the constant is a structure.
3896      if the constant is a union, then we override this,
3897      by getting the field from the TREE_LIST element.
3898      But the constant could also be an array.  Then FIELD is zero.  */
3899   for (link = CONSTRUCTOR_ELTS (exp);
3900        link;
3901        link = TREE_CHAIN (link),
3902        field = field ? TREE_CHAIN (field) : 0)
3903     {
3904       tree val = TREE_VALUE (link);
3905       tree index = 0;
3906
3907       /* the element in a union constructor specifies the proper field.  */
3908
3909       if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE
3910           || TREE_CODE (TREE_TYPE (exp)) == UNION_TYPE)
3911         {
3912           /* if available, use the type given by link */
3913           if (TREE_PURPOSE (link) != 0)
3914             field = TREE_PURPOSE (link);
3915         }
3916
3917       if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
3918         index = TREE_PURPOSE (link);
3919
3920       /* Eliminate the marker that makes a cast not be an lvalue.  */
3921       if (val != 0)
3922         STRIP_NOPS (val);
3923
3924       if (index && TREE_CODE (index) == RANGE_EXPR)
3925         {
3926           register int fieldsize
3927             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (exp)));
3928           HOST_WIDE_INT lo_index = TREE_INT_CST_LOW (TREE_OPERAND (index, 0));
3929           HOST_WIDE_INT hi_index = TREE_INT_CST_LOW (TREE_OPERAND (index, 1));
3930           HOST_WIDE_INT index;
3931           for (index = lo_index; index <= hi_index; index++)
3932             {
3933               /* Output the element's initial value.  */
3934               if (val == 0)
3935                 assemble_zeros (fieldsize);
3936               else
3937                 output_constant (val, fieldsize);
3938
3939               /* Count its size.  */
3940               total_bytes += fieldsize;
3941             }
3942         }
3943       else if (field == 0 || !DECL_BIT_FIELD (field))
3944         {
3945           /* An element that is not a bit-field.  */
3946
3947           register int fieldsize;
3948           /* Since this structure is static,
3949              we know the positions are constant.  */
3950           int bitpos = (field ? (TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field))
3951                                  / BITS_PER_UNIT)
3952                         : 0);
3953           if (index != 0)
3954             bitpos = (TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (val)))
3955                       / BITS_PER_UNIT
3956                       * (TREE_INT_CST_LOW (index) - min_index));
3957
3958           /* Output any buffered-up bit-fields preceding this element.  */
3959           if (byte_buffer_in_use)
3960             {
3961               ASM_OUTPUT_BYTE (asm_out_file, byte);
3962               total_bytes++;
3963               byte_buffer_in_use = 0;
3964             }
3965
3966           /* Advance to offset of this element.
3967              Note no alignment needed in an array, since that is guaranteed
3968              if each element has the proper size.  */
3969           if ((field != 0 || index != 0) && bitpos != total_bytes)
3970             {
3971               if (!output_bytecode)
3972                 assemble_zeros (bitpos - total_bytes);
3973               else
3974                 bc_emit_const_skip (bitpos - total_bytes);
3975               total_bytes = bitpos;
3976             }
3977
3978           /* Determine size this element should occupy.  */
3979           if (field)
3980             {
3981               if (TREE_CODE (DECL_SIZE (field)) != INTEGER_CST)
3982                 abort ();
3983               if (TREE_INT_CST_LOW (DECL_SIZE (field)) > 100000)
3984                 {
3985                   /* This avoids overflow trouble.  */
3986                   tree size_tree = size_binop (CEIL_DIV_EXPR,
3987                                                DECL_SIZE (field),
3988                                                size_int (BITS_PER_UNIT));
3989                   fieldsize = TREE_INT_CST_LOW (size_tree);
3990                 }
3991               else
3992                 {
3993                   fieldsize = TREE_INT_CST_LOW (DECL_SIZE (field));
3994                   fieldsize = (fieldsize + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
3995                 }
3996             }
3997           else
3998             fieldsize = int_size_in_bytes (TREE_TYPE (TREE_TYPE (exp)));
3999
4000           /* Output the element's initial value.  */
4001           if (val == 0)
4002             assemble_zeros (fieldsize);
4003           else
4004             output_constant (val, fieldsize);
4005
4006           /* Count its size.  */
4007           total_bytes += fieldsize;
4008         }
4009       else if (val != 0 && TREE_CODE (val) != INTEGER_CST)
4010         error ("invalid initial value for member `%s'",
4011                IDENTIFIER_POINTER (DECL_NAME (field)));
4012       else
4013         {
4014           /* Element that is a bit-field.  */
4015
4016           int next_offset = TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field));
4017           int end_offset
4018             = (next_offset + TREE_INT_CST_LOW (DECL_SIZE (field)));
4019
4020           if (val == 0)
4021             val = integer_zero_node;
4022
4023           /* If this field does not start in this (or, next) byte,
4024              skip some bytes.  */
4025           if (next_offset / BITS_PER_UNIT != total_bytes)
4026             {
4027               /* Output remnant of any bit field in previous bytes.  */
4028               if (byte_buffer_in_use)
4029                 {
4030                   ASM_OUTPUT_BYTE (asm_out_file, byte);
4031                   total_bytes++;
4032                   byte_buffer_in_use = 0;
4033                 }
4034
4035               /* If still not at proper byte, advance to there.  */
4036               if (next_offset / BITS_PER_UNIT != total_bytes)
4037                 {
4038                   assemble_zeros (next_offset / BITS_PER_UNIT - total_bytes);
4039                   total_bytes = next_offset / BITS_PER_UNIT;
4040                 }
4041             }
4042
4043           if (! byte_buffer_in_use)
4044             byte = 0;
4045
4046           /* We must split the element into pieces that fall within
4047              separate bytes, and combine each byte with previous or
4048              following bit-fields.  */
4049
4050           /* next_offset is the offset n fbits from the beginning of
4051              the structure to the next bit of this element to be processed.
4052              end_offset is the offset of the first bit past the end of
4053              this element.  */
4054           while (next_offset < end_offset)
4055             {
4056               int this_time;
4057               int shift;
4058               HOST_WIDE_INT value;
4059               int next_byte = next_offset / BITS_PER_UNIT;
4060               int next_bit = next_offset % BITS_PER_UNIT;
4061
4062               /* Advance from byte to byte
4063                  within this element when necessary.  */
4064               while (next_byte != total_bytes)
4065                 {
4066                   ASM_OUTPUT_BYTE (asm_out_file, byte);
4067                   total_bytes++;
4068                   byte = 0;
4069                 }
4070
4071               /* Number of bits we can process at once
4072                  (all part of the same byte).  */
4073               this_time = MIN (end_offset - next_offset,
4074                                BITS_PER_UNIT - next_bit);
4075               if (BYTES_BIG_ENDIAN)
4076                 {
4077                   /* On big-endian machine, take the most significant bits
4078                      first (of the bits that are significant)
4079                      and put them into bytes from the most significant end.  */
4080                   shift = end_offset - next_offset - this_time;
4081                   /* Don't try to take a bunch of bits that cross
4082                      the word boundary in the INTEGER_CST.  */
4083                   if (shift < HOST_BITS_PER_WIDE_INT
4084                       && shift + this_time > HOST_BITS_PER_WIDE_INT)
4085                     {
4086                       this_time -= (HOST_BITS_PER_WIDE_INT - shift);
4087                       shift = HOST_BITS_PER_WIDE_INT;
4088                     }
4089
4090                   /* Now get the bits from the appropriate constant word.  */
4091                   if (shift < HOST_BITS_PER_WIDE_INT)
4092                     {
4093                       value = TREE_INT_CST_LOW (val);
4094                     }
4095                   else if (shift < 2 * HOST_BITS_PER_WIDE_INT)
4096                     {
4097                       value = TREE_INT_CST_HIGH (val);
4098                       shift -= HOST_BITS_PER_WIDE_INT;
4099                     }
4100                   else
4101                     abort ();
4102                   byte |= (((value >> shift)
4103                             & (((HOST_WIDE_INT) 1 << this_time) - 1))
4104                            << (BITS_PER_UNIT - this_time - next_bit));
4105                 }
4106               else
4107                 {
4108                   /* On little-endian machines,
4109                      take first the least significant bits of the value
4110                      and pack them starting at the least significant
4111                      bits of the bytes.  */
4112                   shift = (next_offset
4113                            - TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field)));
4114                   /* Don't try to take a bunch of bits that cross
4115                      the word boundary in the INTEGER_CST.  */
4116                   if (shift < HOST_BITS_PER_WIDE_INT
4117                       && shift + this_time > HOST_BITS_PER_WIDE_INT)
4118                     {
4119                       this_time -= (HOST_BITS_PER_WIDE_INT - shift);
4120                       shift = HOST_BITS_PER_WIDE_INT;
4121                     }
4122
4123                   /* Now get the bits from the appropriate constant word.  */
4124                   if (shift < HOST_BITS_PER_INT)
4125                     value = TREE_INT_CST_LOW (val);
4126                   else if (shift < 2 * HOST_BITS_PER_WIDE_INT)
4127                     {
4128                       value = TREE_INT_CST_HIGH (val);
4129                       shift -= HOST_BITS_PER_WIDE_INT;
4130                     }
4131                   else
4132                     abort ();
4133                   byte |= (((value >> shift)
4134                             & (((HOST_WIDE_INT) 1 << this_time) - 1))
4135                            << next_bit);
4136                 }
4137               next_offset += this_time;
4138               byte_buffer_in_use = 1;
4139             }
4140         }
4141     }
4142   if (byte_buffer_in_use)
4143     {
4144       ASM_OUTPUT_BYTE (asm_out_file, byte);
4145       total_bytes++;
4146     }
4147   if (total_bytes < size)
4148     assemble_zeros (size - total_bytes);
4149 }
4150
4151 /* Output asm to handle ``#pragma weak'' */
4152
4153 void
4154 handle_pragma_weak (what, name, value)
4155      enum pragma_state what;
4156      char *name, *value;
4157 {
4158 #ifdef HANDLE_PRAGMA_WEAK
4159   if (what == ps_name || what == ps_value)
4160     {
4161       struct weak_syms *weak =
4162         (struct weak_syms *)permalloc (sizeof (struct weak_syms));
4163       weak->next = weak_decls;
4164       weak->name = permalloc (strlen (name) + 1);
4165       strcpy (weak->name, name);
4166
4167       if (what != ps_value)
4168         weak->value = NULL_PTR;
4169
4170       else
4171         {
4172           weak->value = permalloc (strlen (value) + 1);
4173           strcpy (weak->value, value);
4174         }
4175
4176       weak_decls = weak;
4177     }
4178   else if (! (what == ps_done || what == ps_start))
4179     warning ("malformed `#pragma weak'");
4180 #endif /* HANDLE_PRAGMA_WEAK */
4181 }
4182
4183 /* Declare DECL to be a weak symbol.  */
4184
4185 void
4186 declare_weak (decl)
4187      tree decl;
4188 {
4189   if (! TREE_PUBLIC (decl))
4190     error_with_decl (decl, "weak declaration of `%s' must be public");
4191   else if (TREE_ASM_WRITTEN (decl))
4192     error_with_decl (decl, "weak declaration of `%s' must precede definition");
4193   else if (SUPPORTS_WEAK)
4194     DECL_WEAK (decl) = 1;
4195 }
4196
4197 /* Emit any pending weak declarations.  */
4198
4199 void
4200 weak_finish ()
4201 {
4202 #ifdef HANDLE_PRAGMA_WEAK
4203   if (HANDLE_PRAGMA_WEAK)
4204     {
4205       struct weak_syms *t;
4206       for (t = weak_decls; t; t = t->next)
4207         {
4208           ASM_WEAKEN_LABEL (asm_out_file, t->name);
4209           if (t->value)
4210             ASM_OUTPUT_DEF (asm_out_file, t->name, t->value);
4211         }
4212     }
4213 #endif
4214 }
4215
4216 void
4217 assemble_alias (decl, target)
4218      tree decl, target;
4219 {
4220 #ifdef ASM_OUTPUT_DEF
4221   char *name;
4222
4223   make_decl_rtl (decl, (char *) 0, 1);
4224   name = XSTR (XEXP (DECL_RTL (decl), 0), 0);
4225
4226   /* Make name accessible from other files, if appropriate.  */
4227
4228   if (TREE_PUBLIC (decl))
4229     {
4230 #ifdef ASM_WEAKEN_LABEL
4231       if (DECL_WEAK (decl))
4232         ASM_WEAKEN_LABEL (asm_out_file, name);
4233       else
4234 #endif
4235       if (output_bytecode)
4236         BC_GLOBALIZE_LABEL (asm_out_file, name);
4237       else
4238         ASM_GLOBALIZE_LABEL (asm_out_file, name);
4239     }
4240
4241   ASM_OUTPUT_DEF (asm_out_file, name, IDENTIFIER_POINTER (target));
4242   TREE_ASM_WRITTEN (decl) = 1;
4243 #else
4244   warning ("alias definitions not supported in this configuration");
4245 #endif
4246 }
4247
4248 /* This determines whether or not we support link-once semantics.  */
4249 #ifndef SUPPORTS_ONE_ONLY
4250 #ifdef MAKE_DECL_ONE_ONLY
4251 #define SUPPORTS_ONE_ONLY 1
4252 #else
4253 #define SUPPORTS_ONE_ONLY 0
4254 #endif
4255 #endif
4256
4257 /* Returns 1 if the target configuration supports defining public symbols
4258    so that one of them will be chosen at link time instead of generating a
4259    multiply-defined symbol error, whether through the use of weak symbols or
4260    a target-specific mechanism for having duplicates discarded.  */
4261
4262 int
4263 supports_one_only ()
4264 {
4265   if (SUPPORTS_ONE_ONLY)
4266     return 1;
4267   return SUPPORTS_WEAK;
4268 }
4269
4270 /* Set up DECL as a public symbol that can be defined in multiple
4271    translation units without generating a linker error.  */
4272
4273 void
4274 make_decl_one_only (decl)
4275      tree decl;
4276 {
4277   if (TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != FUNCTION_DECL)
4278     abort ();
4279
4280   TREE_PUBLIC (decl) = 1;
4281
4282   if (TREE_CODE (decl) == VAR_DECL
4283       && (DECL_INITIAL (decl) == 0 || DECL_INITIAL (decl) == error_mark_node))
4284     DECL_COMMON (decl) = 1;
4285   else if (SUPPORTS_ONE_ONLY)
4286     {
4287 #ifdef MAKE_DECL_ONE_ONLY
4288       MAKE_DECL_ONE_ONLY (decl);
4289 #endif
4290       DECL_ONE_ONLY (decl) = 1;
4291     }
4292   else if (SUPPORTS_WEAK)
4293     DECL_WEAK (decl) = 1;
4294   else
4295     abort ();
4296 }