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