gcc/varasm.c

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