gcc/varasm.c

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