gcc/varasm.c

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