gcc/varasm.c

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