gcc/varasm.c

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