/* Output variables, constants and external declarations, for GNU compiler.
- Copyright (C) 1987, 1988, 1989, 1992 Free Software Foundation, Inc.
+ Copyright (C) 1987, 88, 89, 92, 93, 94, 1995 Free Software Foundation, Inc.
This file is part of GNU CC.
#include "flags.h"
#include "function.h"
#include "expr.h"
+#include "output.h"
#include "hard-reg-set.h"
#include "regs.h"
#include "defaults.h"
#include "real.h"
+#include "bytecode.h"
#include "obstack.h"
#include "xcoffout.h"
#endif
+#include <ctype.h>
+
#ifndef ASM_STABS_OP
#define ASM_STABS_OP ".stabs"
#endif
extern struct obstack *current_obstack;
extern struct obstack *saveable_obstack;
+extern struct obstack *rtl_obstack;
extern struct obstack permanent_obstack;
#define obstack_chunk_alloc xmalloc
int var_labelno;
+/* Carry information from ASM_DECLARE_OBJECT_NAME
+ to ASM_FINISH_DECLARE_OBJECT. */
+
+int size_directive_output;
+
+/* The last decl for which assemble_variable was called,
+ if it did ASM_DECLARE_OBJECT_NAME.
+ If the last call to assemble_variable didn't do that,
+ this holds 0. */
+
+tree last_assemble_variable_decl;
+
/* 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 output_constant_pool ();
-void assemble_name ();
-int output_addressed_constants ();
-void output_constant ();
-void output_constructor ();
-void text_section ();
-void readonly_data_section ();
-void data_section ();
+struct addr_const;
+struct constant_descriptor;
+struct rtx_const;
+struct pool_constant;
+
+static void bc_make_decl_rtl PROTO((tree, char *, int));
+static char *strip_reg_name PROTO((char *));
+static void bc_output_ascii PROTO((FILE *, char *, int));
+static int contains_pointers_p PROTO((tree));
+static void decode_addr_const PROTO((tree, struct addr_const *));
+static int const_hash PROTO((tree));
+static int compare_constant PROTO((tree,
+ struct constant_descriptor *));
+static char *compare_constant_1 PROTO((tree, char *));
+static struct constant_descriptor *record_constant PROTO((tree));
+static void record_constant_1 PROTO((tree));
+static tree copy_constant PROTO((tree));
+static void output_constant_def_contents PROTO((tree, int, int));
+static void decode_rtx_const PROTO((enum machine_mode, rtx,
+ struct rtx_const *));
+static int const_hash_rtx PROTO((enum machine_mode, rtx));
+static int compare_constant_rtx PROTO((enum machine_mode, rtx,
+ struct constant_descriptor *));
+static struct constant_descriptor *record_constant_rtx PROTO((enum machine_mode,
+ rtx));
+static struct pool_constant *find_pool_constant PROTO((rtx));
+static int output_addressed_constants PROTO((tree));
+static void bc_assemble_integer PROTO((tree, int));
+static void output_constructor PROTO((tree, int));
\f
#ifdef EXTRA_SECTIONS
-static enum in_section {no_section, in_text, in_data, EXTRA_SECTIONS} in_section
+static enum in_section {no_section, in_text, in_data, in_named, EXTRA_SECTIONS} in_section
= no_section;
#else
-static enum in_section {no_section, in_text, in_data} in_section
+static enum in_section {no_section, in_text, in_data, in_named} in_section
= no_section;
#endif
+/* Return a non-zero value if DECL has a section attribute. */
+#define IN_NAMED_SECTION(DECL) \
+ ((TREE_CODE (DECL) == FUNCTION_DECL || TREE_CODE (DECL) == VAR_DECL) \
+ && DECL_SECTION_NAME (DECL) != NULL_TREE)
+
+/* Text of section name when in_section == in_named. */
+static char *in_named_name;
+
/* Define functions like text_section for any extra sections. */
#ifdef EXTRA_SECTION_FUNCTIONS
EXTRA_SECTION_FUNCTIONS
{
if (in_section != in_text)
{
- fprintf (asm_out_file, "%s\n", TEXT_SECTION_ASM_OP);
+ if (output_bytecode)
+ bc_text ();
+ else
+ fprintf (asm_out_file, "%s\n", TEXT_SECTION_ASM_OP);
+
in_section = in_text;
}
}
{
if (in_section != in_data)
{
- if (flag_shared_data)
+ if (output_bytecode)
+ bc_data ();
+ else
{
+ if (flag_shared_data)
+ {
#ifdef SHARED_SECTION_ASM_OP
- fprintf (asm_out_file, "%s\n", 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);
+ fprintf (asm_out_file, "%s\n", DATA_SECTION_ASM_OP);
#endif
+ }
+ else
+ fprintf (asm_out_file, "%s\n", DATA_SECTION_ASM_OP);
}
- else
- fprintf (asm_out_file, "%s\n", DATA_SECTION_ASM_OP);
in_section = in_data;
}
{
return in_section == in_text;
}
+
+/* Tell assembler to change to section NAME for DECL.
+ If DECL is NULL, just switch to section NAME.
+ If NAME is NULL, get the name from DECL. */
+
+void
+named_section (decl, name)
+ tree decl;
+ char *name;
+{
+ if (decl != NULL_TREE
+ && (TREE_CODE (decl) != FUNCTION_DECL && TREE_CODE (decl) != VAR_DECL))
+ abort ();
+ if (name == NULL)
+ name = TREE_STRING_POINTER (DECL_SECTION_NAME (decl));
+
+ if (in_section != in_named || strcmp (name, in_named_name))
+ {
+ in_named_name = name;
+ in_section = in_named;
+
+#ifdef ASM_OUTPUT_SECTION_NAME
+ ASM_OUTPUT_SECTION_NAME (asm_out_file, decl, name);
+#else
+ /* Section attributes are not supported if this macro isn't provided -
+ some host formats don't support them at all. The front-end should
+ already have flagged this as an error. */
+ abort ();
+#endif
+ }
+}
+
+/* Switch to the section for function DECL.
+
+ If DECL is NULL_TREE, switch to the text section.
+ ??? It's not clear that we will ever be passed NULL_TREE, but it's
+ safer to handle it. */
+
+void
+function_section (decl)
+ tree decl;
+{
+ if (decl != NULL_TREE
+ && DECL_SECTION_NAME (decl) != NULL_TREE)
+ named_section (decl, (char *) 0);
+ else
+ text_section ();
+}
\f
/* Create the rtl to represent a function, for a function definition.
DECL is a FUNCTION_DECL node which describes which function.
{
char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
+ if (output_bytecode)
+ {
+ if (DECL_RTL (decl) == 0)
+ DECL_RTL (decl) = bc_gen_rtx (name, 0, (struct bc_label *) 0);
+
+ /* Record that at least one function has been defined. */
+ function_defined = 1;
+ return;
+ }
+
/* Rename a nested function to avoid conflicts. */
if (decl_function_context (decl) != 0
&& DECL_INITIAL (decl) != 0
/* Optionally set flags or add text to the name to record information
such as that it is a function name. If the name is changed, the macro
- ASM_OUTPUT_LABELREF will have to know how to strip this information.
- And if it finds a * at the beginning after doing so, it must handle
- that too. */
+ ASM_OUTPUT_LABELREF will have to know how to strip this information. */
#ifdef ENCODE_SECTION_INFO
ENCODE_SECTION_INFO (decl);
#endif
function_defined = 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_DECLs. */
+
+static void
+bc_make_decl_rtl (decl, asmspec, top_level)
+ tree decl;
+ char *asmspec;
+ int top_level;
+{
+ register char *name = TREE_STRING_POINTER (DECL_ASSEMBLER_NAME (decl));
+
+ if (DECL_RTL (decl) == 0)
+ {
+ /* Print an error message for register variables. */
+ if (DECL_REGISTER (decl) && TREE_CODE (decl) == FUNCTION_DECL)
+ error ("function declared `register'");
+ else if (DECL_REGISTER (decl))
+ error ("global register variables not supported in the interpreter");
+
+ /* Handle ordinary static variables and functions. */
+ 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 && !DECL_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) = bc_gen_rtx (name, 0, (struct bc_label *) 0);
+ }
+ }
+}
+
/* Given NAME, a putative register name, discard any customary prefixes. */
static char *
char *asmspec;
int top_level;
{
- register char *name;
- int reg_number = decode_reg_name (asmspec);
+ register char *name = 0;
+ int reg_number;
+
+ if (output_bytecode)
+ {
+ bc_make_decl_rtl (decl, asmspec, top_level);
+ return;
+ }
+
+ reg_number = decode_reg_name (asmspec);
if (DECL_ASSEMBLER_NAME (decl) != NULL_TREE)
name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
}
/* 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))
+ same DECL node. Don't discard the RTL already made. */
+ if (DECL_RTL (decl) == 0)
{
DECL_RTL (decl) = 0;
error ("global register variable follows a function definition");
if (TREE_THIS_VOLATILE (decl))
warning ("volatile register variables don't work as you might wish");
- DECL_RTL (decl) = gen_rtx (REG, DECL_MODE (decl), reg_number);
+
+ /* If the user specified one of the eliminables registers here,
+ e.g., FRAME_POINTER_REGNUM, we don't want to get this variable
+ confused with that register and be eliminated. Although this
+ usage is somewhat suspect, we nevertheless use the following
+ kludge to avoid setting DECL_RTL to frame_pointer_rtx. */
+
+ DECL_RTL (decl)
+ = gen_rtx (REG, DECL_MODE (decl), FIRST_PSEUDO_REGISTER);
+ REGNO (DECL_RTL (decl)) = reg_number;
REG_USERVAR_P (DECL_RTL (decl)) = 1;
if (top_level)
{
- /* Make this register fixed, so not usable for anything else. */
+ /* Make this register global, 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 ();
+ globalize_reg (reg_number + --nregs);
}
}
+ /* Specifying a section attribute on an uninitialized variable does not
+ (and cannot) cause it to be put in the given section. The linker
+ can only put initialized objects in specific sections, everything
+ else goes in bss for the linker to sort out later (otherwise the
+ linker would give a duplicate definition error for each compilation
+ unit that behaved thusly). So warn the user. */
+ else if (TREE_CODE (decl) == VAR_DECL
+ && DECL_SECTION_NAME (decl) != NULL_TREE
+ && DECL_INITIAL (decl) == NULL_TREE
+ && DECL_COMMON (decl)
+ && ! flag_no_common)
+ {
+ warning_with_decl (decl,
+ "section attribute ignored for uninitialized variable `%s'");
+ /* Remove the section name so subsequent declarations won't see it.
+ We are ignoring it, remember. */
+ DECL_SECTION_NAME (decl) = NULL_TREE;
+ }
/* Now handle ordinary static variables and functions (in memory).
Also handle vars declared register invalidly. */
var_labelno++;
}
+ if (name == 0)
+ abort ();
+
DECL_RTL (decl) = gen_rtx (MEM, DECL_MODE (decl),
gen_rtx (SYMBOL_REF, Pmode, name));
- if (TREE_THIS_VOLATILE (decl))
+
+ /* If this variable is to be treated as volatile, show its
+ tree node has side effects. If it has side effects, either
+ because of this test or from TREE_THIS_VOLATILE also
+ being set, show the MEM is volatile. */
+ if (flag_volatile_global && TREE_CODE (decl) == VAR_DECL
+ && TREE_PUBLIC (decl))
+ TREE_SIDE_EFFECTS (decl) = 1;
+ if (TREE_SIDE_EFFECTS (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);
+ = AGGREGATE_TYPE_P (TREE_TYPE (decl));
/* Optionally set flags or add text to the name to record information
such as that it is a function name.
If the name is changed, the macro ASM_OUTPUT_LABELREF
- will have to know how to strip this information.
- And if it finds a * at the beginning after doing so,
- it must handle that too. */
+ will have to know how to strip this information. */
#ifdef ENCODE_SECTION_INFO
ENCODE_SECTION_INFO (decl);
#endif
}
}
+ /* If the old RTL had the wrong mode, fix the mode. */
+ else if (GET_MODE (DECL_RTL (decl)) != DECL_MODE (decl))
+ {
+ rtx rtl = DECL_RTL (decl);
+ PUT_MODE (rtl, DECL_MODE (decl));
+ }
}
/* Make the rtl for variable VAR be volatile.
Use this only for static variables. */
+void
make_var_volatile (var)
tree var;
{
MEM_VOLATILE_P (DECL_RTL (var)) = 1;
}
\f
+/* Output alignment directive to align for constant expression EXP. */
+
+void
+assemble_constant_align (exp)
+ tree exp;
+{
+ int align;
+
+ /* Align the location counter as required by EXP's data type. */
+ align = TYPE_ALIGN (TREE_TYPE (exp));
+#ifdef CONSTANT_ALIGNMENT
+ align = CONSTANT_ALIGNMENT (exp, align);
+#endif
+
+ if (align > BITS_PER_UNIT)
+ ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
+}
+
/* Output a string of literal assembler code
for an `asm' keyword used between functions. */
assemble_asm (string)
tree string;
{
+ if (output_bytecode)
+ {
+ error ("asm statements not allowed in interpreter");
+ return;
+ }
+
app_enable ();
if (TREE_CODE (string) == ADDR_EXPR)
output_constant_pool (fnname, decl);
- text_section ();
-
+ function_section (decl);
/* 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);
+ {
+ if (output_bytecode)
+ BC_OUTPUT_ALIGN (asm_out_file, align);
+ else
+ ASM_OUTPUT_ALIGN (asm_out_file, align);
+ }
#ifdef ASM_OUTPUT_FUNCTION_PREFIX
ASM_OUTPUT_FUNCTION_PREFIX (asm_out_file, fnname);
{
if (!first_global_object_name)
STRIP_NAME_ENCODING (first_global_object_name, fnname);
- ASM_GLOBALIZE_LABEL (asm_out_file, fnname);
+ if (output_bytecode)
+ BC_GLOBALIZE_LABEL (asm_out_file, fnname);
+ else
+ ASM_GLOBALIZE_LABEL (asm_out_file, fnname);
}
/* Do any machine/system dependent processing of the 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);
+ if (output_bytecode)
+ BC_OUTPUT_LABEL (asm_out_file, fnname);
+ else
+ ASM_OUTPUT_LABEL (asm_out_file, fnname);
#endif /* ASM_DECLARE_FUNCTION_NAME */
}
assemble_zeros (size)
int size;
{
+ if (output_bytecode)
+ {
+ bc_emit_const_skip (size);
+ return;
+ }
+
#ifdef ASM_NO_SKIP_IN_TEXT
/* The `space' pseudo in the text section outputs nop insns rather than 0s,
so we must output 0s explicitly in the text section. */
else
#endif
if (size > 0)
- ASM_OUTPUT_SKIP (asm_out_file, size);
+ {
+ if (output_bytecode)
+ BC_OUTPUT_SKIP (asm_out_file, size);
+ else
+ ASM_OUTPUT_SKIP (asm_out_file, size);
+ }
+}
+
+/* Assemble an alignment pseudo op for an ALIGN-bit boundary. */
+
+void
+assemble_align (align)
+ int align;
+{
+ if (align > BITS_PER_UNIT)
+ ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
}
/* Assemble a string constant with the specified C string as contents. */
void
assemble_string (p, size)
- unsigned char *p;
+ char *p;
int size;
{
register int i;
int pos = 0;
int maximum = 2000;
+ if (output_bytecode)
+ {
+ bc_emit (p, size);
+ return;
+ }
+
/* If the string is very long, split it up. */
while (pos < size)
if (thissize > maximum)
thissize = maximum;
- ASM_OUTPUT_ASCII (asm_out_file, p, thissize);
+ if (output_bytecode)
+ bc_output_ascii (asm_out_file, p, thissize);
+ else
+ {
+ ASM_OUTPUT_ASCII (asm_out_file, p, thissize);
+ }
pos += thissize;
p += thissize;
}
}
+
+static void
+bc_output_ascii (file, p, size)
+ FILE *file;
+ char *p;
+ int size;
+{
+ BC_OUTPUT_ASCII (file, p, size);
+}
\f
/* Assemble everything that is needed for a variable or function declaration.
Not used for automatic variables, and not used for function definitions.
TOP_LEVEL is nonzero if this variable has file scope.
AT_END is nonzero if this is the special handling, at end of compilation,
- to define things that have had only tentative definitions. */
+ to define things that have had only tentative definitions.
+ DONT_OUTPUT_DATA if nonzero means don't actually output the
+ initial value (that will be done by the caller). */
void
-assemble_variable (decl, top_level, at_end)
+assemble_variable (decl, top_level, at_end, dont_output_data)
tree decl;
int top_level;
int at_end;
+ int dont_output_data;
{
register char *name;
int align;
tree size_tree;
int reloc = 0;
+ enum in_section saved_in_section;
+
+ last_assemble_variable_decl = 0;
+
+ if (output_bytecode)
+ return;
if (GET_CODE (DECL_RTL (decl)) == REG)
{
return;
TREE_ASM_WRITTEN (decl) = 1;
+ if (!output_bytecode)
+ {
#if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
- /* File-scope global variables are output here. */
- if ((write_symbols == DBX_DEBUG || write_symbols == XCOFF_DEBUG)
- && top_level)
- dbxout_symbol (decl, 0);
+ /* File-scope global variables are output here. */
+ if ((write_symbols == DBX_DEBUG || write_symbols == XCOFF_DEBUG)
+ && top_level)
+ dbxout_symbol (decl, 0);
#endif
#ifdef SDB_DEBUGGING_INFO
- if (write_symbols == SDB_DEBUG && top_level
- /* Leave initialized global vars for end of compilation;
- see comment in compile_file. */
- && (TREE_PUBLIC (decl) == 0 || DECL_INITIAL (decl) == 0))
- sdbout_symbol (decl, 0);
+ if (write_symbols == SDB_DEBUG && top_level
+ /* Leave initialized global vars for end of compilation;
+ see comment in compile_file. */
+ && (TREE_PUBLIC (decl) == 0 || DECL_INITIAL (decl) == 0))
+ sdbout_symbol (decl, 0);
#endif
+ }
/* Don't output any DWARF debugging information for variables here.
In the case of local variables, the information for them is output
/* 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)
+ if (!dont_output_data && DECL_SIZE (decl) == 0)
{
error_with_file_and_line (DECL_SOURCE_FILE (decl),
DECL_SOURCE_LINE (decl),
"storage size of `%s' isn't known",
IDENTIFIER_POINTER (DECL_NAME (decl)));
+ TREE_ASM_WRITTEN (decl) = 1;
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
- /* Leave initialized global vars for end of compilation;
- see comment in compile_file. */
- && (TREE_PUBLIC (decl) == 0 || DECL_INITIAL (decl) == 0))
- sdbout_symbol (decl, 0);
-#endif
-
- /* Don't output any DWARF debugging information for variables here.
- In the case of local variables, the information for them is output
- when we do our recursive traversal of the tree representation for
- the entire containing function. In the case of file-scope variables,
- we output information for all of them at the very end of compilation
- while we are doing our final traversal of the chain of file-scope
- declarations. */
-
- /* If storage size is erroneously variable, just continue.
- Error message was already made. */
-
- if (TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST)
- goto finish;
-
app_disable ();
- /* This is better than explicit arithmetic, since it avoids overflow. */
- size_tree = size_binop (CEIL_DIV_EXPR,
+ if (! dont_output_data)
+ {
+ if (TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST)
+ goto finish;
+
+ /* This is better than explicit arithmetic, since it avoids overflow. */
+ size_tree = size_binop (CEIL_DIV_EXPR,
DECL_SIZE (decl), size_int (BITS_PER_UNIT));
- if (TREE_INT_CST_HIGH (size_tree) != 0)
- {
- error_with_decl (decl, "size of variable `%s' is too large");
- goto finish;
+ if (TREE_INT_CST_HIGH (size_tree) != 0)
+ {
+ error_with_decl (decl, "size of variable `%s' is too large");
+ goto finish;
+ }
}
name = XSTR (XEXP (DECL_RTL (decl), 0), 0);
/* ANSI specifies that a tentative definition which is not merged with
a non-tentative definition behaves exactly like a definition with an
initializer equal to zero. (Section 3.7.2)
- -fno-common gives strict ANSI behavior. Usually you don't want it. */
- if (! flag_no_common
+ -fno-common gives strict ANSI behavior. Usually you don't want it.
+ This matters only for variables with external linkage. */
+ if ((! flag_no_common || ! TREE_PUBLIC (decl))
+ && DECL_COMMON (decl)
+ && ! dont_output_data
&& (DECL_INITIAL (decl) == 0 || DECL_INITIAL (decl) == error_mark_node))
{
int size = TREE_INT_CST_LOW (size_tree);
rounded += (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1;
rounded = (rounded / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
* (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
+
+#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
+ /* Leave initialized global vars for end of compilation;
+ see comment in compile_file. */
+ && (TREE_PUBLIC (decl) == 0 || DECL_INITIAL (decl) == 0))
+ sdbout_symbol (decl, 0);
+#endif
+
+ /* Don't output any DWARF debugging information for variables here.
+ In the case of local variables, the information for them is output
+ when we do our recursive traversal of the tree representation for
+ the entire containing function. In the case of file-scope variables,
+ we output information for all of them at the very end of compilation
+ while we are doing our final traversal of the chain of file-scope
+ declarations. */
+
#if 0
if (flag_shared_data)
data_section ();
ASM_OUTPUT_SHARED_COMMON (asm_out_file, name, size, rounded);
else
#endif
+ if (output_bytecode)
+ {
+ BC_OUTPUT_COMMON (asm_out_file, name, size, rounded);
+ }
+ else
+ {
#ifdef ASM_OUTPUT_ALIGNED_COMMON
- ASM_OUTPUT_ALIGNED_COMMON (asm_out_file, name, size,
- DECL_ALIGN (decl));
+ ASM_OUTPUT_ALIGNED_COMMON (asm_out_file, name, size,
+ DECL_ALIGN (decl));
#else
- ASM_OUTPUT_COMMON (asm_out_file, name, size, rounded);
+ ASM_OUTPUT_COMMON (asm_out_file, name, size, rounded);
#endif
+ }
}
else
{
ASM_OUTPUT_SHARED_LOCAL (asm_out_file, name, size, rounded);
else
#endif
+ if (output_bytecode)
+ {
+ BC_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
+ }
+ else
+ {
#ifdef ASM_OUTPUT_ALIGNED_LOCAL
- ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size,
- DECL_ALIGN (decl));
+ ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size,
+ DECL_ALIGN (decl));
#else
- ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
+ ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
#endif
+ }
}
goto finish;
}
#endif
/* Output any data that we will need to use the address of. */
- if (DECL_INITIAL (decl))
+ if (DECL_INITIAL (decl) == error_mark_node)
+ reloc = contains_pointers_p (TREE_TYPE (decl));
+ else if (DECL_INITIAL (decl))
reloc = output_addressed_constants (DECL_INITIAL (decl));
/* Switch to the proper section for this data. */
+ if (IN_NAMED_SECTION (decl))
+ named_section (decl, NULL);
+ else
+ {
+ /* C++ can have const variables that get initialized from constructors,
+ and thus can not be in a readonly section. We prevent this by
+ verifying that the initial value is constant for objects put in a
+ readonly section.
+
+ error_mark_node is used by the C front end to indicate that the
+ initializer has not been seen yet. In this case, we assume that
+ the initializer must be constant. */
#ifdef SELECT_SECTION
- SELECT_SECTION (decl, reloc);
+ SELECT_SECTION (decl, reloc);
#else
- if (TREE_READONLY (decl)
- && ! TREE_THIS_VOLATILE (decl)
- && ! (flag_pic && reloc))
- readonly_data_section ();
- else
- data_section ();
+ if (TREE_READONLY (decl)
+ && ! TREE_THIS_VOLATILE (decl)
+ && DECL_INITIAL (decl)
+ && (DECL_INITIAL (decl) == error_mark_node
+ || TREE_CONSTANT (DECL_INITIAL (decl)))
+ && ! (flag_pic && reloc))
+ readonly_data_section ();
+ else
+ data_section ();
#endif
+ }
+
+ /* dbxout.c needs to know this. */
+ if (in_text_section ())
+ DECL_IN_TEXT_SECTION (decl) = 1;
+
+ /* Record current section so we can restore it if dbxout.c clobbers it. */
+ saved_in_section = in_section;
+
+ /* Output the dbx info now that we have chosen the section. */
+
+#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
+ /* Leave initialized global vars for end of compilation;
+ see comment in compile_file. */
+ && (TREE_PUBLIC (decl) == 0 || DECL_INITIAL (decl) == 0))
+ sdbout_symbol (decl, 0);
+#endif
+
+ /* Don't output any DWARF debugging information for variables here.
+ In the case of local variables, the information for them is output
+ when we do our recursive traversal of the tree representation for
+ the entire containing function. In the case of file-scope variables,
+ we output information for all of them at the very end of compilation
+ while we are doing our final traversal of the chain of file-scope
+ declarations. */
+
+ /* If the debugging output changed sections, reselect the section
+ that's supposed to be selected. */
+ if (in_section != saved_in_section)
+ {
+ /* Switch to the proper section for this data. */
+#ifdef SELECT_SECTION
+ SELECT_SECTION (decl, reloc);
+#else
+ if (TREE_READONLY (decl)
+ && ! TREE_THIS_VOLATILE (decl)
+ && DECL_INITIAL (decl)
+ && (DECL_INITIAL (decl) == error_mark_node
+ || TREE_CONSTANT (DECL_INITIAL (decl)))
+ && ! (flag_pic && reloc))
+ readonly_data_section ();
+ else
+ data_section ();
+#endif
+ }
/* Compute and output the alignment of this data. */
align = DECL_ALIGN (decl);
+ /* In the case for initialing an array whose length isn't specified,
+ where we have not yet been able to do the layout,
+ figure out the proper alignment now. */
+ if (dont_output_data && DECL_SIZE (decl) == 0
+ && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
+ align = MAX (align, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (decl))));
+
/* Some object file formats have a maximum alignment which they support.
In particular, a.out format supports a maximum alignment of 4. */
#ifndef MAX_OFILE_ALIGNMENT
DECL_ALIGN (decl) = align;
if (align > BITS_PER_UNIT)
- ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
+ {
+ if (output_bytecode)
+ BC_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
+ else
+ ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
+ }
/* Do any machine/system dependent processing of the object. */
#ifdef ASM_DECLARE_OBJECT_NAME
+ last_assemble_variable_decl = decl;
ASM_DECLARE_OBJECT_NAME (asm_out_file, name, decl);
#else
/* Standard thing is just output label for the object. */
- ASM_OUTPUT_LABEL (asm_out_file, name);
+ if (output_bytecode)
+ BC_OUTPUT_LABEL (asm_out_file, name);
+ else
+ ASM_OUTPUT_LABEL (asm_out_file, name);
#endif /* ASM_DECLARE_OBJECT_NAME */
-#if 0
- for (d = equivalents; d; d = TREE_CHAIN (d))
+ if (!dont_output_data)
{
- tree e = TREE_VALUE (d);
- ASM_OUTPUT_LABEL (asm_out_file, XSTR (XEXP (DECL_RTL (e), 0), 0));
+ if (DECL_INITIAL (decl))
+ /* Output the actual data. */
+ output_constant (DECL_INITIAL (decl), TREE_INT_CST_LOW (size_tree));
+ else
+ /* Leave space for it. */
+ assemble_zeros (TREE_INT_CST_LOW (size_tree));
}
-#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. */
- assemble_zeros (int_size_in_bytes (TREE_TYPE (decl)));
finish:
#ifdef XCOFF_DEBUGGING_INFO
/* File-scope global variables are output here. */
if (write_symbols == XCOFF_DEBUG && top_level)
- dbxout_symbol (decl, 0);
+ {
+ saved_in_section = in_section;
+
+ dbxout_symbol (decl, 0);
+
+ if (in_section != saved_in_section)
+ {
+ /* Switch to the proper section for this data. */
+#ifdef SELECT_SECTION
+ SELECT_SECTION (decl, reloc);
+#else
+ if (TREE_READONLY (decl)
+ && ! TREE_THIS_VOLATILE (decl)
+ && DECL_INITIAL (decl)
+ && (DECL_INITIAL (decl) == error_mark_node
+ || TREE_CONSTANT (DECL_INITIAL (decl)))
+ && ! (flag_pic && reloc))
+ readonly_data_section ();
+ else
+ data_section ();
+#endif
+ }
+ }
#else
/* There must be a statement after a label. */
;
#endif
}
+/* Return 1 if type TYPE contains any pointers. */
+
+static int
+contains_pointers_p (type)
+ tree type;
+{
+ switch (TREE_CODE (type))
+ {
+ case POINTER_TYPE:
+ case REFERENCE_TYPE:
+ /* I'm not sure whether OFFSET_TYPE needs this treatment,
+ so I'll play safe and return 1. */
+ case OFFSET_TYPE:
+ return 1;
+
+ case RECORD_TYPE:
+ case UNION_TYPE:
+ case QUAL_UNION_TYPE:
+ {
+ tree fields;
+ /* For a type that has fields, see if the fields have pointers. */
+ for (fields = TYPE_FIELDS (type); fields; fields = TREE_CHAIN (fields))
+ if (TREE_CODE (fields) == FIELD_DECL
+ && contains_pointers_p (TREE_TYPE (fields)))
+ return 1;
+ return 0;
+ }
+
+ case ARRAY_TYPE:
+ /* An array type contains pointers if its element type does. */
+ return contains_pointers_p (TREE_TYPE (type));
+
+ default:
+ return 0;
+ }
+}
+
+/* Output text storage for constructor CONSTR. */
+
+void
+bc_output_constructor (constr, size)
+ tree constr;
+ int size;
+{
+ int i;
+
+ /* Must always be a literal; non-literal constructors are handled
+ differently. */
+
+ if (!TREE_CONSTANT (constr))
+ abort ();
+
+ /* Always const */
+ text_section ();
+
+ /* Align */
+ for (i = 0; TYPE_ALIGN (constr) >= BITS_PER_UNIT << (i + 1); i++)
+ ;
+
+ if (i > 0)
+ BC_OUTPUT_ALIGN (asm_out_file, i);
+
+ /* Output data */
+ output_constant (constr, size);
+}
+
+/* Create storage for constructor CONSTR. */
+
+void
+bc_output_data_constructor (constr)
+ tree constr;
+{
+ int i;
+
+ /* Put in data section */
+ data_section ();
+
+ /* Align */
+ for (i = 0; TYPE_ALIGN (constr) >= BITS_PER_UNIT << (i + 1); i++);
+ if (i > 0)
+ BC_OUTPUT_ALIGN (asm_out_file, i);
+
+ /* The constructor is filled in at runtime. */
+ BC_OUTPUT_SKIP (asm_out_file, int_size_in_bytes (TREE_TYPE (constr)));
+}
+
/* Output something to declare an external symbol to the assembler.
(Most assemblers don't need this, so we normally output nothing.)
Do nothing if DECL is not external. */
assemble_external (decl)
tree decl;
{
+ if (output_bytecode)
+ return;
+
#ifdef ASM_OUTPUT_EXTERNAL
if (TREE_CODE_CLASS (TREE_CODE (decl)) == 'd'
&& DECL_EXTERNAL (decl) && TREE_PUBLIC (decl))
rtx fun;
{
#ifdef ASM_OUTPUT_EXTERNAL_LIBCALL
- /* Declare library function name external when first used, if nec. */
- if (! SYMBOL_REF_USED (fun))
+ if (!output_bytecode)
{
- SYMBOL_REF_USED (fun) = 1;
- ASM_OUTPUT_EXTERNAL_LIBCALL (asm_out_file, fun);
+ /* Declare library function name external when first used, if nec. */
+ if (! SYMBOL_REF_USED (fun))
+ {
+ SYMBOL_REF_USED (fun) = 1;
+ ASM_OUTPUT_EXTERNAL_LIBCALL (asm_out_file, fun);
+ }
}
#endif
}
assemble_label (name)
char *name;
{
- ASM_OUTPUT_LABEL (asm_out_file, name);
+ if (output_bytecode)
+ BC_OUTPUT_LABEL (asm_out_file, name);
+ else
+ ASM_OUTPUT_LABEL (asm_out_file, name);
}
/* Output to FILE a reference to the assembler name of a C-level name NAME.
FILE *file;
char *name;
{
+ char *real_name;
+
+ STRIP_NAME_ENCODING (real_name, name);
+ TREE_SYMBOL_REFERENCED (get_identifier (real_name)) = 1;
+
if (name[0] == '*')
- fputs (&name[1], file);
+ {
+ if (output_bytecode)
+ bc_emit_labelref (name);
+ else
+ fputs (&name[1], file);
+ }
else
- ASM_OUTPUT_LABELREF (file, name);
+ {
+ if (output_bytecode)
+ BC_OUTPUT_LABELREF (file, name);
+ else
+ ASM_OUTPUT_LABELREF (file, name);
+ }
}
/* Allocate SIZE bytes writable static space with a gensym name
strlen (name) + 2);
strcpy (namestring, name);
- x = gen_rtx (SYMBOL_REF, Pmode, namestring);
+ if (output_bytecode)
+ x = bc_gen_rtx (namestring, 0, (struct bc_label *) 0);
+ else
+ x = gen_rtx (SYMBOL_REF, Pmode, namestring);
+
+ if (output_bytecode)
+ {
+ BC_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
+ }
+ else
+ {
#ifdef ASM_OUTPUT_ALIGNED_LOCAL
- ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, BIGGEST_ALIGNMENT);
+ ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, BIGGEST_ALIGNMENT);
#else
- ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
+ ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
#endif
+ }
return x;
}
char *name;
int align;
+ /* Shouldn't get here */
+ if (output_bytecode)
+ abort ();
+
/* By default, put trampoline templates in read-only data section. */
#ifdef TRAMPOLINE_SECTION
{
error ("floating point trap outputting a constant");
#ifdef REAL_IS_NOT_DOUBLE
- bzero (&d, sizeof d);
+ bzero ((char *) &d, sizeof d);
d = dconst0;
#else
d = 0;
ASM_OUTPUT_SHORT_FLOAT (asm_out_file, d);
break;
#endif
+#ifdef ASM_OUTPUT_THREE_QUARTER_FLOAT
+ case TQFmode:
+ ASM_OUTPUT_THREE_QUARTER_FLOAT (asm_out_file, d);
+ break;
+#endif
#ifdef ASM_OUTPUT_FLOAT
case SFmode:
ASM_OUTPUT_FLOAT (asm_out_file, d);
#endif
#ifdef ASM_OUTPUT_LONG_DOUBLE
+ case XFmode:
case TFmode:
ASM_OUTPUT_LONG_DOUBLE (asm_out_file, d);
break;
static rtx const_double_chain;
-/* Return a CONST_DOUBLE for a value specified as a pair of ints.
+/* Return a CONST_DOUBLE or CONST_INT 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. */
/* We cannot represent this value as a constant. */
abort ();
+ /* If this would be an entire word for the target, but is not for
+ the host, then sign-extend on the host so that the number will look
+ the same way on the host that it would on the target.
+
+ For example, when building a 64 bit alpha hosted 32 bit sparc
+ targeted compiler, then we want the 32 bit unsigned value -1 to be
+ represented as a 64 bit value -1, and not as 0x00000000ffffffff.
+ The later confuses the sparc backend. */
+
+ if (BITS_PER_WORD < HOST_BITS_PER_WIDE_INT && BITS_PER_WORD == width
+ && (i0 & ((HOST_WIDE_INT) 1 << (width - 1))))
+ i0 |= ((HOST_WIDE_INT) (-1) << width);
+
/* If MODE fits within HOST_BITS_PER_WIDE_INT, always use a CONST_INT.
??? Strictly speaking, this is wrong if we create a CONST_INT
r = gen_rtx (CONST_DOUBLE, mode, 0, i0, i1);
pop_obstacks ();
- /* Don't touch const_double_chain in nested function;
- see force_const_mem. */
- if (outer_function_chain == 0)
+ /* Don't touch const_double_chain in nested function; see force_const_mem.
+ Also, don't touch it if not inside any function. */
+ if (outer_function_chain == 0 && current_function_decl != 0)
{
CONST_DOUBLE_CHAIN (r) = const_double_chain;
const_double_chain = r;
/* Detect special cases. */
/* Avoid REAL_VALUES_EQUAL here in order to distinguish minus zero. */
- if (!bcmp (&dconst0, &d, sizeof d))
+ if (!bcmp ((char *) &dconst0, (char *) &d, sizeof d))
return CONST0_RTX (mode);
- else if (REAL_VALUES_EQUAL (dconst1, d))
+ /* Check for NaN first, because some ports (specifically the i386) do not
+ emit correct ieee-fp code by default, and thus will generate a core
+ dump here if we pass a NaN to REAL_VALUES_EQUAL and if REAL_VALUES_EQUAL
+ does a floating point comparison. */
+ else if (! REAL_VALUE_ISNAN (d) && REAL_VALUES_EQUAL (dconst1, d))
return CONST1_RTX (mode);
if (sizeof u == 2 * sizeof (HOST_WIDE_INT))
If one is found, return it. */
for (r = const_double_chain; r; r = CONST_DOUBLE_CHAIN (r))
- if (! bcmp (&CONST_DOUBLE_LOW (r), &u, sizeof u)
+ if (! bcmp ((char *) &CONST_DOUBLE_LOW (r), (char *) &u, sizeof u)
&& GET_MODE (r) == mode)
return r;
rtl_in_saveable_obstack ();
r = rtx_alloc (CONST_DOUBLE);
PUT_MODE (r, mode);
- bcopy (&u, &CONST_DOUBLE_LOW (r), sizeof u);
+ bcopy ((char *) &u, (char *) &CONST_DOUBLE_LOW (r), sizeof u);
pop_obstacks ();
- /* Don't touch const_double_chain in nested function;
- see force_const_mem. */
- if (outer_function_chain == 0)
+ /* Don't touch const_double_chain in nested function; see force_const_mem.
+ Also, don't touch it if not inside any function. */
+ if (outer_function_chain == 0 && current_function_decl != 0)
{
CONST_DOUBLE_CHAIN (r) = const_double_chain;
const_double_chain = r;
break;
case LABEL_DECL:
- x = gen_rtx (MEM, FUNCTION_MODE,
- gen_rtx (LABEL_REF, VOIDmode,
- label_rtx (TREE_OPERAND (exp, 0))));
+ if (output_bytecode)
+ /* FIXME: this may not be correct, check it */
+ x = bc_gen_rtx (TREE_STRING_POINTER (target), 0, (struct bc_label *) 0);
+ else
+ x = gen_rtx (MEM, FUNCTION_MODE,
+ gen_rtx (LABEL_REF, VOIDmode,
+ label_rtx (TREE_OPERAND (exp, 0))));
break;
case REAL_CST:
abort ();
}
- if (GET_CODE (x) != MEM)
- abort ();
- x = XEXP (x, 0);
+ if (!output_bytecode)
+ {
+ if (GET_CODE (x) != MEM)
+ abort ();
+ x = XEXP (x, 0);
+ }
value->base = x;
value->offset = offset;
/* Compute a hash code for a constant expression. */
-int
+static int
const_hash (exp)
tree exp;
{
else if (code == COMPLEX_CST)
return const_hash (TREE_REALPART (exp)) * 5
+ const_hash (TREE_IMAGPART (exp));
+ else if (code == CONSTRUCTOR && TREE_CODE (TREE_TYPE (exp)) == SET_TYPE)
+ {
+ len = int_size_in_bytes (TREE_TYPE (exp));
+ p = (char*) alloca (len);
+ get_set_constructor_bytes (exp, (unsigned char *) p, len);
+ }
else if (code == CONSTRUCTOR)
{
register tree link;
return 0;
strp = TREE_STRING_POINTER (exp);
len = TREE_STRING_LENGTH (exp);
- if (bcmp (&TREE_STRING_LENGTH (exp), p,
+ if (bcmp ((char *) &TREE_STRING_LENGTH (exp), p,
sizeof TREE_STRING_LENGTH (exp)))
return 0;
p += sizeof TREE_STRING_LENGTH (exp);
p = compare_constant_1 (TREE_IMAGPART (exp), p);
return p;
}
+ else if (code == CONSTRUCTOR && TREE_CODE (TREE_TYPE (exp)) == SET_TYPE)
+ {
+ len = int_size_in_bytes (TREE_TYPE (exp));
+ strp = (char*) alloca (len);
+ get_set_constructor_bytes (exp, (unsigned char *) strp, len);
+ }
else if (code == CONSTRUCTOR)
{
register tree link;
int length = list_length (CONSTRUCTOR_ELTS (exp));
tree type;
- if (bcmp (&length, p, sizeof length))
+ if (bcmp ((char *) &length, p, sizeof length))
return 0;
p += sizeof length;
type = TREE_TYPE (exp);
else
type = 0;
- if (bcmp (&type, p, sizeof type))
+ if (bcmp ((char *) &type, p, sizeof type))
return 0;
p += sizeof type;
if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
{
int size = int_size_in_bytes (TREE_TYPE (exp));
- if (bcmp (&size, p, sizeof size))
+ if (bcmp ((char *) &size, p, sizeof size))
return 0;
p += sizeof size;
}
{
tree zero = 0;
- if (bcmp (&zero, p, sizeof zero))
+ if (bcmp ((char *) &zero, p, sizeof zero))
return 0;
p += sizeof zero;
}
record_constant (exp)
tree exp;
{
- struct constant_descriptor *ptr = 0;
- int buf;
+ struct constant_descriptor *next = 0;
+ char *label = 0;
+
+ /* Make a struct constant_descriptor. The first two pointers will
+ be filled in later. Here we just leave space for them. */
- obstack_grow (&permanent_obstack, &ptr, sizeof ptr);
- obstack_grow (&permanent_obstack, &buf, sizeof buf);
+ obstack_grow (&permanent_obstack, (char *) &next, sizeof next);
+ obstack_grow (&permanent_obstack, (char *) &label, sizeof label);
record_constant_1 (exp);
return (struct constant_descriptor *) obstack_finish (&permanent_obstack);
}
obstack_1grow (&permanent_obstack, (unsigned int) code);
- if (code == INTEGER_CST)
+ switch (code)
{
+ case 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)
- {
+ break;
+
+ case 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)
- {
+ break;
+
+ case 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)
- {
+ break;
+
+ case 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 arrays, insist that the size in bytes match. */
- if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
+ case CONSTRUCTOR:
+ if (TREE_CODE (TREE_TYPE (exp)) == SET_TYPE)
{
- int size = int_size_in_bytes (TREE_TYPE (exp));
- obstack_grow (&permanent_obstack, (char *) &size, sizeof size);
+ int nbytes = int_size_in_bytes (TREE_TYPE (exp));
+ obstack_grow (&permanent_obstack, &nbytes, sizeof (nbytes));
+ obstack_blank (&permanent_obstack, nbytes);
+ get_set_constructor_bytes
+ (exp, (unsigned char *) permanent_obstack.next_free, nbytes);
+ return;
}
-
- for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
+ else
{
- if (TREE_VALUE (link))
- record_constant_1 (TREE_VALUE (link));
+ 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 arrays, insist that the size in bytes match. */
+ if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
{
- tree zero = 0;
+ int size = int_size_in_bytes (TREE_TYPE (exp));
+ obstack_grow (&permanent_obstack, (char *) &size, sizeof size);
+ }
+
+ for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
+ {
+ if (TREE_VALUE (link))
+ record_constant_1 (TREE_VALUE (link));
+ else
+ {
+ tree zero = 0;
- obstack_grow (&permanent_obstack, (char *) &zero, sizeof zero);
+ obstack_grow (&permanent_obstack,
+ (char *) &zero, sizeof zero);
+ }
}
}
-
return;
- }
- else if (code == ADDR_EXPR)
- {
- struct addr_const value;
- decode_addr_const (exp, &value);
- /* Record the offset. */
- obstack_grow (&permanent_obstack,
- (char *) &value.offset, sizeof value.offset);
- /* Record the symbol name. */
- obstack_grow (&permanent_obstack, XSTR (value.base, 0),
- strlen (XSTR (value.base, 0)) + 1);
+
+ case ADDR_EXPR:
+ {
+ struct addr_const value;
+
+ decode_addr_const (exp, &value);
+ /* Record the offset. */
+ obstack_grow (&permanent_obstack,
+ (char *) &value.offset, sizeof value.offset);
+ /* 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)
- {
+
+ case PLUS_EXPR:
+ case MINUS_EXPR:
record_constant_1 (TREE_OPERAND (exp, 0));
record_constant_1 (TREE_OPERAND (exp, 1));
return;
- }
- else if (code == NOP_EXPR || code == CONVERT_EXPR)
- {
+
+ case NOP_EXPR:
+ case CONVERT_EXPR:
+ case NON_LVALUE_EXPR:
record_constant_1 (TREE_OPERAND (exp, 0));
return;
+
+ default:
+ abort ();
}
/* Record constant contents. */
obstack_grow (&permanent_obstack, strp, len);
}
\f
+/* Record a list of constant expressions that were passed to
+ output_constant_def but that could not be output right away. */
+
+struct deferred_constant
+{
+ struct deferred_constant *next;
+ tree exp;
+ int reloc;
+ int labelno;
+};
+
+static struct deferred_constant *deferred_constants;
+
+/* Nonzero means defer output of addressed subconstants
+ (i.e., those for which output_constant_def is called.) */
+static int defer_addressed_constants_flag;
+
+/* Start deferring output of subconstants. */
+
+void
+defer_addressed_constants ()
+{
+ defer_addressed_constants_flag++;
+}
+
+/* Stop deferring output of subconstants,
+ and output now all those that have been deferred. */
+
+void
+output_deferred_addressed_constants ()
+{
+ struct deferred_constant *p, *next;
+
+ defer_addressed_constants_flag--;
+
+ if (defer_addressed_constants_flag > 0)
+ return;
+
+ for (p = deferred_constants; p; p = next)
+ {
+ output_constant_def_contents (p->exp, p->reloc, p->labelno);
+ next = p->next;
+ free (p);
+ }
+
+ deferred_constants = 0;
+}
+
+/* Make a copy of the whole tree structure for a constant.
+ This handles the same types of nodes that compare_constant
+ and record_constant handle. */
+
+static tree
+copy_constant (exp)
+ tree exp;
+{
+ switch (TREE_CODE (exp))
+ {
+ case ADDR_EXPR:
+ /* For ADDR_EXPR, we do not want to copy the decl whose address
+ is requested. We do want to copy constants though. */
+ if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 0))) == 'c')
+ return build1 (TREE_CODE (exp), TREE_TYPE (exp),
+ copy_constant (TREE_OPERAND (exp, 0)));
+ else
+ return copy_node (exp);
+
+ case INTEGER_CST:
+ case REAL_CST:
+ case STRING_CST:
+ return copy_node (exp);
+
+ case COMPLEX_CST:
+ return build_complex (copy_constant (TREE_REALPART (exp)),
+ copy_constant (TREE_IMAGPART (exp)));
+
+ case PLUS_EXPR:
+ case MINUS_EXPR:
+ return build (TREE_CODE (exp), TREE_TYPE (exp),
+ copy_constant (TREE_OPERAND (exp, 0)),
+ copy_constant (TREE_OPERAND (exp, 1)));
+
+ case NOP_EXPR:
+ case CONVERT_EXPR:
+ return build1 (TREE_CODE (exp), TREE_TYPE (exp),
+ copy_constant (TREE_OPERAND (exp, 0)));
+
+ case CONSTRUCTOR:
+ {
+ tree copy = copy_node (exp);
+ tree list = copy_list (CONSTRUCTOR_ELTS (exp));
+ tree tail;
+
+ CONSTRUCTOR_ELTS (copy) = list;
+ for (tail = list; tail; tail = TREE_CHAIN (tail))
+ TREE_VALUE (tail) = copy_constant (TREE_VALUE (tail));
+ if (TREE_CODE (TREE_TYPE (exp)) == SET_TYPE)
+ for (tail = list; tail; tail = TREE_CHAIN (tail))
+ TREE_PURPOSE (tail) = copy_constant (TREE_PURPOSE (tail));
+
+ return copy;
+ }
+
+ default:
+ abort ();
+ }
+}
+\f
/* 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.
+ Otherwise, output such a constant in memory (or defer it for later)
+ and generate an rtx for it.
+
+ The TREE_CST_RTL of EXP is set up to point to that rtx.
The const_hash_table records which constants already have label strings. */
rtx
output_constant_def (exp)
tree exp;
{
- register int hash, align;
+ register int hash;
register struct constant_descriptor *desc;
char label[256];
char *found = 0;
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))
{
found = desc->label;
break;
}
-
+
if (found == 0)
{
/* 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. */
-
+
/* Create a string containing the label name, in LABEL. */
ASM_GENERATE_INTERNAL_LABEL (label, "LC", const_labelno);
= (char *) obstack_copy0 (&permanent_obstack, label, strlen (label));
const_hash_table[hash] = desc;
}
-
+ else
+ {
+ /* Create a string containing the label name, in LABEL. */
+ ASM_GENERATE_INTERNAL_LABEL (label, "LC", const_labelno);
+ }
+
/* We have a symbol name; construct the SYMBOL_REF and the MEM. */
push_obstacks_nochange ();
end_temporary_allocation ();
def = gen_rtx (SYMBOL_REF, Pmode, desc->label);
-
+
TREE_CST_RTL (exp)
= gen_rtx (MEM, TYPE_MODE (TREE_TYPE (exp)), def);
RTX_UNCHANGING_P (TREE_CST_RTL (exp)) = 1;
- if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE
- || TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
+ if (AGGREGATE_TYPE_P (TREE_TYPE (exp)))
MEM_IN_STRUCT_P (TREE_CST_RTL (exp)) = 1;
pop_obstacks ();
/* Optionally set flags or add text to the name to record information
such as that it is a function name. If the name is changed, the macro
- ASM_OUTPUT_LABELREF will have to know how to strip this information.
- And if it finds a * at the beginning after doing so, it must handle
- that too. */
+ ASM_OUTPUT_LABELREF will have to know how to strip this information. */
#ifdef ENCODE_SECTION_INFO
ENCODE_SECTION_INFO (exp);
#endif
+ /* If this is the first time we've seen this particular constant,
+ output it (or defer its output for later). */
if (found == 0)
{
- /* Now output assembler code to define that label
- and follow it with the data of EXP. */
+ if (defer_addressed_constants_flag)
+ {
+ struct deferred_constant *p;
+ p = (struct deferred_constant *) xmalloc (sizeof (struct deferred_constant));
+
+ push_obstacks_nochange ();
+ suspend_momentary ();
+ p->exp = copy_constant (exp);
+ pop_obstacks ();
+ p->reloc = reloc;
+ p->labelno = const_labelno++;
+ p->next = deferred_constants;
+ deferred_constants = p;
+ }
+ else
+ output_constant_def_contents (exp, reloc, const_labelno++);
+ }
+
+ return TREE_CST_RTL (exp);
+}
+
+/* Now output assembler code to define the label for EXP,
+ and follow it with the data of EXP. */
+
+static void
+output_constant_def_contents (exp, reloc, labelno)
+ tree exp;
+ int reloc;
+ int labelno;
+{
+ int align;
+ if (IN_NAMED_SECTION (exp))
+ named_section (exp, NULL);
+ else
+ {
/* First switch to text section, except for writable strings. */
#ifdef SELECT_SECTION
SELECT_SECTION (exp, reloc);
else
readonly_data_section ();
#endif
+ }
- /* Align the location counter as required by EXP's data type. */
- align = TYPE_ALIGN (TREE_TYPE (exp));
+ /* Align the location counter as required by EXP's data type. */
+ align = TYPE_ALIGN (TREE_TYPE (exp));
#ifdef CONSTANT_ALIGNMENT
- align = CONSTANT_ALIGNMENT (exp, align);
+ align = CONSTANT_ALIGNMENT (exp, align);
#endif
- if (align > BITS_PER_UNIT)
- ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
-
- /* Output the label itself. */
- ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LC", const_labelno);
+ if (align > BITS_PER_UNIT)
+ {
+ if (!output_bytecode)
+ {
+ ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
+ }
+ else
+ {
+ BC_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
+ }
+ }
- /* Output the value of EXP. */
- output_constant (exp,
- (TREE_CODE (exp) == STRING_CST
- ? TREE_STRING_LENGTH (exp)
- : int_size_in_bytes (TREE_TYPE (exp))));
+ /* Output the label itself. */
+ ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LC", labelno);
- ++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))));
- return TREE_CST_RTL (exp);
}
\f
/* Similar hash facility for making memory-constants
const_rtx_sym_hash_table
= ((struct pool_sym **)
oballoc (MAX_RTX_HASH_TABLE * sizeof (struct pool_sym *)));
- bzero (const_rtx_hash_table,
+ bzero ((char *) const_rtx_hash_table,
MAX_RTX_HASH_TABLE * sizeof (struct constant_descriptor *));
- bzero (const_rtx_sym_hash_table,
+ bzero ((char *) const_rtx_sym_hash_table,
MAX_RTX_HASH_TABLE * sizeof (struct pool_sym *));
first_pool = last_pool = 0;
pool_offset = 0;
}
-/* Save and restore it for a nested function. */
+/* Save and restore status for a nested function. */
void
save_varasm_status (p)
{
case CONST_DOUBLE:
value->kind = RTX_DOUBLE;
- value->mode = GET_MODE (x);
- bcopy (&CONST_DOUBLE_LOW (x), &value->un.du, sizeof value->un.du);
+ if (GET_MODE (x) != VOIDmode)
+ value->mode = GET_MODE (x);
+ bcopy ((char *) &CONST_DOUBLE_LOW (x),
+ (char *) &value->un.du, sizeof value->un.du);
break;
case CONST_INT:
/* Compute a hash code for a constant RTL expression. */
-int
+static int
const_hash_rtx (mode, x)
enum machine_mode mode;
rtx x;
decode_rtx_const (mode, x, &value);
- obstack_grow (current_obstack, &ptr, sizeof ptr);
- obstack_grow (current_obstack, &label, sizeof label);
+ /* Put these things in the saveable obstack so we can ensure it won't
+ be freed if we are called from combine or some other phase that discards
+ memory allocated from function_obstack (current_obstack). */
+ obstack_grow (saveable_obstack, &ptr, sizeof ptr);
+ obstack_grow (saveable_obstack, &label, sizeof label);
/* Record constant contents. */
- obstack_grow (current_obstack, &value, sizeof value);
+ obstack_grow (saveable_obstack, &value, sizeof value);
- return (struct constant_descriptor *) obstack_finish (current_obstack);
+ return (struct constant_descriptor *) obstack_finish (saveable_obstack);
}
\f
/* Given a constant rtx X, make (or find) a memory constant for its value
pool_offset += align - 1;
pool_offset &= ~ (align - 1);
+ /* If RTL is not being placed into the saveable obstack, make a
+ copy of X that is in the saveable obstack in case we are being
+ called from combine or some other phase that discards memory
+ it allocates. We need only do this if it is a CONST, since
+ no other RTX should be allocated in this situation. */
+ if (rtl_obstack != saveable_obstack
+ && GET_CODE (x) == CONST)
+ {
+ push_obstacks_nochange ();
+ rtl_in_saveable_obstack ();
+
+ x = gen_rtx (CONST, GET_MODE (x),
+ gen_rtx (PLUS, GET_MODE (x),
+ XEXP (XEXP (x, 0), 0), XEXP (XEXP (x, 0), 1)));
+ pop_obstacks ();
+ }
+
/* Allocate a pool constant descriptor, fill it in, and chain it in. */
- pool = (struct pool_constant *) oballoc (sizeof (struct pool_constant));
+ pool = (struct pool_constant *) savealloc (sizeof (struct pool_constant));
pool->desc = desc;
pool->constant = x;
pool->mode = mode;
/* Add label to symbol hash table. */
hash = SYMHASH (found);
- sym = (struct pool_sym *) oballoc (sizeof (struct pool_sym));
+ sym = (struct pool_sym *) savealloc (sizeof (struct pool_sym));
sym->label = found;
sym->pool = pool;
sym->next = const_rtx_sym_hash_table[hash];
if (GET_CODE (x) != CONST_DOUBLE)
abort ();
- bcopy (&CONST_DOUBLE_LOW (x), &u, sizeof u);
+ bcopy ((char *) &CONST_DOUBLE_LOW (x), (char *) &u, sizeof u);
assemble_real (u.d, pool->mode);
break;
and make sure assembler code with a label has been output for each one.
Indicate whether an ADDR_EXPR has been encountered. */
-int
+static int
output_addressed_constants (exp)
tree exp;
{
if (size == 0)
return;
+ /* Eliminate the NON_LVALUE_EXPR_EXPR that makes a cast not be an lvalue.
+ That way we get the constant (we hope) inside it. Also, strip off any
+ NOP_EXPR that converts between two record, union, array, or set types. */
+ while ((TREE_CODE (exp) == NOP_EXPR
+ && (TREE_TYPE (exp) == TREE_TYPE (TREE_OPERAND (exp, 0))
+ || AGGREGATE_TYPE_P (TREE_TYPE (exp))))
+ || TREE_CODE (exp) == NON_LVALUE_EXPR)
+ exp = TREE_OPERAND (exp, 0);
+
/* Allow a constructor with no elements for any data type.
This means to fill the space with zeros. */
if (TREE_CODE (exp) == CONSTRUCTOR && CONSTRUCTOR_ELTS (exp) == 0)
{
- assemble_zeros (size);
+ if (output_bytecode)
+ bc_emit_const_skip (size);
+ else
+ assemble_zeros (size);
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 CHAR_TYPE:
else
abort ();
return;
+
+ case SET_TYPE:
+ if (TREE_CODE (exp) == INTEGER_CST)
+ assemble_integer (expand_expr (exp, NULL_RTX,
+ VOIDmode, EXPAND_INITIALIZER),
+ size, 1);
+ else if (TREE_CODE (exp) == CONSTRUCTOR)
+ {
+ unsigned char *buffer = (unsigned char *) alloca (size);
+ if (get_set_constructor_bytes (exp, buffer, size))
+ abort ();
+ assemble_string ((char *) buffer, size);
+ }
+ else
+ error ("unknown set constructor type");
+ return;
}
if (size > 0)
assemble_zeros (size);
}
+
+/* Bytecode specific code to output assembler for integer. */
+
+static void
+bc_assemble_integer (exp, size)
+ tree exp;
+ int size;
+{
+ tree const_part;
+ tree addr_part;
+ tree tmp;
+
+ /* FIXME: is this fold() business going to be as good as the
+ expand_expr() using EXPAND_SUM above in the RTL case? I
+ hate RMS.
+ FIXME: Copied as is from BC-GCC1; may need work. Don't hate. -bson */
+
+ exp = fold (exp);
+
+ while (TREE_CODE (exp) == NOP_EXPR || TREE_CODE (exp) == CONVERT_EXPR)
+ exp = TREE_OPERAND (exp, 0);
+ if (TREE_CODE (exp) == INTEGER_CST)
+ {
+ const_part = exp;
+ addr_part = 0;
+ }
+ else if (TREE_CODE (exp) == PLUS_EXPR)
+ {
+ const_part = TREE_OPERAND (exp, 0);
+ while (TREE_CODE (const_part) == NOP_EXPR
+ || TREE_CODE (const_part) == CONVERT_EXPR)
+ const_part = TREE_OPERAND (const_part, 0);
+ addr_part = TREE_OPERAND (exp, 1);
+ while (TREE_CODE (addr_part) == NOP_EXPR
+ || TREE_CODE (addr_part) == CONVERT_EXPR)
+ addr_part = TREE_OPERAND (addr_part, 0);
+ if (TREE_CODE (const_part) != INTEGER_CST)
+ tmp = const_part, const_part = addr_part, addr_part = tmp;
+ if (TREE_CODE (const_part) != INTEGER_CST
+ || TREE_CODE (addr_part) != ADDR_EXPR)
+ abort (); /* FIXME: we really haven't considered
+ all the possible cases here. */
+ }
+ else if (TREE_CODE (exp) == ADDR_EXPR)
+ {
+ const_part = integer_zero_node;
+ addr_part = exp;
+ }
+ else
+ abort (); /* FIXME: ditto previous. */
+
+ if (addr_part == 0)
+ {
+ if (size == 1)
+ {
+ char c = TREE_INT_CST_LOW (const_part);
+ bc_emit (&c, 1);
+ size -= 1;
+ }
+ else if (size == 2)
+ {
+ short s = TREE_INT_CST_LOW (const_part);
+ bc_emit ((char *) &s, 2);
+ size -= 2;
+ }
+ else if (size == 4)
+ {
+ int i = TREE_INT_CST_LOW (const_part);
+ bc_emit ((char *) &i, 4);
+ size -= 4;
+ }
+ else if (size == 8)
+ {
+ if (WORDS_BIG_ENDIAN)
+ {
+ int i = TREE_INT_CST_HIGH (const_part);
+ bc_emit ((char *) &i, 4);
+ i = TREE_INT_CST_LOW (const_part);
+ bc_emit ((char *) &i, 4);
+ }
+ else
+ {
+ int i = TREE_INT_CST_LOW (const_part);
+ bc_emit ((char *) &i, 4);
+ i = TREE_INT_CST_HIGH (const_part);
+ bc_emit ((char *) &i, 4);
+ }
+ size -= 8;
+ }
+ }
+ else
+ if (size == 4
+ && TREE_CODE (TREE_OPERAND (addr_part, 0)) == VAR_DECL)
+ bc_emit_labelref (DECL_ASSEMBLER_NAME (TREE_OPERAND (addr_part, 0)),
+ TREE_INT_CST_LOW (const_part));
+ else
+ abort (); /* FIXME: there may be more cases. */
+}
\f
/* Subroutine of output_constant, used for CONSTRUCTORs
(aggregate constants).
Generate at least SIZE bytes, padding if necessary. */
-void
+static void
output_constructor (exp, size)
tree exp;
int size;
{
register tree link, field = 0;
+ HOST_WIDE_INT min_index = 0;
/* Number of bytes output or skipped so far.
In other words, current position within the constructor. */
int total_bytes = 0;
if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
field = TYPE_FIELDS (TREE_TYPE (exp));
+ if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE
+ && TYPE_DOMAIN (TREE_TYPE (exp)) != 0)
+ min_index
+ = TREE_INT_CST_LOW (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (exp))));
+
/* As LINK goes through the elements of the constant,
FIELD goes through the structure fields, if the constant is a structure.
if the constant is a union, then we override this,
field = field ? TREE_CHAIN (field) : 0)
{
tree val = TREE_VALUE (link);
+ tree index = 0;
+
/* the element in a union constructor specifies the proper field. */
- if (TREE_PURPOSE (link) != 0)
- field = TREE_PURPOSE (link);
+
+ if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE
+ || TREE_CODE (TREE_TYPE (exp)) == UNION_TYPE)
+ {
+ /* if available, use the type given by link */
+ if (TREE_PURPOSE (link) != 0)
+ field = TREE_PURPOSE (link);
+ }
+
+ if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
+ index = TREE_PURPOSE (link);
/* Eliminate the marker that makes a cast not be an lvalue. */
if (val != 0)
if (field == 0 || !DECL_BIT_FIELD (field))
{
+ /* An element that is not a bit-field. */
+
register int fieldsize;
/* Since this structure is static,
we know the positions are constant. */
int bitpos = (field ? (TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field))
/ BITS_PER_UNIT)
: 0);
+ if (index != 0)
+ bitpos = (TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (val)))
+ / BITS_PER_UNIT
+ * (TREE_INT_CST_LOW (index) - min_index));
- /* An element that is not a bit-field.
- Output any buffered-up bit-fields preceding it. */
+ /* Output any buffered-up bit-fields preceding this element. */
if (byte_buffer_in_use)
{
ASM_OUTPUT_BYTE (asm_out_file, byte);
/* 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 && bitpos != total_bytes)
+ if ((field != 0 || index != 0) && bitpos != total_bytes)
{
- assemble_zeros (bitpos - total_bytes);
+ if (!output_bytecode)
+ assemble_zeros (bitpos - total_bytes);
+ else
+ bc_emit_const_skip (bitpos - total_bytes);
total_bytes = bitpos;
}
while (next_offset < end_offset)
{
int this_time;
- int shift, value;
+ int shift;
+ HOST_WIDE_INT value;
int next_byte = next_offset / BITS_PER_UNIT;
int next_bit = next_offset % BITS_PER_UNIT;
(all part of the same byte). */
this_time = MIN (end_offset - next_offset,
BITS_PER_UNIT - next_bit);
-#if 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. */
- shift = end_offset - next_offset - this_time;
- /* Don't try to take a bunch of bits that cross
- the word boundary in the INTEGER_CST. */
- if (shift < HOST_BITS_PER_WIDE_INT
- && shift + this_time > HOST_BITS_PER_WIDE_INT)
- {
- this_time -= (HOST_BITS_PER_WIDE_INT - shift);
- shift = HOST_BITS_PER_WIDE_INT;
- }
-
- /* Now get the bits from the appropriate constant word. */
- if (shift < HOST_BITS_PER_WIDE_INT)
+ if (BYTES_BIG_ENDIAN)
{
- value = TREE_INT_CST_LOW (val);
- }
- else if (shift < 2 * HOST_BITS_PER_WIDE_INT)
- {
- value = TREE_INT_CST_HIGH (val);
- shift -= HOST_BITS_PER_WIDE_INT;
+ /* 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. */
+ shift = end_offset - next_offset - this_time;
+ /* Don't try to take a bunch of bits that cross
+ the word boundary in the INTEGER_CST. */
+ if (shift < HOST_BITS_PER_WIDE_INT
+ && shift + this_time > HOST_BITS_PER_WIDE_INT)
+ {
+ this_time -= (HOST_BITS_PER_WIDE_INT - shift);
+ shift = HOST_BITS_PER_WIDE_INT;
+ }
+
+ /* Now get the bits from the appropriate constant word. */
+ if (shift < HOST_BITS_PER_WIDE_INT)
+ {
+ value = TREE_INT_CST_LOW (val);
+ }
+ else if (shift < 2 * HOST_BITS_PER_WIDE_INT)
+ {
+ value = TREE_INT_CST_HIGH (val);
+ shift -= HOST_BITS_PER_WIDE_INT;
+ }
+ else
+ abort ();
+ byte |= (((value >> shift)
+ & (((HOST_WIDE_INT) 1 << this_time) - 1))
+ << (BITS_PER_UNIT - this_time - next_bit));
}
else
- abort ();
- byte |= (((value >> shift)
- & (((HOST_WIDE_INT) 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. */
- shift = (next_offset
- - TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field)));
- /* Don't try to take a bunch of bits that cross
- the word boundary in the INTEGER_CST. */
- if (shift < HOST_BITS_PER_WIDE_INT
- && shift + this_time > HOST_BITS_PER_WIDE_INT)
{
- this_time -= (HOST_BITS_PER_WIDE_INT - shift);
- shift = HOST_BITS_PER_WIDE_INT;
+ /* 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. */
+ shift = (next_offset
+ - TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field)));
+ /* Don't try to take a bunch of bits that cross
+ the word boundary in the INTEGER_CST. */
+ if (shift < HOST_BITS_PER_WIDE_INT
+ && shift + this_time > HOST_BITS_PER_WIDE_INT)
+ {
+ this_time -= (HOST_BITS_PER_WIDE_INT - shift);
+ shift = HOST_BITS_PER_WIDE_INT;
+ }
+
+ /* Now get the bits from the appropriate constant word. */
+ if (shift < HOST_BITS_PER_INT)
+ value = TREE_INT_CST_LOW (val);
+ else if (shift < 2 * HOST_BITS_PER_WIDE_INT)
+ {
+ value = TREE_INT_CST_HIGH (val);
+ shift -= HOST_BITS_PER_WIDE_INT;
+ }
+ else
+ abort ();
+ byte |= (((value >> shift)
+ & (((HOST_WIDE_INT) 1 << this_time) - 1))
+ << next_bit);
}
-
- /* Now get the bits from the appropriate constant word. */
- if (shift < HOST_BITS_PER_INT)
- value = TREE_INT_CST_LOW (val);
- else if (shift < 2 * HOST_BITS_PER_WIDE_INT)
- {
- value = TREE_INT_CST_HIGH (val);
- shift -= HOST_BITS_PER_WIDE_INT;
- }
- else
- abort ();
- byte |= ((value >> shift)
- & (((HOST_WIDE_INT) 1 << this_time) - 1)) << next_bit;
-#endif
next_offset += this_time;
byte_buffer_in_use = 1;
}
if (total_bytes < size)
assemble_zeros (size - total_bytes);
}
+
+
+#ifdef HANDLE_SYSV_PRAGMA
+
+/* Support #pragma weak by default if WEAK_ASM_OP and ASM_OUTPUT_DEF
+ are defined. */
+#if defined (WEAK_ASM_OP) && defined (ASM_OUTPUT_DEF)
+
+/* See c-pragma.c for an identical definition. */
+enum pragma_state
+{
+ ps_start,
+ ps_done,
+ ps_bad,
+ ps_weak,
+ ps_name,
+ ps_equals,
+ ps_value,
+ ps_pack,
+ ps_left,
+ ps_align,
+ ps_right
+};
+
+/* Output asm to handle ``#pragma weak'' */
+void
+handle_pragma_weak (what, asm_out_file, name, value)
+ enum pragma_state what;
+ FILE *asm_out_file;
+ char *name, *value;
+{
+ if (what == ps_name || what == ps_value)
+ {
+ fprintf (asm_out_file, "\t%s\t", WEAK_ASM_OP);
+
+ if (output_bytecode)
+ BC_OUTPUT_LABELREF (asm_out_file, name);
+ else
+ ASM_OUTPUT_LABELREF (asm_out_file, name);
+
+ fputc ('\n', asm_out_file);
+ if (what == ps_value)
+ ASM_OUTPUT_DEF (asm_out_file, name, value);
+ }
+ else if (! (what == ps_done || what == ps_start))
+ warning ("malformed `#pragma weak'");
+}
+
+#endif /* HANDLE_PRAGMA_WEAK or (WEAK_ASM_OP and SET_ASM_OP) */
+
+#endif /* WEAK_ASM_OP && ASM_OUTPUT_DEF */
OSDN Git Service
