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