+/* Output variables, constants and external declarations, for GNU compiler.
+ Copyright (C) 1987, 1988, 1989 Free Software Foundation, Inc.
+
+This file is part of GNU CC.
+
+GNU CC is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 1, or (at your option)
+any later version.
+
+GNU CC is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU CC; see the file COPYING. If not, write to
+the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+
+/* This file handles generation of all the assembler code
+ *except* the instructions of a function.
+ This includes declarations of variables and their initial values.
+
+ We also output the assembler code for constants stored in memory
+ and are responsible for combining constants with the same value. */
+
+#include <stdio.h>
+#include <setjmp.h>
+/* #include <stab.h> */
+#include "config.h"
+#include "rtl.h"
+#include "tree.h"
+#include "flags.h"
+#include "expr.h"
+#include "hard-reg-set.h"
+
+#include "obstack.h"
+
+#define MIN(a, b) ((a) < (b) ? (a) : (b))
+
+/* File in which assembler code is being written. */
+
+extern FILE *asm_out_file;
+
+extern struct obstack *current_obstack;
+extern struct obstack *saveable_obstack;
+extern struct obstack permanent_obstack;
+#define obstack_chunk_alloc xmalloc
+extern int xmalloc ();
+
+/* Number for making the label on the next
+ constant that is stored in memory. */
+
+int const_labelno;
+
+/* Number for making the label on the next
+ static variable internal to a function. */
+
+int var_labelno;
+
+/* Nonzero if at least one function definition has been seen. */
+static int function_defined;
+
+extern FILE *asm_out_file;
+
+static char *compare_constant_1 ();
+static void record_constant_1 ();
+void assemble_name ();
+void output_addressed_constants ();
+void output_constant ();
+void output_constructor ();
+\f
+#ifdef EXTRA_SECTIONS
+static enum in_section {no_section, in_text, in_data, EXTRA_SECTIONS} in_section
+ = no_section;
+#else
+static enum in_section {no_section, in_text, in_data} in_section
+ = no_section;
+#endif
+
+/* Define functions like text_section for any extra sections. */
+#ifdef EXTRA_SECTION_FUNCTIONS
+EXTRA_SECTION_FUNCTIONS
+#endif
+
+/* Tell assembler to switch to text section. */
+
+void
+text_section ()
+{
+ if (in_section != in_text)
+ {
+ fprintf (asm_out_file, "%s\n", TEXT_SECTION_ASM_OP);
+ in_section = in_text;
+ }
+}
+
+/* Tell assembler to switch to data section. */
+
+void
+data_section ()
+{
+ if (in_section != in_data)
+ {
+ if (flag_shared_data)
+ {
+#ifdef SHARED_SECTION_ASM_OP
+ fprintf (asm_out_file, "%s\n", SHARED_SECTION_ASM_OP);
+#else
+ fprintf (asm_out_file, "%s\n", DATA_SECTION_ASM_OP);
+#endif
+ }
+ else
+ fprintf (asm_out_file, "%s\n", DATA_SECTION_ASM_OP);
+
+ in_section = in_data;
+ }
+}
+
+/* Determine if we're in the text section. */
+
+int
+in_text_section ()
+{
+ return in_section == in_text;
+}
+\f
+/* Create the rtl to represent a function, for a function definition.
+ DECL is a FUNCTION_DECL node which describes which function.
+ The rtl is stored into DECL. */
+
+void
+make_function_rtl (decl)
+ tree decl;
+{
+ if (DECL_RTL (decl) == 0)
+ DECL_RTL (decl)
+ = gen_rtx (MEM, DECL_MODE (decl),
+ gen_rtx (SYMBOL_REF, Pmode, DECL_ASSEMBLER_NAME (decl)));
+
+ /* Record at least one function has been defined. */
+ function_defined = 1;
+}
+
+/* Decode an `asm' spec for a declaration as a register name.
+ Return the register number, or -1 if nothing specified,
+ or -2 if the name is not a register. */
+
+int
+decode_reg_name (asmspec)
+ char *asmspec;
+{
+ if (asmspec != 0)
+ {
+ int i;
+ extern char *reg_names[];
+
+ for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
+ if (!strcmp (asmspec, reg_names[i]))
+ break;
+
+ if (i < FIRST_PSEUDO_REGISTER)
+ return i;
+ else
+ return -2;
+ }
+
+ return -1;
+}
+
+/* Create the DECL_RTL for a declaration for a static or external variable
+ or static or external function.
+ ASMSPEC, if not 0, is the string which the user specified
+ as the assembler symbol name.
+ TOP_LEVEL is nonzero if this is a file-scope variable.
+
+ This is never called for PARM_DECL nodes. */
+
+void
+make_decl_rtl (decl, asmspec, top_level)
+ tree decl;
+ char *asmspec;
+ int top_level;
+{
+ register char *name = DECL_ASSEMBLER_NAME (decl);
+ int reg_number = decode_reg_name (asmspec);
+
+ if (reg_number == -2)
+ {
+ name = (char *) obstack_alloc (saveable_obstack,
+ strlen (asmspec) + 2);
+ name[0] = '*';
+ strcpy (&name[1], asmspec);
+ }
+
+ /* For a duplicate declaration, we can be called twice on the
+ same DECL node. Don't alter the RTL already made
+ unless the old mode is wrong (which can happen when
+ the previous rtl was made when the type was incomplete). */
+ if (DECL_RTL (decl) == 0
+ || GET_MODE (DECL_RTL (decl)) != DECL_MODE (decl))
+ {
+ DECL_RTL (decl) = 0;
+
+ /* First detect errors in declaring global registers. */
+ if (TREE_REGDECL (decl) && reg_number == -1)
+ error_with_decl (decl,
+ "register name not specified for `%s'");
+ else if (TREE_REGDECL (decl) && reg_number == -2)
+ error_with_decl (decl,
+ "invalid register name for `%s'");
+ else if (reg_number >= 0 && ! TREE_REGDECL (decl))
+ error_with_decl (decl,
+ "register name given for non-register variable `%s'");
+ else if (TREE_REGDECL (decl) && TREE_CODE (decl) == FUNCTION_DECL)
+ error ("function declared `register'");
+ else if (TREE_REGDECL (decl) && TYPE_MODE (TREE_TYPE (decl)) == BLKmode)
+ error_with_decl (decl, "data type of `%s' isn't suitable for a register");
+ /* Now handle properly declared static register variables. */
+ else if (TREE_REGDECL (decl))
+ {
+ int nregs;
+ if (pedantic)
+ warning ("ANSI C forbids global register variables");
+ if (DECL_INITIAL (decl) != 0)
+ {
+ DECL_INITIAL (decl) = 0;
+ error ("global register variable has initial value");
+ }
+ if (fixed_regs[reg_number] == 0
+ && function_defined && top_level)
+ error ("global register variable follows a function definition");
+ DECL_RTL (decl) = gen_rtx (REG, DECL_MODE (decl), reg_number);
+ if (top_level)
+ {
+ /* Make this register fixed, so not usable for anything else. */
+ nregs = HARD_REGNO_NREGS (reg_number, DECL_MODE (decl));
+ while (nregs > 0)
+ global_regs[reg_number + --nregs] = 1;
+ init_reg_sets_1 ();
+ }
+ }
+
+ /* Now handle ordinary static variables and functions (in memory).
+ Also handle vars declared register invalidly. */
+ if (DECL_RTL (decl) == 0)
+ {
+ /* Can't use just the variable's own name for a variable
+ whose scope is less than the whole file.
+ Concatenate a distinguishing number. */
+ if (!top_level && !TREE_EXTERNAL (decl) && asmspec == 0)
+ {
+ char *label;
+
+ ASM_FORMAT_PRIVATE_NAME (label, name, var_labelno);
+ name = obstack_copy0 (saveable_obstack, label, strlen (label));
+ var_labelno++;
+ }
+
+ DECL_RTL (decl) = gen_rtx (MEM, DECL_MODE (decl),
+ gen_rtx (SYMBOL_REF, Pmode, name));
+ if (TREE_EXTERNAL (decl))
+ EXTERNAL_SYMBOL_P (XEXP (DECL_RTL (decl), 0)) = 1;
+ if (TREE_VOLATILE (decl))
+ MEM_VOLATILE_P (DECL_RTL (decl)) = 1;
+ if (TREE_READONLY (decl))
+ RTX_UNCHANGING_P (DECL_RTL (decl)) = 1;
+ MEM_IN_STRUCT_P (DECL_RTL (decl))
+ = (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
+ || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
+ || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE);
+ }
+ }
+}
+\f
+/* Output a string of literal assembler code
+ for an `asm' keyword used between functions. */
+
+void
+assemble_asm (string)
+ tree string;
+{
+ app_enable ();
+
+ fprintf (asm_out_file, "\t%s\n", TREE_STRING_POINTER (string));
+}
+
+/* Output assembler code associated with defining the name of a function
+ as described by DECL. */
+
+void
+assemble_function (decl)
+ tree decl;
+{
+ rtx x, n;
+ char *fnname;
+ int align;
+
+ /* Get the function's name, as described by its RTL.
+ This may be different from the DECL_NAME name used in the source file. */
+
+ x = DECL_RTL (decl);
+ if (GET_CODE (x) != MEM)
+ abort ();
+ n = XEXP (x, 0);
+ if (GET_CODE (n) != SYMBOL_REF)
+ abort ();
+ fnname = XSTR (n, 0);
+
+ /* The following code does not need preprocessing in the assembler. */
+
+ app_disable ();
+
+ text_section ();
+
+#ifdef SDB_DEBUGGING_INFO
+ /* Make sure types are defined for debugger before fcn name is defined. */
+ if (write_symbols == SDB_DEBUG)
+ sdbout_tags (gettags ());
+#endif
+
+ /* Tell assembler to move to target machine's alignment for functions. */
+
+ align = floor_log2 (FUNCTION_BOUNDARY / BITS_PER_UNIT);
+ if (align > 0)
+ ASM_OUTPUT_ALIGN (asm_out_file, align);
+
+#ifdef SDB_DEBUGGING_INFO
+ /* Output SDB definition of the function. */
+ if (write_symbols == SDB_DEBUG)
+ sdbout_mark_begin_function ();
+#endif
+
+ /* Make function name accessible from other files, if appropriate. */
+
+ if (TREE_PUBLIC (decl))
+ ASM_GLOBALIZE_LABEL (asm_out_file, fnname);
+
+ /* Do any machine/system dependent processing of the function name */
+#ifdef ASM_DECLARE_FUNCTION_NAME
+ ASM_DECLARE_FUNCTION_NAME (asm_out_file, fnname, current_function_decl);
+#else
+ /* Standard thing is just output label for the function. */
+ ASM_OUTPUT_LABEL (asm_out_file, fnname);
+#endif /* ASM_DECLARE_FUNCTION_NAME */
+}
+
+/* Assemble " .int 0\n" or whatever this assembler wants. */
+
+void
+assemble_integer_zero ()
+{
+ ASM_OUTPUT_INT (asm_out_file, const0_rtx);
+}
+
+/* Assemble a string constant with the specified C string as contents. */
+
+void
+assemble_string (p, size)
+ unsigned char *p;
+ int size;
+{
+ register int i;
+ int excess = 0;
+ int pos = 0;
+ int maximum = 2000;
+
+ /* If the string is very long, split it up. */
+
+ while (pos < size)
+ {
+ int thissize = size - pos;
+ if (thissize > maximum)
+ thissize = maximum;
+
+#ifdef ASM_OUTPUT_ASCII
+ ASM_OUTPUT_ASCII (asm_out_file, p, thissize);
+#else
+ fprintf (asm_out_file, "\t.ascii \"");
+
+ for (i = 0; i < thissize; i++)
+ {
+ register int c = p[i];
+ if (c == '\"' || c == '\\')
+ putc ('\\', asm_out_file);
+ if (c >= ' ' && c < 0177)
+ putc (c, asm_out_file);
+ else
+ {
+ fprintf (asm_out_file, "\\%o", c);
+ /* After an octal-escape, if a digit follows,
+ terminate one string constant and start another.
+ The Vax assembler fails to stop reading the escape
+ after three digits, so this is the only way we
+ can get it to parse the data properly. */
+ if (i < thissize - 1
+ && p[i + 1] >= '0' && p[i + 1] <= '9')
+ fprintf (asm_out_file, "\"\n\t.ascii \"");
+ }
+ }
+ fprintf (asm_out_file, "\"\n");
+#endif /* no ASM_OUTPUT_ASCII */
+
+ pos += thissize;
+ p += thissize;
+ }
+}
+\f
+/* Assemble everything that is needed for a variable or function declaration.
+ Not used for automatic variables, and not used for function definitions.
+ Should not be called for variables of incomplete structure type.
+
+ TOP_LEVEL is nonzero if this variable has file scope.
+ WRITE_SYMBOLS is DBX_DEBUG if writing dbx symbol output.
+ The dbx data for a file-scope variable is written here.
+ AT_END is nonzero if this is the special handling, at end of compilation,
+ to define things that have had only tentative definitions. */
+
+void
+assemble_variable (decl, top_level, write_symbols, at_end)
+ tree decl;
+ int top_level;
+ enum debugger write_symbols;
+ int at_end;
+{
+ register char *name;
+ register int i;
+
+ /* Do nothing for global register variables. */
+
+ if (GET_CODE (DECL_RTL (decl)) == REG)
+ return;
+
+ /* Normally no need to say anything for external references,
+ since assembler considers all undefined symbols external. */
+
+ if (TREE_EXTERNAL (decl))
+ return;
+
+ /* Output no assembler code for a function declaration.
+ Only definitions of functions output anything. */
+
+ if (TREE_CODE (decl) == FUNCTION_DECL)
+ return;
+
+ /* If type was incomplete when the variable was declared,
+ see if it is complete now. */
+
+ if (DECL_SIZE (decl) == 0)
+ layout_decl (decl, 0);
+
+ /* Still incomplete => don't allocate it; treat the tentative defn
+ (which is what it must have been) as an `extern' reference. */
+
+ if (DECL_SIZE (decl) == 0)
+ {
+ error_with_file_and_line (DECL_SOURCE_FILE (decl),
+ DECL_SOURCE_LINE (decl),
+ "storage size of static var `%s' isn't known",
+ IDENTIFIER_POINTER (DECL_NAME (decl)));
+ return;
+ }
+
+ /* The first declaration of a variable that comes through this function
+ decides whether it is global (in C, has external linkage)
+ or local (in C, has internal linkage). So do nothing more
+ if this function has already run. */
+
+ if (TREE_ASM_WRITTEN (decl))
+ return;
+
+ TREE_ASM_WRITTEN (decl) = 1;
+
+#ifdef DBX_DEBUGGING_INFO
+ /* File-scope global variables are output here. */
+ if (write_symbols == DBX_DEBUG && top_level)
+ dbxout_symbol (decl, 0);
+#endif
+#ifdef SDB_DEBUGGING_INFO
+ if (write_symbols == SDB_DEBUG && top_level)
+ sdbout_symbol (decl, 0);
+#endif
+ if (write_symbols == GDB_DEBUG)
+ /* Make sure the file is known to GDB even if it has no functions. */
+ set_current_gdbfile (DECL_SOURCE_FILE (decl));
+
+ /* If storage size is erroneously variable, just continue.
+ Error message was already made. */
+
+ if (! TREE_LITERAL (DECL_SIZE (decl)))
+ return;
+
+ app_disable ();
+
+ name = XSTR (XEXP (DECL_RTL (decl), 0), 0);
+
+ /* Handle uninitialized definitions. */
+
+ if (DECL_INITIAL (decl) == 0 || DECL_INITIAL (decl) == error_mark_node)
+ {
+ int size = (TREE_INT_CST_LOW (DECL_SIZE (decl))
+ * DECL_SIZE_UNIT (decl)
+ / BITS_PER_UNIT);
+ int rounded = size;
+ /* Don't allocate zero bytes of common,
+ since that means "undefined external" in the linker. */
+ if (size == 0) rounded = 1;
+ /* Round size up to multiple of BIGGEST_ALIGNMENT bits
+ so that each uninitialized object starts on such a boundary. */
+ rounded = ((rounded + (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1)
+ / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
+ * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
+ if (flag_shared_data)
+ data_section ();
+ if (TREE_PUBLIC (decl))
+ ASM_OUTPUT_COMMON (asm_out_file, name, size, rounded);
+ else
+ ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
+ return;
+ }
+
+ /* Handle initialized definitions. */
+
+ /* First make the assembler name(s) global if appropriate. */
+ if (TREE_PUBLIC (decl) && DECL_NAME (decl))
+ ASM_GLOBALIZE_LABEL (asm_out_file, name);
+#if 0
+ for (d = equivalents; d; d = TREE_CHAIN (d))
+ {
+ tree e = TREE_VALUE (d);
+ if (TREE_PUBLIC (e) && DECL_NAME (e))
+ ASM_GLOBALIZE_LABEL (asm_out_file,
+ XSTR (XEXP (DECL_RTL (e), 0), 0));
+ }
+#endif
+
+ /* Output any data that we will need to use the address of. */
+ if (DECL_INITIAL (decl))
+ output_addressed_constants (DECL_INITIAL (decl));
+
+ /* Switch to the proper section for this data. */
+#ifdef SELECT_SECTION
+ SELECT_SECTION (decl);
+#else
+ if (TREE_READONLY (decl) && ! TREE_VOLATILE (decl))
+ text_section ();
+ else
+ data_section ();
+#endif
+
+ /* Output the alignment of this data. */
+ for (i = 0; DECL_ALIGN (decl) >= BITS_PER_UNIT << (i + 1); i++);
+ if (i > 0)
+ ASM_OUTPUT_ALIGN (asm_out_file, i);
+
+ /* Output the name(s) of this data. */
+ ASM_OUTPUT_LABEL (asm_out_file, name);
+#if 0
+ for (d = equivalents; d; d = TREE_CHAIN (d))
+ {
+ tree e = TREE_VALUE (d);
+ ASM_OUTPUT_LABEL (asm_out_file, XSTR (XEXP (DECL_RTL (e), 0), 0));
+ }
+#endif
+
+ if (DECL_INITIAL (decl))
+ /* Output the actual data. */
+ output_constant (DECL_INITIAL (decl), int_size_in_bytes (TREE_TYPE (decl)));
+ else
+ /* Leave space for it. */
+ ASM_OUTPUT_SKIP (asm_out_file, int_size_in_bytes (TREE_TYPE (decl)));
+}
+
+/* Output something to declare an external symbol to the assembler.
+ (Most assemblers don't need this, so we normally output nothing.) */
+
+void
+assemble_external (decl)
+ tree decl;
+{
+ rtx rtl = DECL_RTL (decl);
+
+ if (GET_CODE (rtl) == MEM && GET_CODE (XEXP (rtl, 0)) == SYMBOL_REF)
+ {
+#ifdef ASM_OUTPUT_EXTERNAL
+ /* Some systems do require some output. */
+ ASM_OUTPUT_EXTERNAL (asm_out_file, decl, XSTR (XEXP (rtl, 0), 0));
+#endif
+ }
+}
+
+/* Output to FILE a reference to the assembler name of a C-level name NAME.
+ If NAME starts with a *, the rest of NAME is output verbatim.
+ Otherwise NAME is transformed in an implementation-defined way
+ (usually by the addition of an underscore).
+ Many macros in the tm file are defined to call this function. */
+
+void
+assemble_name (file, name)
+ FILE *file;
+ char *name;
+{
+ if (name[0] == '*')
+ fputs (&name[1], file);
+ else
+ ASM_OUTPUT_LABELREF (file, name);
+}
+
+/* Allocate SIZE bytes writable static space with a gensym name
+ and return an RTX to refer to its address. */
+
+rtx
+assemble_static_space (size)
+ int size;
+{
+ char name[12];
+ char *namestring;
+ rtx x;
+ /* Round size up to multiple of BIGGEST_ALIGNMENT bits
+ so that each uninitialized object starts on such a boundary. */
+ int rounded = ((size + (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1)
+ / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
+ * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
+
+ if (flag_shared_data)
+ data_section ();
+ ASM_GENERATE_INTERNAL_LABEL (name, "LF", const_labelno);
+ ++const_labelno;
+
+ namestring = (char *) obstack_alloc (saveable_obstack,
+ strlen (name) + 2);
+ strcpy (namestring, name);
+
+ x = gen_rtx (SYMBOL_REF, Pmode, namestring);
+ ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
+ return x;
+}
+\f
+/* Here we combine duplicate floating constants to make
+ CONST_DOUBLE rtx's, and force those out to memory when necessary. */
+
+/* Chain of all CONST_DOUBLE rtx's constructed for the current function.
+ They are chained through the CONST_DOUBLE_CHAIN.
+ A CONST_DOUBLE rtx has CONST_DOUBLE_MEM != cc0_rtx iff it is on this chain.
+ In that case, CONST_DOUBLE_MEM is either a MEM,
+ or const0_rtx if no MEM has been made for this CONST_DOUBLE yet. */
+
+static rtx real_constant_chain;
+
+/* Return a CONST_DOUBLE for a value specified as a pair of ints.
+ For an integer, I0 is the low-order word and I1 is the high-order word.
+ For a real number, I0 is the word with the low address
+ and I1 is the word with the high address. */
+
+rtx
+immed_double_const (i0, i1, mode)
+ int i0, i1;
+ enum machine_mode mode;
+{
+ register rtx r;
+
+ if (mode == DImode && i0 == 0 && i1 == 0)
+ return const0_rtx;
+
+ /* Search the chain for an existing CONST_DOUBLE with the right value.
+ If one is found, return it. */
+
+ for (r = real_constant_chain; r; r = CONST_DOUBLE_CHAIN (r))
+ if (CONST_DOUBLE_LOW (r) == i0 && CONST_DOUBLE_HIGH (r) == i1
+ && GET_MODE (r) == mode)
+ return r;
+
+ /* No; make a new one and add it to the chain. */
+
+ r = gen_rtx (CONST_DOUBLE, mode, 0, i0, i1);
+
+ CONST_DOUBLE_CHAIN (r) = real_constant_chain;
+ real_constant_chain = r;
+
+ /* Store const0_rtx in mem-slot since this CONST_DOUBLE is on the chain.
+ Actual use of mem-slot is only through force_const_double_mem. */
+
+ CONST_DOUBLE_MEM (r) = const0_rtx;
+
+ return r;
+}
+
+/* Return a CONST_DOUBLE for a specified `double' value
+ and machine mode. */
+
+rtx
+immed_real_const_1 (d, mode)
+ REAL_VALUE_TYPE d;
+ enum machine_mode mode;
+{
+ union real_extract u;
+ register rtx r;
+
+ /* Get the desired `double' value as a sequence of ints
+ since that is how they are stored in a CONST_DOUBLE. */
+
+ u.d = d;
+
+ /* Detect zero. */
+
+ if (! bcmp (&CONST_DOUBLE_LOW (dconst0_rtx), &u, sizeof u))
+ return (mode == DFmode ? dconst0_rtx : fconst0_rtx);
+
+ if (sizeof u == 2 * sizeof (int))
+ return immed_double_const (u.i[0], u.i[1], mode);
+
+ /* The rest of this function handles the case where
+ a float value requires more than 2 ints of space.
+ It will be deleted as dead code on machines that don't need it. */
+
+ /* Search the chain for an existing CONST_DOUBLE with the right value.
+ If one is found, return it. */
+
+ for (r = real_constant_chain; r; r = CONST_DOUBLE_CHAIN (r))
+ if (! bcmp (&CONST_DOUBLE_LOW (r), &u, sizeof u)
+ && GET_MODE (r) == mode)
+ return r;
+
+ /* No; make a new one and add it to the chain. */
+
+ r = rtx_alloc (CONST_DOUBLE);
+ PUT_MODE (r, mode);
+ bcopy (&u, &CONST_DOUBLE_LOW (r), sizeof u);
+
+ CONST_DOUBLE_CHAIN (r) = real_constant_chain;
+ real_constant_chain = r;
+
+ /* Store const0_rtx in slot 2 since this CONST_DOUBLE is on the chain.
+ Actual use of slot 2 is only through force_const_double_mem. */
+
+ CONST_DOUBLE_MEM (r) = const0_rtx;
+
+ return r;
+}
+
+/* Return a CONST_DOUBLE rtx for a value specified by EXP,
+ which must be a REAL_CST tree node. */
+
+rtx
+immed_real_const (exp)
+ tree exp;
+{
+ return immed_real_const_1 (TREE_REAL_CST (exp), TYPE_MODE (TREE_TYPE (exp)));
+}
+
+/* Given a CONST_DOUBLE, cause a constant in memory to be created
+ (unless we already have one for the same value)
+ and return a MEM rtx to refer to it.
+ Put the CONST_DOUBLE on real_constant_chain if it isn't already there. */
+
+rtx
+force_const_double_mem (r)
+ rtx r;
+{
+ if (CONST_DOUBLE_MEM (r) == cc0_rtx)
+ {
+ CONST_DOUBLE_CHAIN (r) = real_constant_chain;
+ real_constant_chain = r;
+ CONST_DOUBLE_MEM (r) = const0_rtx;
+ }
+
+ if (CONST_DOUBLE_MEM (r) == const0_rtx)
+ {
+ CONST_DOUBLE_MEM (r) = force_const_mem (GET_MODE (r), r);
+ }
+ /* CONST_DOUBLE_MEM (r) is now a MEM with a constant address.
+ If that is legitimate, return it.
+ Othewise it will need reloading, so return a copy of it. */
+ if (memory_address_p (GET_MODE (r), XEXP (CONST_DOUBLE_MEM (r), 0)))
+ return CONST_DOUBLE_MEM (r);
+ return gen_rtx (MEM, GET_MODE (r), XEXP (CONST_DOUBLE_MEM (r), 0));
+}
+
+/* At the end of a function, forget the memory-constants
+ previously made for CONST_DOUBLEs. Mark them as not on real_constant_chain.
+ Also clear out real_constant_chain and clear out all the chain-pointers. */
+
+void
+clear_const_double_mem ()
+{
+ register rtx r, next;
+
+ for (r = real_constant_chain; r; r = next)
+ {
+ next = CONST_DOUBLE_CHAIN (r);
+ CONST_DOUBLE_CHAIN (r) = 0;
+ CONST_DOUBLE_MEM (r) = cc0_rtx;
+ }
+ real_constant_chain = 0;
+}
+\f
+/* Given an expression EXP with a constant value,
+ reduce it to the sum of an assembler symbol and an integer.
+ Store them both in the structure *VALUE.
+ Abort if EXP does not reduce. */
+
+struct addr_const
+{
+ rtx base;
+ int offset;
+};
+
+static void
+decode_addr_const (exp, value)
+ tree exp;
+ struct addr_const *value;
+{
+ register tree target = TREE_OPERAND (exp, 0);
+ register int offset = 0;
+ register rtx x;
+
+ while (1)
+ {
+ if (TREE_CODE (target) == COMPONENT_REF)
+ {
+ offset += DECL_OFFSET (TREE_OPERAND (target, 1)) / BITS_PER_UNIT;
+ target = TREE_OPERAND (target, 0);
+ }
+ else if (TREE_CODE (target) == ARRAY_REF)
+ {
+ if (TREE_CODE (TREE_OPERAND (target, 1)) != INTEGER_CST
+ || TREE_CODE (TYPE_SIZE (TREE_TYPE (target))) != INTEGER_CST)
+ abort ();
+ offset += ((TYPE_SIZE_UNIT (TREE_TYPE (target))
+ * TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (target)))
+ * TREE_INT_CST_LOW (TREE_OPERAND (target, 1)))
+ / BITS_PER_UNIT);
+ target = TREE_OPERAND (target, 0);
+ }
+ else break;
+ }
+
+ if (TREE_CODE (target) == VAR_DECL
+ || TREE_CODE (target) == FUNCTION_DECL)
+ x = DECL_RTL (target);
+ else if (TREE_LITERAL (target))
+ x = TREE_CST_RTL (target);
+ else
+ abort ();
+
+ if (GET_CODE (x) != MEM)
+ abort ();
+ x = XEXP (x, 0);
+
+ value->base = x;
+ value->offset = offset;
+}
+\f
+/* Uniquize all constants that appear in memory.
+ Each constant in memory thus far output is recorded
+ in `const_hash_table' with a `struct constant_descriptor'
+ that contains a polish representation of the value of
+ the constant.
+
+ We cannot store the trees in the hash table
+ because the trees may be temporary. */
+
+struct constant_descriptor
+{
+ struct constant_descriptor *next;
+ char *label;
+ char contents[1];
+};
+
+#define HASHBITS 30
+#define MAX_HASH_TABLE 1007
+static struct constant_descriptor *const_hash_table[MAX_HASH_TABLE];
+
+/* Compute a hash code for a constant expression. */
+
+int
+const_hash (exp)
+ tree exp;
+{
+ register char *p;
+ register int len, hi, i;
+ register enum tree_code code = TREE_CODE (exp);
+
+ if (code == INTEGER_CST)
+ {
+ p = (char *) &TREE_INT_CST_LOW (exp);
+ len = 2 * sizeof TREE_INT_CST_LOW (exp);
+ }
+ else if (code == REAL_CST)
+ {
+ p = (char *) &TREE_REAL_CST (exp);
+ len = sizeof TREE_REAL_CST (exp);
+ }
+ else if (code == STRING_CST)
+ p = TREE_STRING_POINTER (exp), len = TREE_STRING_LENGTH (exp);
+ else if (code == COMPLEX_CST)
+ return const_hash (TREE_REALPART (exp)) * 5
+ + const_hash (TREE_IMAGPART (exp));
+ else if (code == CONSTRUCTOR)
+ {
+ register tree link;
+
+ /* For record type, include the type in the hashing.
+ We do not do so for array types
+ because (1) the sizes of the elements are sufficient
+ and (2) distinct array types can have the same constructor. */
+ if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
+ hi = ((int) TREE_TYPE (exp) & ((1 << HASHBITS) - 1)) % MAX_HASH_TABLE;
+ else
+ hi = 5;
+
+ for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
+ hi = (hi * 603 + const_hash (TREE_VALUE (link))) % MAX_HASH_TABLE;
+
+ return hi;
+ }
+ else if (code == ADDR_EXPR)
+ {
+ struct addr_const value;
+ decode_addr_const (exp, &value);
+ p = (char *) &value;
+ len = sizeof value;
+ }
+ else if (code == PLUS_EXPR || code == MINUS_EXPR)
+ return const_hash (TREE_OPERAND (exp, 0)) * 9
+ + const_hash (TREE_OPERAND (exp, 1));
+ else if (code == NOP_EXPR || code == CONVERT_EXPR)
+ return const_hash (TREE_OPERAND (exp, 0)) * 7 + 2;
+
+ /* Compute hashing function */
+ hi = len;
+ for (i = 0; i < len; i++)
+ hi = ((hi * 613) + (unsigned)(p[i]));
+
+ hi &= (1 << HASHBITS) - 1;
+ hi %= MAX_HASH_TABLE;
+ return hi;
+}
+\f
+/* Compare a constant expression EXP with a constant-descriptor DESC.
+ Return 1 if DESC describes a constant with the same value as EXP. */
+
+static int
+compare_constant (exp, desc)
+ tree exp;
+ struct constant_descriptor *desc;
+{
+ return 0 != compare_constant_1 (exp, desc->contents);
+}
+
+/* Compare constant expression EXP with a substring P of a constant descriptor.
+ If they match, return a pointer to the end of the substring matched.
+ If they do not match, return 0.
+
+ Since descriptors are written in polish prefix notation,
+ this function can be used recursively to test one operand of EXP
+ against a subdescriptor, and if it succeeds it returns the
+ address of the subdescriptor for the next operand. */
+
+static char *
+compare_constant_1 (exp, p)
+ tree exp;
+ char *p;
+{
+ register char *strp;
+ register int len;
+ register enum tree_code code = TREE_CODE (exp);
+
+ if (code != (enum tree_code) *p++)
+ return 0;
+
+ if (code == INTEGER_CST)
+ {
+ /* Integer constants are the same only if the same width of type. */
+ if (*p++ != TYPE_PRECISION (TREE_TYPE (exp)))
+ return 0;
+ strp = (char *) &TREE_INT_CST_LOW (exp);
+ len = 2 * sizeof TREE_INT_CST_LOW (exp);
+ }
+ else if (code == REAL_CST)
+ {
+ /* Real constants are the same only if the same width of type. */
+ if (*p++ != TYPE_PRECISION (TREE_TYPE (exp)))
+ return 0;
+ strp = (char *) &TREE_REAL_CST (exp);
+ len = sizeof TREE_REAL_CST (exp);
+ }
+ else if (code == STRING_CST)
+ {
+ if (flag_writable_strings)
+ return 0;
+ strp = TREE_STRING_POINTER (exp);
+ len = TREE_STRING_LENGTH (exp);
+ if (bcmp (&TREE_STRING_LENGTH (exp), p,
+ sizeof TREE_STRING_LENGTH (exp)))
+ return 0;
+ p += sizeof TREE_STRING_LENGTH (exp);
+ }
+ else if (code == COMPLEX_CST)
+ {
+ p = compare_constant_1 (TREE_REALPART (exp), p);
+ if (p == 0) return 0;
+ p = compare_constant_1 (TREE_IMAGPART (exp), p);
+ return p;
+ }
+ else if (code == CONSTRUCTOR)
+ {
+ register tree link;
+ int length = list_length (CONSTRUCTOR_ELTS (exp));
+ tree type;
+
+ if (bcmp (&length, p, sizeof length))
+ return 0;
+ p += sizeof length;
+
+ /* For record constructors, insist that the types match.
+ For arrays, just verify both constructors are for arrays. */
+ if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
+ type = TREE_TYPE (exp);
+ else
+ type = 0;
+ if (bcmp (&type, p, sizeof type))
+ return 0;
+ p += sizeof type;
+
+ for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
+ if ((p = compare_constant_1 (TREE_VALUE (link), p)) == 0)
+ return 0;
+ return p;
+ }
+ else if (code == ADDR_EXPR)
+ {
+ struct addr_const value;
+ decode_addr_const (exp, &value);
+ strp = (char *) &value;
+ len = sizeof value;
+ /* Compare SYMBOL_REF address and offset. */
+ while (--len >= 0)
+ if (*p++ != *strp++)
+ return 0;
+ /* Compare symbol name. */
+ strp = XSTR (value.base, 0);
+ len = strlen (strp) + 1;
+ }
+ else if (code == PLUS_EXPR || code == MINUS_EXPR)
+ {
+ if (*p++ != (char) code)
+ return 0;
+ p = compare_constant_1 (TREE_OPERAND (exp, 0), p);
+ if (p == 0) return 0;
+ p = compare_constant_1 (TREE_OPERAND (exp, 1), p);
+ return p;
+ }
+ else if (code == NOP_EXPR || code == CONVERT_EXPR)
+ {
+ if (*p++ != (char) code)
+ return 0;
+ p = compare_constant_1 (TREE_OPERAND (exp, 0), p);
+ return p;
+ }
+
+ /* Compare constant contents. */
+ while (--len >= 0)
+ if (*p++ != *strp++)
+ return 0;
+
+ return p;
+}
+\f
+/* Construct a constant descriptor for the expression EXP.
+ It is up to the caller to enter the descriptor in the hash table. */
+
+static struct constant_descriptor *
+record_constant (exp)
+ tree exp;
+{
+ struct constant_descriptor *ptr = 0;
+ int buf;
+
+ obstack_grow (&permanent_obstack, &ptr, sizeof ptr);
+ obstack_grow (&permanent_obstack, &buf, sizeof buf);
+ record_constant_1 (exp);
+ return (struct constant_descriptor *) obstack_finish (&permanent_obstack);
+}
+
+/* Add a description of constant expression EXP
+ to the object growing in `permanent_obstack'.
+ No need to return its address; the caller will get that
+ from the obstack when the object is complete. */
+
+static void
+record_constant_1 (exp)
+ tree exp;
+{
+ register char *strp;
+ register int len;
+ register enum tree_code code = TREE_CODE (exp);
+
+ obstack_1grow (&permanent_obstack, (unsigned int) code);
+
+ if (code == INTEGER_CST)
+ {
+ obstack_1grow (&permanent_obstack, TYPE_PRECISION (TREE_TYPE (exp)));
+ strp = (char *) &TREE_INT_CST_LOW (exp);
+ len = 2 * sizeof TREE_INT_CST_LOW (exp);
+ }
+ else if (code == REAL_CST)
+ {
+ obstack_1grow (&permanent_obstack, TYPE_PRECISION (TREE_TYPE (exp)));
+ strp = (char *) &TREE_REAL_CST (exp);
+ len = sizeof TREE_REAL_CST (exp);
+ }
+ else if (code == STRING_CST)
+ {
+ if (flag_writable_strings)
+ return;
+ strp = TREE_STRING_POINTER (exp);
+ len = TREE_STRING_LENGTH (exp);
+ obstack_grow (&permanent_obstack, (char *) &TREE_STRING_LENGTH (exp),
+ sizeof TREE_STRING_LENGTH (exp));
+ }
+ else if (code == COMPLEX_CST)
+ {
+ record_constant_1 (TREE_REALPART (exp));
+ record_constant_1 (TREE_IMAGPART (exp));
+ return;
+ }
+ else if (code == CONSTRUCTOR)
+ {
+ register tree link;
+ int length = list_length (CONSTRUCTOR_ELTS (exp));
+ tree type;
+
+ obstack_grow (&permanent_obstack, (char *) &length, sizeof length);
+
+ /* For record constructors, insist that the types match.
+ For arrays, just verify both constructors are for arrays. */
+ if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
+ type = TREE_TYPE (exp);
+ else
+ type = 0;
+ obstack_grow (&permanent_obstack, (char *) &type, sizeof type);
+
+ for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
+ record_constant_1 (TREE_VALUE (link));
+ return;
+ }
+ else if (code == ADDR_EXPR)
+ {
+ struct addr_const value;
+ decode_addr_const (exp, &value);
+ /* Record the SYMBOL_REF address and the offset. */
+ obstack_grow (&permanent_obstack, (char *) &value, sizeof value);
+ /* Record the symbol name. */
+ obstack_grow (&permanent_obstack, XSTR (value.base, 0),
+ strlen (XSTR (value.base, 0)) + 1);
+ return;
+ }
+ else if (code == PLUS_EXPR || code == MINUS_EXPR)
+ {
+ obstack_1grow (&permanent_obstack, (int) code);
+ record_constant_1 (TREE_OPERAND (exp, 0));
+ record_constant_1 (TREE_OPERAND (exp, 1));
+ return;
+ }
+ else if (code == NOP_EXPR || code == CONVERT_EXPR)
+ {
+ obstack_1grow (&permanent_obstack, (int) code);
+ record_constant_1 (TREE_OPERAND (exp, 0));
+ return;
+ }
+
+ /* Record constant contents. */
+ obstack_grow (&permanent_obstack, strp, len);
+}
+\f
+/* Return the constant-label-string for constant value EXP.
+ If no constant equal to EXP has yet been output,
+ define a new label and output assembler code for it.
+ The const_hash_table records which constants already have label strings. */
+
+static char *
+get_or_assign_label (exp)
+ tree exp;
+{
+ register int hash, i, align;
+ register struct constant_descriptor *desc;
+ char label[256];
+
+ /* Make sure any other constants whose addresses appear in EXP
+ are assigned label numbers. */
+
+ output_addressed_constants (exp);
+
+ /* Compute hash code of EXP. Search the descriptors for that hash code
+ to see if any of them describes EXP. If yes, the descriptor records
+ the label number already assigned. */
+
+ hash = const_hash (exp) % MAX_HASH_TABLE;
+
+ for (desc = const_hash_table[hash]; desc; desc = desc->next)
+ if (compare_constant (exp, desc))
+ return desc->label;
+
+ /* No constant equal to EXP is known to have been output.
+ Make a constant descriptor to enter EXP in the hash table.
+ Assign the label number and record it in the descriptor for
+ future calls to this function to find. */
+
+ desc = record_constant (exp);
+ desc->next = const_hash_table[hash];
+ const_hash_table[hash] = desc;
+
+ /* Now output assembler code to define that label
+ and follow it with the data of EXP. */
+
+ /* First switch to text section, except for writable strings. */
+#ifdef SELECT_SECTION
+ SELECT_SECTION (exp);
+#else
+ if ((TREE_CODE (exp) == STRING_CST) && flag_writable_strings)
+ data_section ();
+ else
+ text_section ();
+#endif
+
+ /* Align the location counter as required by EXP's data type. */
+#ifdef CONSTANT_ALIGNMENT
+ align = CONSTANT_ALIGNMENT (TREE_CODE (exp), TYPE_ALIGN (TREE_TYPE (exp)));
+#else
+ align = TYPE_ALIGN (TREE_TYPE (exp));
+#endif
+
+ for (i = 0; align >= BITS_PER_UNIT << (i + 1); i++);
+ if (i > 0)
+ ASM_OUTPUT_ALIGN (asm_out_file, i);
+
+ /* Output the label itself. */
+ ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LC", const_labelno);
+
+ /* Output the value of EXP. */
+ output_constant (exp,
+ (TREE_CODE (exp) == STRING_CST
+ ? TREE_STRING_LENGTH (exp)
+ : int_size_in_bytes (TREE_TYPE (exp))));
+
+ /* Create a string containing the label name, in LABEL. */
+ ASM_GENERATE_INTERNAL_LABEL (label, "LC", const_labelno);
+
+ ++const_labelno;
+
+ desc->label
+ = (char *) obstack_copy0 (&permanent_obstack, label, strlen (label));
+
+ return desc->label;
+}
+
+/* Return an rtx representing a reference to constant data in memory
+ for the constant expression EXP.
+ If assembler code for such a constant has already been output,
+ return an rtx to refer to it.
+ Otherwise, output such a constant in memory and generate
+ an rtx for it. The TREE_CST_RTL of EXP is set up to point to that rtx. */
+
+rtx
+output_constant_def (exp)
+ tree exp;
+{
+ register rtx def;
+ int temp_p = allocation_temporary_p ();
+
+ if (TREE_CODE (exp) == INTEGER_CST)
+ abort (); /* No TREE_CST_RTL slot in these. */
+
+ if (TREE_CST_RTL (exp))
+ return TREE_CST_RTL (exp);
+
+ if (TREE_PERMANENT (exp))
+ end_temporary_allocation ();
+
+ def = gen_rtx (SYMBOL_REF, Pmode, get_or_assign_label (exp));
+
+ TREE_CST_RTL (exp)
+ = gen_rtx (MEM, TYPE_MODE (TREE_TYPE (exp)), def);
+ RTX_UNCHANGING_P (TREE_CST_RTL (exp)) = 1;
+
+ if (temp_p && TREE_PERMANENT (exp))
+ resume_temporary_allocation ();
+
+ return TREE_CST_RTL (exp);
+}
+\f
+/* Similar hash facility for making memory-constants
+ from constant rtl-expressions. It is used on RISC machines
+ where immediate integer arguments and constant addresses are restricted
+ so that such constants must be stored in memory.
+
+ This pool of constants is reinitialized for each function
+ so each function gets its own constants-pool that comes right before it. */
+
+#define MAX_RTX_HASH_TABLE 61
+static struct constant_descriptor *const_rtx_hash_table[MAX_RTX_HASH_TABLE];
+
+void
+init_const_rtx_hash_table ()
+{
+ bzero (const_rtx_hash_table, sizeof const_rtx_hash_table);
+}
+
+struct rtx_const
+{
+ enum kind { RTX_DOUBLE, RTX_INT } kind : 16;
+ enum machine_mode mode : 16;
+ union {
+ union real_extract du;
+ struct addr_const addr;
+ } un;
+};
+
+/* Express an rtx for a constant integer (perhaps symbolic)
+ as the sum of a symbol or label plus an explicit integer.
+ They are stored into VALUE. */
+
+static void
+decode_rtx_const (mode, x, value)
+ enum machine_mode mode;
+ rtx x;
+ struct rtx_const *value;
+{
+ /* Clear the whole structure, including any gaps. */
+
+ {
+ int *p = (int *) value;
+ int *end = (int *) (value + 1);
+ while (p < end)
+ *p++ = 0;
+ }
+
+ value->kind = RTX_INT; /* Most usual kind. */
+ value->mode = mode;
+
+ switch (GET_CODE (x))
+ {
+ case CONST_DOUBLE:
+ value->kind = RTX_DOUBLE;
+ value->mode = GET_MODE (x);
+ bcopy (&CONST_DOUBLE_LOW (x), &value->un.du, sizeof value->un.du);
+ break;
+
+ case CONST_INT:
+ value->un.addr.offset = INTVAL (x);
+ break;
+
+ case SYMBOL_REF:
+ value->un.addr.base = x;
+ break;
+
+ case LABEL_REF:
+ value->un.addr.base = x;
+ break;
+
+ case CONST:
+ x = XEXP (x, 0);
+ if (GET_CODE (x) == PLUS)
+ {
+ value->un.addr.base = XEXP (XEXP (x, 0), 0);
+ if (GET_CODE (XEXP (x, 1)) != CONST_INT)
+ abort ();
+ value->un.addr.offset = INTVAL (XEXP (x, 1));
+ }
+ else if (GET_CODE (x) == MINUS)
+ {
+ value->un.addr.base = XEXP (x, 0);
+ if (GET_CODE (XEXP (x, 1)) != CONST_INT)
+ abort ();
+ value->un.addr.offset = - INTVAL (XEXP (x, 1));
+ }
+ else
+ abort ();
+ break;
+
+ default:
+ abort ();
+ }
+
+ if (value->kind == RTX_INT && value->un.addr.base != 0)
+ switch (GET_CODE (value->un.addr.base))
+ {
+ case SYMBOL_REF:
+ case LABEL_REF:
+ /* Use the string's address, not the SYMBOL_REF's address,
+ for the sake of addresses of library routines.
+ For a LABEL_REF, compare labels. */
+ value->un.addr.base = XEXP (value->un.addr.base, 0);
+ }
+}
+
+/* Compute a hash code for a constant RTL expression. */
+
+int
+const_hash_rtx (mode, x)
+ enum machine_mode mode;
+ rtx x;
+{
+ register int hi, i;
+
+ struct rtx_const value;
+ decode_rtx_const (mode, x, &value);
+
+ /* Compute hashing function */
+ hi = 0;
+ for (i = 0; i < sizeof value / sizeof (int); i++)
+ hi += ((int *) &value)[i];
+
+ hi &= (1 << HASHBITS) - 1;
+ hi %= MAX_RTX_HASH_TABLE;
+ return hi;
+}
+
+/* Compare a constant rtl object X with a constant-descriptor DESC.
+ Return 1 if DESC describes a constant with the same value as X. */
+
+static int
+compare_constant_rtx (mode, x, desc)
+ enum machine_mode mode;
+ rtx x;
+ struct constant_descriptor *desc;
+{
+ register int *p = (int *) desc->contents;
+ register int *strp;
+ register int len;
+ struct rtx_const value;
+
+ decode_rtx_const (mode, x, &value);
+ strp = (int *) &value;
+ len = sizeof value / sizeof (int);
+
+ /* Compare constant contents. */
+ while (--len >= 0)
+ if (*p++ != *strp++)
+ return 0;
+
+ return 1;
+}
+
+/* Construct a constant descriptor for the rtl-expression X.
+ It is up to the caller to enter the descriptor in the hash table. */
+
+static struct constant_descriptor *
+record_constant_rtx (mode, x)
+ enum machine_mode mode;
+ rtx x;
+{
+ struct constant_descriptor *ptr = 0;
+ int buf;
+ struct rtx_const value;
+
+ decode_rtx_const (mode, x, &value);
+
+ obstack_grow (saveable_obstack, &ptr, sizeof ptr);
+ obstack_grow (saveable_obstack, &buf, sizeof buf);
+
+ /* Record constant contents. */
+ obstack_grow (saveable_obstack, &value, sizeof value);
+
+ return (struct constant_descriptor *) obstack_finish (saveable_obstack);
+}
+\f
+/* Given a constant rtx X, make (or find) a memory constant for its value
+ and return a MEM rtx to refer to it in memory. */
+
+rtx
+force_const_mem (mode, x)
+ enum machine_mode mode;
+ rtx x;
+{
+ register int hash;
+ register struct constant_descriptor *desc;
+ char label[256];
+ char *found = 0;
+ rtx def;
+
+ if (GET_CODE (x) == CONST_DOUBLE
+ && GET_CODE (CONST_DOUBLE_MEM (x)) == MEM)
+ return CONST_DOUBLE_MEM (x);
+
+ /* Compute hash code of X. Search the descriptors for that hash code
+ to see if any of them describes X. If yes, the descriptor records
+ the label number already assigned. */
+
+ hash = const_hash_rtx (mode, x);
+
+ for (desc = const_rtx_hash_table[hash]; desc; desc = desc->next)
+ if (compare_constant_rtx (mode, x, desc))
+ {
+ found = desc->label;
+ break;
+ }
+
+ if (found == 0)
+ {
+ int align;
+
+ /* No constant equal to X is known to have been output.
+ Make a constant descriptor to enter X in the hash table.
+ Assign the label number and record it in the descriptor for
+ future calls to this function to find. */
+
+ desc = record_constant_rtx (mode, x);
+ desc->next = const_rtx_hash_table[hash];
+ const_rtx_hash_table[hash] = desc;
+
+ /* Now output assembler code to define that label
+ and follow it with the data of EXP. */
+
+ /* First switch to text section. */
+#ifdef SELECT_RTX_SECTION
+ SELECT_RTX_SECTION (mode, x);
+#else
+ text_section ();
+#endif
+
+ /* Align the location counter as required by EXP's data type. */
+ align = (mode == VOIDmode) ? UNITS_PER_WORD : GET_MODE_SIZE (mode);
+ if (align > BIGGEST_ALIGNMENT / BITS_PER_UNIT)
+ align = BIGGEST_ALIGNMENT / BITS_PER_UNIT;
+
+ if (align > 1)
+ ASM_OUTPUT_ALIGN (asm_out_file, exact_log2 (align));
+
+ /* Output the label itself. */
+ ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LC", const_labelno);
+
+ /* Output the value of EXP. */
+ if (GET_CODE (x) == CONST_DOUBLE)
+ {
+ union real_extract u;
+
+ bcopy (&CONST_DOUBLE_LOW (x), &u, sizeof u);
+ switch (mode)
+ {
+ /* Perhaps change the following to use
+ CONST_DOUBLE_LOW and CONST_DOUBLE_HIGH, rather than u.i. */
+ case DImode:
+#ifdef ASM_OUTPUT_DOUBLE_INT
+ ASM_OUTPUT_DOUBLE_INT (asm_out_file, x);
+#else /* no ASM_OUTPUT_DOUBLE_INT */
+#ifndef WORDS_BIG_ENDIAN
+ /* Output two ints. */
+ ASM_OUTPUT_INT (asm_out_file,
+ gen_rtx (CONST_INT, VOIDmode, u.i[0]));
+ ASM_OUTPUT_INT (asm_out_file,
+ gen_rtx (CONST_INT, VOIDmode, u.i[1]));
+#else
+ /* Output two ints. */
+ ASM_OUTPUT_INT (asm_out_file,
+ gen_rtx (CONST_INT, VOIDmode, u.i[1]));
+ ASM_OUTPUT_INT (asm_out_file,
+ gen_rtx (CONST_INT, VOIDmode, u.i[0]));
+#endif /* WORDS_BIG_ENDIAN */
+#endif /* no ASM_OUTPUT_DOUBLE_INT */
+ break;
+
+ case DFmode:
+ ASM_OUTPUT_DOUBLE (asm_out_file, u.d);
+ break;
+
+ case SFmode:
+ ASM_OUTPUT_FLOAT (asm_out_file, u.d);
+ }
+ }
+ else
+ switch (mode)
+ {
+ case SImode:
+ ASM_OUTPUT_INT (asm_out_file, x);
+ break;
+
+ case HImode:
+ ASM_OUTPUT_SHORT (asm_out_file, x);
+ break;
+
+ case QImode:
+ ASM_OUTPUT_CHAR (asm_out_file, x);
+ break;
+ }
+
+ /* Create a string containing the label name, in LABEL. */
+ ASM_GENERATE_INTERNAL_LABEL (label, "LC", const_labelno);
+
+ ++const_labelno;
+
+ desc->label = found
+ = (char *) obstack_copy0 (&permanent_obstack, label, strlen (label));
+ }
+
+ /* We have a symbol name; construct the SYMBOL_REF and the MEM. */
+
+ def = gen_rtx (MEM, mode, gen_rtx (SYMBOL_REF, Pmode, desc->label));
+
+ RTX_UNCHANGING_P (def) = 1;
+ /* Mark the symbol_ref as belonging to this constants pool. */
+ CONSTANT_POOL_ADDRESS_P (XEXP (def, 0)) = 1;
+
+ if (GET_CODE (x) == CONST_DOUBLE)
+ {
+ if (CONST_DOUBLE_MEM (x) == cc0_rtx)
+ {
+ CONST_DOUBLE_CHAIN (x) = real_constant_chain;
+ real_constant_chain = x;
+ }
+ CONST_DOUBLE_MEM (x) = def;
+ }
+
+ return def;
+}
+\f
+/* Find all the constants whose addresses are referenced inside of EXP,
+ and make sure assembler code with a label has been output for each one. */
+
+void
+output_addressed_constants (exp)
+ tree exp;
+{
+ switch (TREE_CODE (exp))
+ {
+ case ADDR_EXPR:
+ {
+ register tree constant = TREE_OPERAND (exp, 0);
+
+ while (TREE_CODE (constant) == COMPONENT_REF)
+ {
+ constant = TREE_OPERAND (constant, 0);
+ }
+
+ if (TREE_LITERAL (constant))
+ /* No need to do anything here
+ for addresses of variables or functions. */
+ output_constant_def (constant);
+ }
+ break;
+
+ case PLUS_EXPR:
+ case MINUS_EXPR:
+ output_addressed_constants (TREE_OPERAND (exp, 0));
+ output_addressed_constants (TREE_OPERAND (exp, 1));
+ break;
+
+ case NOP_EXPR:
+ case CONVERT_EXPR:
+ output_addressed_constants (TREE_OPERAND (exp, 0));
+ break;
+
+ case CONSTRUCTOR:
+ {
+ register tree link;
+ for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
+ output_addressed_constants (TREE_VALUE (link));
+ }
+ break;
+
+ case ERROR_MARK:
+ break;
+
+ default:
+ if (! TREE_LITERAL (exp))
+ abort ();
+ }
+}
+\f
+/* Output assembler code for constant EXP to FILE, with no label.
+ This includes the pseudo-op such as ".int" or ".byte", and a newline.
+ Assumes output_addressed_constants has been done on EXP already.
+
+ Generate exactly SIZE bytes of assembler data, padding at the end
+ with zeros if necessary. SIZE must always be specified.
+
+ SIZE is important for structure constructors,
+ since trailing members may have been omitted from the constructor.
+ It is also important for initialization of arrays from string constants
+ since the full length of the string constant might not be wanted.
+ It is also needed for initialization of unions, where the initializer's
+ type is just one member, and that may not be as long as the union.
+
+ There a case in which we would fail to output exactly SIZE bytes:
+ for a structure constructor that wants to produce more than SIZE bytes.
+ But such constructors will never be generated for any possible input. */
+
+void
+output_constant (exp, size)
+ register tree exp;
+ register int size;
+{
+ register enum tree_code code = TREE_CODE (TREE_TYPE (exp));
+ rtx x;
+
+ if (size == 0)
+ return;
+
+ /* Eliminate the NOP_EXPR that makes a cast not be an lvalue.
+ That way we get the constant (we hope) inside it. */
+ if (TREE_CODE (exp) == NOP_EXPR
+ && TREE_TYPE (exp) == TREE_TYPE (TREE_OPERAND (exp, 0)))
+ exp = TREE_OPERAND (exp, 0);
+
+ switch (code)
+ {
+ case INTEGER_TYPE:
+ case ENUMERAL_TYPE:
+ case POINTER_TYPE:
+ case REFERENCE_TYPE:
+ /* ??? What about (int)((float)(int)&foo + 4) */
+ while (TREE_CODE (exp) == NOP_EXPR || TREE_CODE (exp) == CONVERT_EXPR)
+ exp = TREE_OPERAND (exp, 0);
+
+#ifndef ASM_OUTPUT_DOUBLE_INT
+ if (TYPE_MODE (TREE_TYPE (exp)) == DImode)
+ {
+ if (TREE_CODE (exp) == INTEGER_CST)
+ {
+#ifndef WORDS_BIG_ENDIAN
+ ASM_OUTPUT_INT (asm_out_file,
+ gen_rtx (CONST_INT, VOIDmode,
+ TREE_INT_CST_LOW (exp)));
+ ASM_OUTPUT_INT (asm_out_file,
+ gen_rtx (CONST_INT, VOIDmode,
+ TREE_INT_CST_HIGH (exp)));
+#else
+ ASM_OUTPUT_INT (asm_out_file,
+ gen_rtx (CONST_INT, VOIDmode,
+ TREE_INT_CST_HIGH (exp)));
+ ASM_OUTPUT_INT (asm_out_file,
+ gen_rtx (CONST_INT, VOIDmode,
+ TREE_INT_CST_LOW (exp)));
+#endif
+ size -= 8;
+ break;
+ }
+ else
+ error ("8-byte integer constant expression too complicated");
+
+ break;
+ }
+#endif /* no ASM_OUTPUT_DOUBLE_INT */
+
+ x = expand_expr (exp, 0, VOIDmode, EXPAND_SUM);
+
+ if (size == 1)
+ {
+ ASM_OUTPUT_CHAR (asm_out_file, x);
+ size -= 1;
+ }
+ else if (size == 2)
+ {
+ ASM_OUTPUT_SHORT (asm_out_file, x);
+ size -= 2;
+ }
+ else if (size == 4)
+ {
+ ASM_OUTPUT_INT (asm_out_file, x);
+ size -= 4;
+ }
+#ifdef ASM_OUTPUT_DOUBLE_INT
+ else if (size == 8)
+ {
+ ASM_OUTPUT_DOUBLE_INT (asm_out_file, x);
+ size -= 8;
+ }
+#endif /* ASM_OUTPUT_DOUBLE_INT */
+ else
+ abort ();
+
+ break;
+
+ case REAL_TYPE:
+ if (TREE_CODE (exp) != REAL_CST)
+ error ("initializer for floating value is not a floating constant");
+ else
+ {
+ REAL_VALUE_TYPE d;
+ jmp_buf output_constant_handler;
+
+ d = TREE_REAL_CST (exp);
+ if (setjmp (output_constant_handler))
+ {
+ error ("floating point trap outputting a constant");
+#ifdef REAL_IS_NOT_DOUBLE
+ bzero (&d, sizeof d);
+ d = REAL_VALUE_ATOF ("0");
+#else
+ d = 0;
+#endif
+ }
+ set_float_handler (output_constant_handler);
+
+ if (size < 4)
+ break;
+ else if (size < 8)
+ {
+ ASM_OUTPUT_FLOAT (asm_out_file, d);
+ size -= 4;
+ }
+ else
+ {
+ ASM_OUTPUT_DOUBLE (asm_out_file, d);
+ size -= 8;
+ }
+ set_float_handler (0);
+ }
+ break;
+
+ case COMPLEX_TYPE:
+ output_constant (TREE_REALPART (exp), size / 2);
+ output_constant (TREE_IMAGPART (exp), size / 2);
+ size -= (size / 2) * 2;
+ break;
+
+ case ARRAY_TYPE:
+ if (TREE_CODE (exp) == CONSTRUCTOR)
+ {
+ output_constructor (exp, size);
+ return;
+ }
+ else if (TREE_CODE (exp) == STRING_CST)
+ {
+ int excess = 0;
+
+ if (size > TREE_STRING_LENGTH (exp))
+ {
+ excess = size - TREE_STRING_LENGTH (exp);
+ size = TREE_STRING_LENGTH (exp);
+ }
+
+ assemble_string (TREE_STRING_POINTER (exp), size);
+ size = excess;
+ }
+ else
+ abort ();
+ break;
+
+ case RECORD_TYPE:
+ case UNION_TYPE:
+ if (TREE_CODE (exp) == CONSTRUCTOR)
+ output_constructor (exp, size);
+ else
+ abort ();
+ return;
+ }
+
+ if (size > 0)
+ ASM_OUTPUT_SKIP (asm_out_file, size);
+}
+\f
+/* Subroutine of output_constant, used for CONSTRUCTORs
+ (aggregate constants).
+ Generate at least SIZE bytes, padding if necessary. */
+
+void
+output_constructor (exp, size)
+ tree exp;
+ int size;
+{
+ register tree link, field = 0;
+ /* Number of bytes output or skipped so far.
+ In other words, current position within the constructor. */
+ int total_bytes = 0;
+ /* Non-zero means BYTE contains part of a byte, to be output. */
+ int byte_buffer_in_use = 0;
+ register int byte;
+
+ if (HOST_BITS_PER_INT < BITS_PER_UNIT)
+ abort ();
+
+ if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE
+ || TREE_CODE (TREE_TYPE (exp)) == UNION_TYPE)
+ field = TYPE_FIELDS (TREE_TYPE (exp));
+
+ /* As LINK goes through the elements of the constant,
+ FIELD goes through the structure fields, if the constant is a structure.
+ But the constant could also be an array. Then FIELD is zero. */
+ for (link = CONSTRUCTOR_ELTS (exp);
+ link;
+ link = TREE_CHAIN (link),
+ field = field ? TREE_CHAIN (field) : 0)
+ {
+ tree val = TREE_VALUE (link);
+
+ /* Eliminate the NOP_EXPR that makes a cast not be an lvalue. */
+ if (TREE_CODE (val) == NOP_EXPR
+ && TREE_TYPE (val) == TREE_TYPE (TREE_OPERAND (val, 0)))
+ val = TREE_OPERAND (val, 0);
+
+ if (field == 0
+ || (DECL_MODE (field) != BImode))
+ {
+ register int fieldsize;
+
+ /* An element that is not a bit-field.
+ Output any buffered-up bit-fields preceding it. */
+ if (byte_buffer_in_use)
+ {
+ ASM_OUTPUT_BYTE (asm_out_file, byte);
+ total_bytes++;
+ byte_buffer_in_use = 0;
+ }
+
+ /* Advance to offset of this element.
+ Note no alignment needed in an array, since that is guaranteed
+ if each element has the proper size. */
+ if (field != 0 && DECL_OFFSET (field) / BITS_PER_UNIT != total_bytes)
+ {
+ ASM_OUTPUT_SKIP (asm_out_file,
+ (DECL_OFFSET (field) / BITS_PER_UNIT
+ - total_bytes));
+ total_bytes = DECL_OFFSET (field) / BITS_PER_UNIT;
+ }
+
+ /* Determine size this element should occupy. */
+ if (field)
+ {
+ if (! TREE_LITERAL (DECL_SIZE (field)))
+ abort ();
+ fieldsize = TREE_INT_CST_LOW (DECL_SIZE (field))
+ * DECL_SIZE_UNIT (field);
+ fieldsize = (fieldsize + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
+ }
+ else
+ fieldsize = int_size_in_bytes (TREE_TYPE (TREE_TYPE (exp)));
+
+ /* Output the element's initial value. */
+ output_constant (val, fieldsize);
+
+ /* Count its size. */
+ total_bytes += fieldsize;
+ }
+ else if (TREE_CODE (val) != INTEGER_CST)
+ error ("invalid initial value for member `%s'",
+ IDENTIFIER_POINTER (DECL_NAME (field)));
+ else
+ {
+ /* Element that is a bit-field. */
+
+ int next_offset = DECL_OFFSET (field);
+ int end_offset
+ = (next_offset
+ + (TREE_INT_CST_LOW (DECL_SIZE (field))
+ * DECL_SIZE_UNIT (field)));
+
+ /* If this field does not start in this (or, next) byte,
+ skip some bytes. */
+ if (next_offset / BITS_PER_UNIT != total_bytes)
+ {
+ /* Output remnant of any bit field in previous bytes. */
+ if (byte_buffer_in_use)
+ {
+ ASM_OUTPUT_BYTE (asm_out_file, byte);
+ total_bytes++;
+ byte_buffer_in_use = 0;
+ }
+
+ /* If still not at proper byte, advance to there. */
+ if (next_offset / BITS_PER_UNIT != total_bytes)
+ {
+ ASM_OUTPUT_SKIP (asm_out_file,
+ next_offset / BITS_PER_UNIT - total_bytes);
+ total_bytes = next_offset / BITS_PER_UNIT;
+ }
+ }
+
+ if (! byte_buffer_in_use)
+ byte = 0;
+
+ /* We must split the element into pieces that fall within
+ separate bytes, and combine each byte with previous or
+ following bit-fields. */
+
+ /* next_offset is the offset n fbits from the begining of
+ the structure to the next bit of this element to be processed.
+ end_offset is the offset of the first bit past the end of
+ this element. */
+ while (next_offset < end_offset)
+ {
+ int this_time;
+ int next_byte = next_offset / BITS_PER_UNIT;
+ int next_bit = next_offset % BITS_PER_UNIT;
+
+ /* Advance from byte to byte
+ within this element when necessary. */
+ while (next_byte != total_bytes)
+ {
+ ASM_OUTPUT_BYTE (asm_out_file, byte);
+ total_bytes++;
+ byte = 0;
+ }
+
+ /* Number of bits we can process at once
+ (all part of the same byte). */
+ this_time = MIN (end_offset - next_offset,
+ BITS_PER_UNIT - next_bit);
+#ifdef BYTES_BIG_ENDIAN
+ /* On big-endian machine, take the most significant bits
+ first (of the bits that are significant)
+ and put them into bytes from the most significant end. */
+ byte |= (((TREE_INT_CST_LOW (val)
+ >> (end_offset - next_offset - this_time))
+ & ((1 << this_time) - 1))
+ << (BITS_PER_UNIT - this_time - next_bit));
+#else
+ /* On little-endian machines,
+ take first the least significant bits of the value
+ and pack them starting at the least significant
+ bits of the bytes. */
+ byte |= ((TREE_INT_CST_LOW (val)
+ >> (next_offset - DECL_OFFSET (field)))
+ & ((1 << this_time) - 1)) << next_bit;
+#endif
+ next_offset += this_time;
+ byte_buffer_in_use = 1;
+ }
+ }
+ }
+ if (byte_buffer_in_use)
+ {
+ ASM_OUTPUT_BYTE (asm_out_file, byte);
+ total_bytes++;
+ }
+ if (total_bytes < size)
+ ASM_OUTPUT_SKIP (asm_out_file, size - total_bytes);
+}
projects / unix-history / commitdiff