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