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