Commit 229a2e65 by Mark Mitchell Committed by Mark Mitchell

c-typeck.c (check_init_type_bitfields): Remove.

	* c-typeck.c (check_init_type_bitfields): Remove.
	(constructor_incremental): Likewise.
	(struct constructor_stack): Remove incremental bit.
	(struct initializer_stack): Likewise.
	(start_init): Don't play with constructor_incremental.
	(finish_init): Likewise.
	(really_start_incremental_init): Likewise.
	(push_init_level): Likewise.
	(pop_init_level): Likewise.
	(output_init_level): Likewise.
	(output_pending_init_elements): Likewise.

From-SVN: r37096
parent 63eb1269
2000-10-27 Mark Mitchell <mark@codesourcery.com>
* c-typeck.c (check_init_type_bitfields): Remove.
(constructor_incremental): Likewise.
(struct constructor_stack): Remove incremental bit.
(struct initializer_stack): Likewise.
(start_init): Don't play with constructor_incremental.
(finish_init): Likewise.
(really_start_incremental_init): Likewise.
(push_init_level): Likewise.
(pop_init_level): Likewise.
(output_init_level): Likewise.
(output_pending_init_elements): Likewise.
2000-10-21 Mike Coleman <mcoleman2@kc.rr.com> 2000-10-21 Mike Coleman <mcoleman2@kc.rr.com>
* c-pragma.c (handle_pragma_pack): Initialize align to -1. * c-pragma.c (handle_pragma_pack): Initialize align to -1.
......
...@@ -74,7 +74,6 @@ static int spelling_length PARAMS ((void)); ...@@ -74,7 +74,6 @@ static int spelling_length PARAMS ((void));
static char *print_spelling PARAMS ((char *)); static char *print_spelling PARAMS ((char *));
static void warning_init PARAMS ((const char *)); static void warning_init PARAMS ((const char *));
static tree digest_init PARAMS ((tree, tree, int, int)); static tree digest_init PARAMS ((tree, tree, int, int));
static void check_init_type_bitfields PARAMS ((tree));
static void output_init_element PARAMS ((tree, tree, tree, int)); static void output_init_element PARAMS ((tree, tree, tree, int));
static void output_pending_init_elements PARAMS ((int)); static void output_pending_init_elements PARAMS ((int));
static void add_pending_init PARAMS ((tree, tree)); static void add_pending_init PARAMS ((tree, tree));
...@@ -4900,10 +4899,6 @@ int constructor_no_implicit = 0; /* 0 for C; 1 for some other languages. */ ...@@ -4900,10 +4899,6 @@ int constructor_no_implicit = 0; /* 0 for C; 1 for some other languages. */
static int require_constant_value; static int require_constant_value;
static int require_constant_elements; static int require_constant_elements;
/* 1 if it is ok to output this constructor as we read it.
0 means must accumulate a CONSTRUCTOR expression. */
static int constructor_incremental;
/* DECL node for which an initializer is being read. /* DECL node for which an initializer is being read.
0 means we are reading a constructor expression 0 means we are reading a constructor expression
such as (struct foo) {...}. */ such as (struct foo) {...}. */
...@@ -4941,7 +4936,6 @@ struct constructor_stack ...@@ -4941,7 +4936,6 @@ struct constructor_stack
char constant; char constant;
char simple; char simple;
char implicit; char implicit;
char incremental;
char erroneous; char erroneous;
char outer; char outer;
}; };
...@@ -4963,7 +4957,6 @@ struct initializer_stack ...@@ -4963,7 +4957,6 @@ struct initializer_stack
struct spelling *spelling_base; struct spelling *spelling_base;
int spelling_size; int spelling_size;
char top_level; char top_level;
char incremental;
char require_constant_value; char require_constant_value;
char require_constant_elements; char require_constant_elements;
char deferred; char deferred;
...@@ -4989,7 +4982,6 @@ start_init (decl, asmspec_tree, top_level) ...@@ -4989,7 +4982,6 @@ start_init (decl, asmspec_tree, top_level)
p->decl = constructor_decl; p->decl = constructor_decl;
p->asmspec = constructor_asmspec; p->asmspec = constructor_asmspec;
p->incremental = constructor_incremental;
p->require_constant_value = require_constant_value; p->require_constant_value = require_constant_value;
p->require_constant_elements = require_constant_elements; p->require_constant_elements = require_constant_elements;
p->constructor_stack = constructor_stack; p->constructor_stack = constructor_stack;
...@@ -5003,7 +4995,6 @@ start_init (decl, asmspec_tree, top_level) ...@@ -5003,7 +4995,6 @@ start_init (decl, asmspec_tree, top_level)
initializer_stack = p; initializer_stack = p;
constructor_decl = decl; constructor_decl = decl;
constructor_incremental = top_level;
constructor_asmspec = asmspec; constructor_asmspec = asmspec;
constructor_subconstants_deferred = 0; constructor_subconstants_deferred = 0;
constructor_top_level = top_level; constructor_top_level = top_level;
...@@ -5020,8 +5011,6 @@ start_init (decl, asmspec_tree, top_level) ...@@ -5020,8 +5011,6 @@ start_init (decl, asmspec_tree, top_level)
|| TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
|| TREE_CODE (TREE_TYPE (decl)) == QUAL_UNION_TYPE)); || TREE_CODE (TREE_TYPE (decl)) == QUAL_UNION_TYPE));
locus = IDENTIFIER_POINTER (DECL_NAME (decl)); locus = IDENTIFIER_POINTER (DECL_NAME (decl));
constructor_incremental
|= (TREE_STATIC (decl) && !DECL_CONTEXT (decl));
} }
else else
{ {
...@@ -5064,7 +5053,6 @@ finish_init () ...@@ -5064,7 +5053,6 @@ finish_init ()
/* Pop back to the data of the outer initializer (if any). */ /* Pop back to the data of the outer initializer (if any). */
constructor_decl = p->decl; constructor_decl = p->decl;
constructor_asmspec = p->asmspec; constructor_asmspec = p->asmspec;
constructor_incremental = p->incremental;
require_constant_value = p->require_constant_value; require_constant_value = p->require_constant_value;
require_constant_elements = p->require_constant_elements; require_constant_elements = p->require_constant_elements;
constructor_stack = p->constructor_stack; constructor_stack = p->constructor_stack;
...@@ -5095,11 +5083,6 @@ really_start_incremental_init (type) ...@@ -5095,11 +5083,6 @@ really_start_incremental_init (type)
if (type == 0) if (type == 0)
type = TREE_TYPE (constructor_decl); type = TREE_TYPE (constructor_decl);
/* Turn off constructor_incremental if type is a struct with bitfields.
Do this before the first push, so that the corrected value
is available in finish_init. */
check_init_type_bitfields (type);
p->type = constructor_type; p->type = constructor_type;
p->fields = constructor_fields; p->fields = constructor_fields;
p->index = constructor_index; p->index = constructor_index;
...@@ -5116,7 +5099,6 @@ really_start_incremental_init (type) ...@@ -5116,7 +5099,6 @@ really_start_incremental_init (type)
p->depth = constructor_depth; p->depth = constructor_depth;
p->replacement_value = 0; p->replacement_value = 0;
p->implicit = 0; p->implicit = 0;
p->incremental = constructor_incremental;
p->outer = 0; p->outer = 0;
p->next = 0; p->next = 0;
constructor_stack = p; constructor_stack = p;
...@@ -5162,16 +5144,6 @@ really_start_incremental_init (type) ...@@ -5162,16 +5144,6 @@ really_start_incremental_init (type)
constructor_fields = constructor_type; constructor_fields = constructor_type;
constructor_unfilled_fields = constructor_type; constructor_unfilled_fields = constructor_type;
} }
if (constructor_incremental)
{
make_decl_rtl (constructor_decl, constructor_asmspec,
constructor_top_level);
assemble_variable (constructor_decl, constructor_top_level, 0, 1);
defer_addressed_constants ();
constructor_subconstants_deferred = 1;
}
} }
/* Push down into a subobject, for initialization. /* Push down into a subobject, for initialization.
...@@ -5200,30 +5172,6 @@ push_init_level (implicit) ...@@ -5200,30 +5172,6 @@ push_init_level (implicit)
break; break;
} }
/* Structure elements may require alignment. Do this now if necessary
for the subaggregate, and if it comes next in sequence. Don't do
this for subaggregates that will go on the pending list. */
if (constructor_incremental && constructor_type != 0
&& TREE_CODE (constructor_type) == RECORD_TYPE && constructor_fields
&& constructor_fields == constructor_unfilled_fields)
{
/* Advance to offset of this element. */
if (! tree_int_cst_equal (constructor_bit_index,
bit_position (constructor_fields)))
assemble_zeros
(tree_low_cst
(size_binop (TRUNC_DIV_EXPR,
size_binop (MINUS_EXPR,
bit_position (constructor_fields),
constructor_bit_index),
bitsize_unit_node),
1));
/* Indicate that we have now filled the structure up to the current
field. */
constructor_unfilled_fields = constructor_fields;
}
p = (struct constructor_stack *) xmalloc (sizeof (struct constructor_stack)); p = (struct constructor_stack *) xmalloc (sizeof (struct constructor_stack));
p->type = constructor_type; p->type = constructor_type;
p->fields = constructor_fields; p->fields = constructor_fields;
...@@ -5241,7 +5189,6 @@ push_init_level (implicit) ...@@ -5241,7 +5189,6 @@ push_init_level (implicit)
p->depth = constructor_depth; p->depth = constructor_depth;
p->replacement_value = 0; p->replacement_value = 0;
p->implicit = implicit; p->implicit = implicit;
p->incremental = constructor_incremental;
p->outer = 0; p->outer = 0;
p->next = constructor_stack; p->next = constructor_stack;
constructor_stack = p; constructor_stack = p;
...@@ -5267,8 +5214,6 @@ push_init_level (implicit) ...@@ -5267,8 +5214,6 @@ push_init_level (implicit)
constructor_type = TREE_TYPE (constructor_fields); constructor_type = TREE_TYPE (constructor_fields);
push_member_name (constructor_fields); push_member_name (constructor_fields);
constructor_depth++; constructor_depth++;
if (constructor_fields != constructor_unfilled_fields)
constructor_incremental = 0;
} }
} }
else if (TREE_CODE (constructor_type) == ARRAY_TYPE) else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
...@@ -5276,9 +5221,6 @@ push_init_level (implicit) ...@@ -5276,9 +5221,6 @@ push_init_level (implicit)
constructor_type = TREE_TYPE (constructor_type); constructor_type = TREE_TYPE (constructor_type);
push_array_bounds (tree_low_cst (constructor_index, 0)); push_array_bounds (tree_low_cst (constructor_index, 0));
constructor_depth++; constructor_depth++;
if (! tree_int_cst_equal (constructor_index, constructor_unfilled_index)
|| constructor_range_end != 0)
constructor_incremental = 0;
} }
if (constructor_type == 0) if (constructor_type == 0)
...@@ -5289,9 +5231,6 @@ push_init_level (implicit) ...@@ -5289,9 +5231,6 @@ push_init_level (implicit)
return; return;
} }
/* Turn off constructor_incremental if type is a struct with bitfields. */
check_init_type_bitfields (constructor_type);
if (implicit && warn_missing_braces && !missing_braces_mentioned) if (implicit && warn_missing_braces && !missing_braces_mentioned)
{ {
missing_braces_mentioned = 1; missing_braces_mentioned = 1;
...@@ -5335,45 +5274,6 @@ push_init_level (implicit) ...@@ -5335,45 +5274,6 @@ push_init_level (implicit)
} }
} }
/* Don't read a struct incrementally if it has any bitfields,
because the incremental reading code doesn't know how to
handle bitfields yet. */
static void
check_init_type_bitfields (type)
tree type;
{
if (TREE_CODE (type) == RECORD_TYPE)
{
tree tail;
for (tail = TYPE_FIELDS (type); tail;
tail = TREE_CHAIN (tail))
{
if (DECL_C_BIT_FIELD (tail))
{
constructor_incremental = 0;
break;
}
check_init_type_bitfields (TREE_TYPE (tail));
}
}
else if (TREE_CODE (type) == UNION_TYPE)
{
tree tail = TYPE_FIELDS (type);
if (tail && DECL_C_BIT_FIELD (tail))
/* We also use the nonincremental algorithm for initiliazation
of unions whose first member is a bitfield, becuase the
incremental algorithm has no code for dealing with
bitfields. */
constructor_incremental = 0;
}
else if (TREE_CODE (type) == ARRAY_TYPE)
check_init_type_bitfields (TREE_TYPE (type));
}
/* At the end of an implicit or explicit brace level, /* At the end of an implicit or explicit brace level,
finish up that level of constructor. finish up that level of constructor.
If we were outputting the elements as they are read, return 0 If we were outputting the elements as they are read, return 0
...@@ -5429,45 +5329,14 @@ pop_init_level (implicit) ...@@ -5429,45 +5329,14 @@ pop_init_level (implicit)
/* Pad out the end of the structure. */ /* Pad out the end of the structure. */
if (p->replacement_value) if (p->replacement_value)
{ /* If this closes a superfluous brace pair,
/* If this closes a superfluous brace pair, just pass out the element between them. */
just pass out the element between them. */ constructor = p->replacement_value;
constructor = p->replacement_value;
/* If this is the top level thing within the initializer,
and it's for a variable, then since we already called
assemble_variable, we must output the value now. */
if (p->next == 0 && constructor_decl != 0
&& constructor_incremental)
{
constructor = digest_init (constructor_type, constructor,
require_constant_value,
require_constant_elements);
/* If initializing an array of unknown size,
determine the size now. */
if (TREE_CODE (constructor_type) == ARRAY_TYPE
&& TYPE_DOMAIN (constructor_type) == 0)
{
/* We shouldn't have an incomplete array type within
some other type. */
if (constructor_stack->next)
abort ();
if (complete_array_type (constructor_type, constructor, 0))
abort ();
size = int_size_in_bytes (constructor_type);
}
output_constant (constructor, size);
}
}
else if (constructor_type == 0) else if (constructor_type == 0)
; ;
else if (TREE_CODE (constructor_type) != RECORD_TYPE else if (TREE_CODE (constructor_type) != RECORD_TYPE
&& TREE_CODE (constructor_type) != UNION_TYPE && TREE_CODE (constructor_type) != UNION_TYPE
&& TREE_CODE (constructor_type) != ARRAY_TYPE && TREE_CODE (constructor_type) != ARRAY_TYPE)
&& ! constructor_incremental)
{ {
/* A nonincremental scalar initializer--just return /* A nonincremental scalar initializer--just return
the element, after verifying there is just one. */ the element, after verifying there is just one. */
...@@ -5484,7 +5353,7 @@ pop_init_level (implicit) ...@@ -5484,7 +5353,7 @@ pop_init_level (implicit)
else else
constructor = TREE_VALUE (constructor_elements); constructor = TREE_VALUE (constructor_elements);
} }
else if (! constructor_incremental) else
{ {
if (constructor_erroneous) if (constructor_erroneous)
constructor = error_mark_node; constructor = error_mark_node;
...@@ -5498,58 +5367,7 @@ pop_init_level (implicit) ...@@ -5498,58 +5367,7 @@ pop_init_level (implicit)
TREE_STATIC (constructor) = 1; TREE_STATIC (constructor) = 1;
} }
} }
else
{
tree filled;
if (TREE_CODE (constructor_type) == RECORD_TYPE
|| TREE_CODE (constructor_type) == UNION_TYPE)
/* Find the offset of the end of that field. */
filled = size_binop (CEIL_DIV_EXPR, constructor_bit_index,
bitsize_unit_node);
else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
{
/* If initializing an array of unknown size,
determine the size now. */
if (TREE_CODE (constructor_type) == ARRAY_TYPE
&& TYPE_DOMAIN (constructor_type) == 0)
{
tree maxindex
= copy_node (size_diffop (constructor_unfilled_index,
bitsize_one_node));
TYPE_DOMAIN (constructor_type) = build_index_type (maxindex);
TREE_TYPE (maxindex) = TYPE_DOMAIN (constructor_type);
/* TYPE_MAX_VALUE is always one less than the number of elements
in the array, because we start counting at zero. Therefore,
warn only if the value is less than zero. */
if (pedantic
&& (tree_int_cst_sgn
(TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type)))
< 0))
error_with_decl (constructor_decl,
"zero or negative array size `%s'");
layout_type (constructor_type);
size = int_size_in_bytes (constructor_type);
}
filled
= size_binop (MULT_EXPR, constructor_unfilled_index,
convert (bitsizetype,
TYPE_SIZE_UNIT
(TREE_TYPE (constructor_type))));
}
else
filled = 0;
if (filled != 0)
assemble_zeros (size - tree_low_cst (filled, 1));
}
constructor_type = p->type; constructor_type = p->type;
constructor_fields = p->fields; constructor_fields = p->fields;
constructor_index = p->index; constructor_index = p->index;
...@@ -5564,7 +5382,6 @@ pop_init_level (implicit) ...@@ -5564,7 +5382,6 @@ pop_init_level (implicit)
constructor_erroneous = p->erroneous; constructor_erroneous = p->erroneous;
constructor_pending_elts = p->pending_elts; constructor_pending_elts = p->pending_elts;
constructor_depth = p->depth; constructor_depth = p->depth;
constructor_incremental = p->incremental;
RESTORE_SPELLING_DEPTH (constructor_depth); RESTORE_SPELLING_DEPTH (constructor_depth);
constructor_stack = p->next; constructor_stack = p->next;
...@@ -6002,45 +5819,13 @@ output_init_element (value, type, field, pending) ...@@ -6002,45 +5819,13 @@ output_init_element (value, type, field, pending)
if (!duplicate) if (!duplicate)
{ {
if (! constructor_incremental) if (field && TREE_CODE (field) == INTEGER_CST)
{ field = copy_node (field);
if (field && TREE_CODE (field) == INTEGER_CST) constructor_elements
field = copy_node (field); = tree_cons (field, digest_init (type, value,
constructor_elements require_constant_value,
= tree_cons (field, digest_init (type, value, require_constant_elements),
require_constant_value, constructor_elements);
require_constant_elements),
constructor_elements);
}
else
{
/* Structure elements may require alignment.
Do this, if necessary. */
if (TREE_CODE (constructor_type) == RECORD_TYPE
&& ! tree_int_cst_equal (constructor_bit_index,
bit_position (field)))
/* Advance to offset of this element. */
assemble_zeros
(tree_low_cst
(size_binop (TRUNC_DIV_EXPR,
size_binop (MINUS_EXPR, bit_position (field),
constructor_bit_index),
bitsize_unit_node),
0));
output_constant (digest_init (type, value,
require_constant_value,
require_constant_elements),
int_size_in_bytes (type));
/* For a record or union,
keep track of end position of last field. */
if (TREE_CODE (constructor_type) == RECORD_TYPE
|| TREE_CODE (constructor_type) == UNION_TYPE)
constructor_bit_index
= size_binop (PLUS_EXPR, bit_position (field),
DECL_SIZE (field));
}
} }
/* Advance the variable that indicates sequential elements output. */ /* Advance the variable that indicates sequential elements output. */
...@@ -6196,66 +5981,13 @@ output_pending_init_elements (all) ...@@ -6196,66 +5981,13 @@ output_pending_init_elements (all)
if (! (all && next != 0)) if (! (all && next != 0))
return; return;
/* Generate space up to the position of NEXT. */ /* If it's not incremental, just skip over the gap, so that after
if (constructor_incremental) jumping to retry we will output the next successive element. */
{ if (TREE_CODE (constructor_type) == RECORD_TYPE
tree filled; || TREE_CODE (constructor_type) == UNION_TYPE)
tree nextpos_tree = bitsize_zero_node; constructor_unfilled_fields = next;
else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
if (TREE_CODE (constructor_type) == RECORD_TYPE constructor_unfilled_index = next;
|| TREE_CODE (constructor_type) == UNION_TYPE)
{
tree tail;
/* Find the last field written out, if any. */
for (tail = TYPE_FIELDS (constructor_type); tail;
tail = TREE_CHAIN (tail))
if (TREE_CHAIN (tail) == constructor_unfilled_fields)
break;
if (tail)
/* Find the offset of the end of that field. */
filled = size_binop (CEIL_DIV_EXPR,
size_binop (PLUS_EXPR, bit_position (tail),
DECL_SIZE (tail)),
bitsize_unit_node);
else
filled = bitsize_zero_node;
nextpos_tree = convert (bitsizetype, byte_position (next));
constructor_bit_index = bit_position (next);
constructor_unfilled_fields = next;
}
else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
{
filled
= size_binop (MULT_EXPR, constructor_unfilled_index,
convert (bitsizetype,
TYPE_SIZE_UNIT
(TREE_TYPE (constructor_type))));
nextpos_tree
= size_binop (MULT_EXPR, next,
convert (bitsizetype, TYPE_SIZE_UNIT
(TREE_TYPE (constructor_type))));
constructor_unfilled_index = next;
}
else
filled = 0;
if (filled)
assemble_zeros (tree_low_cst (size_diffop (nextpos_tree, filled), 1));
}
else
{
/* If it's not incremental, just skip over the gap,
so that after jumping to retry we will output the next
successive element. */
if (TREE_CODE (constructor_type) == RECORD_TYPE
|| TREE_CODE (constructor_type) == UNION_TYPE)
constructor_unfilled_fields = next;
else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
constructor_unfilled_index = next;
}
/* ELT now points to the node in the pending tree with the next /* ELT now points to the node in the pending tree with the next
initializer to output. */ initializer to output. */
...@@ -6268,13 +6000,7 @@ output_pending_init_elements (all) ...@@ -6268,13 +6000,7 @@ output_pending_init_elements (all)
to handle a partly-braced initializer. to handle a partly-braced initializer.
Once this has found the correct level for the new element, Once this has found the correct level for the new element,
it calls output_init_element. it calls output_init_element. */
Note: if we are incrementally outputting this constructor,
this function may be called with a null argument
representing a sub-constructor that was already incrementally output.
When that happens, we output nothing, but we do the bookkeeping
to skip past that element of the current constructor. */
void void
process_init_element (value) process_init_element (value)
......
2000-10-27 Mark Mitchell <mark@codesourcery.com>
* gcc.dg/noncompile/init-2.c: Tweak to deal with multiple errors
on the same line.
2000-10-27 Jakub Jelinek <jakub@redhat.com> 2000-10-27 Jakub Jelinek <jakub@redhat.com>
* g++.old-deja/g++.other/eh2.C: New test. * g++.old-deja/g++.other/eh2.C: New test.
......
int d[][] = { {1}, {2}, {3} }; /* { dg-error "incomplete type" } */ int d[][] = { {1}, {2}, {3} }; /* { dg-error "incomplete type|storage size|one element" } */
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment