gcc/varasm.c

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