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