gcc/varasm.c

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