/* Output variables, constants and external declarations, for GNU compiler.
- Copyright (C) 1987, 88, 89, 92, 93, 1994 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"
/* 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 ();
-static void output_constant_def_contents ();
-static int contains_pointers_p ();
-static void bc_output_ascii ();
-
-void output_constant_pool ();
-void assemble_name ();
-int output_addressed_constants ();
-void output_constant ();
-void output_constructor ();
-void output_byte_asm ();
-void text_section ();
-void readonly_data_section ();
-void data_section ();
-void named_section ();
-static void bc_assemble_integer ();
+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, in_named, EXTRA_SECTIONS} in_section
#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.
as the assembler symbol name.
TOP_LEVEL is nonzero if this is a file-scope variable.
This is never called for PARM_DECLs. */
-void
+
+static void
bc_make_decl_rtl (decl, asmspec, top_level)
tree decl;
char *asmspec;
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_INITIAL (decl) == NULL_TREE
+ && DECL_COMMON (decl)
+ && ! flag_no_common)
{
warning_with_decl (decl,
"section attribute ignored for uninitialized variable `%s'");
output_constant_pool (fnname, decl);
- if (IN_NAMED_SECTION (decl))
- named_section (decl, NULL);
- else
- text_section ();
+ function_section (decl);
/* Tell assembler to move to target machine's alignment for functions. */
align = floor_log2 (FUNCTION_BOUNDARY / BITS_PER_UNIT);
tree decl;
int top_level;
int at_end;
+ int dont_output_data;
{
register char *name;
int align;
TREE_ASM_WRITTEN (decl) = 1;
- /* If storage size is erroneously variable, just continue.
- Error message was already made. */
+ app_disable ();
- if (DECL_SIZE (decl))
+ if (! dont_output_data)
{
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,
- DECL_SIZE (decl), size_int (BITS_PER_UNIT));
+ DECL_SIZE (decl), size_int (BITS_PER_UNIT));
if (TREE_INT_CST_HIGH (size_tree) != 0)
{
{
if (DECL_INITIAL (decl))
/* Output the actual data. */
- output_constant (DECL_INITIAL (decl),
- int_size_in_bytes (TREE_TYPE (decl)));
+ output_constant (DECL_INITIAL (decl), TREE_INT_CST_LOW (size_tree));
else
/* Leave space for it. */
- assemble_zeros (int_size_in_bytes (TREE_TYPE (decl)));
+ assemble_zeros (TREE_INT_CST_LOW (size_tree));
}
finish:
/* Output text storage for constructor CONSTR. */
void
-bc_output_constructor (constr)
- tree constr;
+bc_output_constructor (constr, size)
+ tree constr;
+ int size;
{
int i;
text_section ();
/* Align */
- for (i = 0; TYPE_ALIGN (constr) >= BITS_PER_UNIT << (i + 1); i++);
+ 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, int_size_in_bytes (TREE_TYPE (constr)));
+ output_constant (constr, size);
}
-
/* Create storage for constructor CONSTR. */
void
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. */
/* 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;
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;
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);
+ }
- obstack_grow (&permanent_obstack, (char *) &zero, sizeof zero);
+ 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);
+ }
}
}
-
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. */
{
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:
- case ADDR_EXPR:
- /* For ADDR_EXPR, we do not want to copy the decl
- whose address is requested. */
return copy_node (exp);
case COMPLEX_CST:
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;
}
pool_offset = 0;
}
-/* Save and restore it for a nested function. */
+/* Save and restore status for a nested function. */
void
save_varasm_status (p)
/* Compute a hash code for a constant RTL expression. */
-int
+static int
const_hash_rtx (mode, x)
enum machine_mode mode;
rtx x;
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;
{
}
return reloc;
}
-
-
-/* Output assembler for byte constant */
-void
-output_byte_asm (byte)
- int byte;
-{
- if (output_bytecode)
- bc_emit_const ((char *) &byte, sizeof (char));
-#ifdef ASM_OUTPUT_BYTE
- else
- {
- ASM_OUTPUT_BYTE (asm_out_file, byte);
- }
-#endif
-}
\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.
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 or union types. */
+ 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))
- || TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE
- || TREE_CODE (TREE_TYPE (exp)) == UNION_TYPE
- || TREE_CODE (TREE_TYPE (exp)) == QUAL_UNION_TYPE))
+ || AGGREGATE_TYPE_P (TREE_TYPE (exp))))
|| TREE_CODE (exp) == NON_LVALUE_EXPR)
exp = TREE_OPERAND (exp, 0);
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;
(aggregate constants).
Generate at least SIZE bytes, padding if necessary. */
-void
+static void
output_constructor (exp, size)
tree exp;
int size;
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;
OSDN Git Service
