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