gcc/varasm.c

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