gcc/varasm.c

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