This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
[PATCH] C99 designated initializers (take 2)
- To: gcc-patches at gcc dot gnu dot org
- Subject: [PATCH] C99 designated initializers (take 2)
- From: Jakub Jelinek <jakub at redhat dot com>
- Date: Tue, 5 Dec 2000 22:43:06 +0100
- Reply-To: Jakub Jelinek <jakub at redhat dot com>
Hi!
This is updated patch for C99 designated initializers.
Unlike the first patch, with this one it is possible to override any
subobject initializers which have been initialized already as requested by
ISO C99. Also, range designators may appear anywhere in the designator list,
so one can do things like:
int a[][10][10] = { [0 ... 5][2 ... 6][1 ... 4] = 1, [2 ...6][4 ... 8][3 ... 7] = 3 };
etc. It required many more changes than I initially thought, because e.g.
when pushing implicitly into a subobject which has been already (partly)
initialized, we need to keep that initialization, not start from scratch
(but if we're pushing explicitely, we overwrite everything in the object).
Example:
struct { int x, y; } a[] = { [0].y = 1, [1] = 3, [0].x = 2 };
should be equivalent to { { 2, 1 }, { 3 } } while:
struct { int x, y; } a[] = { [0].y = 1, [1] = 3, [0] = { .x = 2 } };
needs to start from scratch and thus be equivalent to { { 2 }, { 3 } }
(at least that's my reading of the standard).
Particularly awful is:
struct { wchar_t s[4]; int t } x[] = { L"abc", 1, [0].s[1] = L'x' }
because unless I want special case STRING_CST everywhere, I had to split the
STRING_CST into a CONSTRUCTOR chain for such cases.
I think this patch should cover all the requirements for designated
initializers, there are some things which need some more work (see below)
but IMHO it should be done in steps, not everything in one huge patch.
Without this, gcc ICEs on half of the initializer constructs.
Can anyone please review this and tell me if it is ok to commit?
Bootstrapped on i386-redhat-linux, no regressions.
Things still to do (and I'd prefer to do them in some next step):
-W missing initializer warning needs changes, otherwise it will warn
about correct constructs like:
struct { int x, y; } x[] = { [0 ... 99].x = 1, [0 ... 99].y = 2 };
Likewise -Wall warning about missing explicit braces should probably not
apply to fields initialized by designator lists
The warning about loosing side-effects when some initializer is overwritten
with some other initial value (as suggested by Joseph) is printed in some
cases and not in others. E.g.
int x[] = { [0] = y++, [0] = 1 };
will print the warning while:
struct { int x, y; } x[] = { [0] = y++, [0] = { 1, 2 } };
will not (becase TREE_SIDE_EFFECTS is not propagated through the
CONSTRUCTOR trees upwards).
This should not be terribly hard to fix, assuming frontends will not
choke when seeing CONSTRUCTOR tree with TREE_SIDE_EFFECTS, but there is
another, more complicated issue:
int x[] = { [0 ... 3] = y++, [0] = 1, 2 };
currently prints the warning (and I think should not), but:
int x[] = { [0 ... 3] = y++, [0] = 1, 2, 3 };
should, but it is quite hard to differentiate between the two (the issue
is that range initializers put the side-effect value into SAVE_EXPR,
which will not happen at all only if all references to it disappear).
Ideas?
Another thing which could be done (invisible outside of compiler) is some
work on decreasing memory footprint:
As ggc_collect is not run during initialization processing, I think some
memory could be saved by using a cache of unused TREE_LIST nodes which
could be reused soon again (and register ggc mark function which would
simply discard that cache).
Currently, set_nonincremental_init and set_nonincremental_init_from_string
insert elements into AVL tree one by one, if AVL tree is empty (always
true for the second function), AVL tree could be used faster because the
chain (or string) is already sorted. Also, all AVL tree nodes could be
allocated at once using one xmalloc if it is freed during corresponding
pop_init_level, saving memory.
The copy_node call for array indexes should be moved from output_init_element
to its callers, so that index purpose trees are not copied over and over
during successive push_init_level/pop_init_level calls.
2000-12-05 Jakub Jelinek <jakub@redhat.com>
* c-typeck.c (constructor_range_end): Remove.
(constructor_incremental, designator_depth): New variables.
(struct constructor_stack): Remove range_end, add incremental.
(struct constructor_range_stack, constructor_range_stack): New.
(struct initializer_stack): Add constructor_range_stack.
(start_init, finish_init): Set it.
(really_start_incremental_init): Remove constructor_range_end, add
constructor_incremental.
(pop_init_level): Likewise.
(push_init_level): Likewise. If implicit and the subobject had some
value set already, preinitialize the level with it.
(set_designator, push_range_stack): New functions.
(set_init_index, set_init_label): Use them, remove
constructor_range_end.
(add_pending_init): Compare values of purpose index trees, not the
trees themselves. Allow overwriting of already initialized element.
Issue a warning if it had side-effects.
(set_nonincremental_init, set_nonincremental_init_from_string): New
functions.
(pending_init_member): Rename to...
(find_init_member): ...this function. Call set_nonincremental_init
if necessary. Compare values of purpose index trees, not the trees
themselves. Return the actual value, not just non-zero if something
is found.
(output_init_element): Remove checks for duplicates.
If field has zero size, only check the initializer for correctness.
Call set_nonincremental_init if necessary. Push RECORD/ARRAY into AVL
if constructor_incremental is zero.
(output_pending_init_elements): Compare bit positions, not
FIELD_DECLs to take into account zero-sized fields.
(process_init_element): Use constructor_range_stack to fill all
ranges in the designator lists from current level up.
* extend.texi: Update documentation for labeled elements.
* gcc.c-torture/execute/20000801-3.x: Remove.
* gcc.dg/c99-init-1.c: New test.
* gcc.dg/c99-init-2.c: New test.
* gcc.dg/c99-init-3.c: New test.
--- gcc/c-typeck.c.jj Fri Dec 1 13:55:39 2000
+++ gcc/c-typeck.c Tue Dec 5 17:04:10 2000
@@ -76,8 +76,12 @@ static void warning_init PARAMS ((const
static tree digest_init PARAMS ((tree, tree, int, int));
static void output_init_element PARAMS ((tree, tree, tree, int));
static void output_pending_init_elements PARAMS ((int));
+static int set_designator PARAMS ((int));
+static void push_range_stack PARAMS ((tree));
static void add_pending_init PARAMS ((tree, tree));
-static int pending_init_member PARAMS ((tree));
+static void set_nonincremental_init PARAMS ((void));
+static void set_nonincremental_init_from_string PARAMS ((tree));
+static tree find_init_member PARAMS ((tree));
/* Do `exp = require_complete_type (exp);' to make sure exp
does not have an incomplete type. (That includes void types.) */
@@ -4868,11 +4872,6 @@ static tree constructor_fields;
at which to store the next element we get. */
static tree constructor_index;
-/* For an ARRAY_TYPE, this is the end index of the range
- to initialize with the next element, or NULL in the ordinary case
- where the element is used just once. */
-static tree constructor_range_end;
-
/* For an ARRAY_TYPE, this is the maximum index. */
static tree constructor_max_index;
@@ -4892,6 +4891,10 @@ static tree constructor_bit_index;
most recent first). */
static tree constructor_elements;
+/* 1 if constructor should be incrementally stored into a constructor chain,
+ 0 if all the elements should be kept in AVL tree. */
+static int constructor_incremental;
+
/* 1 if so far this constructor's elements are all compile-time constants. */
static int constructor_constant;
@@ -4943,6 +4946,9 @@ static const char *constructor_asmspec;
/* Nonzero if this is an initializer for a top-level decl. */
static int constructor_top_level;
+/* Nesting depth of designator list. */
+static int designator_depth;
+
/* This stack has a level for each implicit or explicit level of
structuring in the initializer, including the outermost one. It
@@ -4954,7 +4960,6 @@ struct constructor_stack
tree type;
tree fields;
tree index;
- tree range_end;
tree max_index;
tree unfilled_index;
tree unfilled_fields;
@@ -4971,10 +4976,26 @@ struct constructor_stack
char implicit;
char erroneous;
char outer;
+ char incremental;
};
struct constructor_stack *constructor_stack;
+/* This stack represents designators from some range designator up to
+ the last designator in the list. */
+
+struct constructor_range_stack
+{
+ struct constructor_range_stack *next, *prev;
+ struct constructor_stack *stack;
+ tree range_start;
+ tree index;
+ tree range_end;
+ tree fields;
+};
+
+struct constructor_range_stack *constructor_range_stack;
+
/* This stack records separate initializers that are nested.
Nested initializers can't happen in ANSI C, but GNU C allows them
in cases like { ... (struct foo) { ... } ... }. */
@@ -4985,6 +5006,7 @@ struct initializer_stack
tree decl;
const char *asmspec;
struct constructor_stack *constructor_stack;
+ struct constructor_range_stack *constructor_range_stack;
tree elements;
struct spelling *spelling;
struct spelling *spelling_base;
@@ -5018,6 +5040,7 @@ start_init (decl, asmspec_tree, top_leve
p->require_constant_value = require_constant_value;
p->require_constant_elements = require_constant_elements;
p->constructor_stack = constructor_stack;
+ p->constructor_range_stack = constructor_range_stack;
p->elements = constructor_elements;
p->spelling = spelling;
p->spelling_base = spelling_base;
@@ -5053,6 +5076,7 @@ start_init (decl, asmspec_tree, top_leve
}
constructor_stack = 0;
+ constructor_range_stack = 0;
missing_braces_mentioned = 0;
@@ -5083,12 +5107,16 @@ finish_init ()
free (q);
}
+ if (constructor_range_stack)
+ abort ();
+
/* Pop back to the data of the outer initializer (if any). */
constructor_decl = p->decl;
constructor_asmspec = p->asmspec;
require_constant_value = p->require_constant_value;
require_constant_elements = p->require_constant_elements;
constructor_stack = p->constructor_stack;
+ constructor_range_stack = p->constructor_range_stack;
constructor_elements = p->elements;
spelling = p->spelling;
spelling_base = p->spelling_base;
@@ -5119,7 +5147,6 @@ really_start_incremental_init (type)
p->type = constructor_type;
p->fields = constructor_fields;
p->index = constructor_index;
- p->range_end = constructor_range_end;
p->max_index = constructor_max_index;
p->unfilled_index = constructor_unfilled_index;
p->unfilled_fields = constructor_unfilled_fields;
@@ -5133,6 +5160,7 @@ really_start_incremental_init (type)
p->replacement_value = 0;
p->implicit = 0;
p->outer = 0;
+ p->incremental = constructor_incremental;
p->next = 0;
constructor_stack = p;
@@ -5142,6 +5170,8 @@ really_start_incremental_init (type)
constructor_elements = 0;
constructor_pending_elts = 0;
constructor_type = type;
+ constructor_incremental = 1;
+ designator_depth = 0;
if (TREE_CODE (constructor_type) == RECORD_TYPE
|| TREE_CODE (constructor_type) == UNION_TYPE)
@@ -5157,7 +5187,6 @@ really_start_incremental_init (type)
}
else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
{
- constructor_range_end = 0;
if (TYPE_DOMAIN (constructor_type))
{
constructor_max_index
@@ -5189,6 +5218,7 @@ push_init_level (implicit)
int implicit;
{
struct constructor_stack *p;
+ tree value = NULL_TREE;
/* If we've exhausted any levels that didn't have braces,
pop them now. */
@@ -5205,11 +5235,22 @@ push_init_level (implicit)
break;
}
+ /* Unless this is an explicit brace, we need to preserve previous
+ content if any. */
+ if (implicit)
+ {
+ if ((TREE_CODE (constructor_type) == RECORD_TYPE
+ || TREE_CODE (constructor_type) == UNION_TYPE)
+ && constructor_fields)
+ value = find_init_member (constructor_fields);
+ else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
+ value = find_init_member (constructor_index);
+ }
+
p = (struct constructor_stack *) xmalloc (sizeof (struct constructor_stack));
p->type = constructor_type;
p->fields = constructor_fields;
p->index = constructor_index;
- p->range_end = constructor_range_end;
p->max_index = constructor_max_index;
p->unfilled_index = constructor_unfilled_index;
p->unfilled_fields = constructor_unfilled_fields;
@@ -5223,6 +5264,7 @@ push_init_level (implicit)
p->replacement_value = 0;
p->implicit = implicit;
p->outer = 0;
+ p->incremental = constructor_incremental;
p->next = constructor_stack;
constructor_stack = p;
@@ -5230,7 +5272,10 @@ push_init_level (implicit)
constructor_simple = 1;
constructor_depth = SPELLING_DEPTH ();
constructor_elements = 0;
+ constructor_incremental = 1;
constructor_pending_elts = 0;
+ if (!implicit)
+ designator_depth = 0;
/* Don't die if an entire brace-pair level is superfluous
in the containing level. */
@@ -5264,6 +5309,17 @@ push_init_level (implicit)
return;
}
+ if (value && TREE_CODE (value) == CONSTRUCTOR)
+ {
+ constructor_constant = TREE_CONSTANT (value);
+ constructor_simple = TREE_STATIC (value);
+ constructor_elements = TREE_OPERAND (value, 1);
+ if (constructor_elements
+ && (TREE_CODE (constructor_type) == RECORD_TYPE
+ || TREE_CODE (constructor_type) == ARRAY_TYPE))
+ set_nonincremental_init ();
+ }
+
if (implicit && warn_missing_braces && !missing_braces_mentioned)
{
missing_braces_mentioned = 1;
@@ -5284,7 +5340,6 @@ push_init_level (implicit)
}
else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
{
- constructor_range_end = 0;
if (TYPE_DOMAIN (constructor_type))
{
constructor_max_index
@@ -5308,6 +5363,13 @@ push_init_level (implicit)
constructor_index = bitsize_zero_node;
constructor_unfilled_index = constructor_index;
+ if (value && TREE_CODE (value) == STRING_CST)
+ {
+ /* We need to split the char/wchar array into individual
+ characters, so that we don't have to special case it
+ everywhere. */
+ set_nonincremental_init_from_string (value);
+ }
}
else
{
@@ -5358,6 +5420,7 @@ pop_init_level (implicit)
}
/* Now output all pending elements. */
+ constructor_incremental = 1;
output_pending_init_elements (1);
#if 0 /* c-parse.in warns about {}. */
@@ -5414,7 +5477,6 @@ pop_init_level (implicit)
constructor_type = p->type;
constructor_fields = p->fields;
constructor_index = p->index;
- constructor_range_end = p->range_end;
constructor_max_index = p->max_index;
constructor_unfilled_index = p->unfilled_index;
constructor_unfilled_fields = p->unfilled_fields;
@@ -5423,6 +5485,7 @@ pop_init_level (implicit)
constructor_constant = p->constant;
constructor_simple = p->simple;
constructor_erroneous = p->erroneous;
+ constructor_incremental = p->incremental;
constructor_pending_elts = p->pending_elts;
constructor_depth = p->depth;
RESTORE_SPELLING_DEPTH (constructor_depth);
@@ -5439,6 +5502,93 @@ pop_init_level (implicit)
return constructor;
}
+/* Common handling for both array range and field name designators.
+ ARRAY argument is non-zero for array ranges. Returns zero for success. */
+
+static int
+set_designator (array)
+ int array;
+{
+ tree subtype;
+ enum tree_code subcode;
+
+ /* Don't die if an entire brace-pair level is superfluous
+ in the containing level. */
+ if (constructor_type == 0)
+ return 1;
+
+ if (!designator_depth)
+ {
+ if (constructor_range_stack)
+ abort ();
+
+ /* Designator list starts at the level of closest explicit
+ braces. */
+ while (constructor_stack->implicit)
+ process_init_element (pop_init_level (1));
+ return 0;
+ }
+
+ if (constructor_no_implicit)
+ {
+ error_init ("initialization designators may not nest");
+ return 1;
+ }
+
+ if (TREE_CODE (constructor_type) == RECORD_TYPE
+ || TREE_CODE (constructor_type) == UNION_TYPE)
+ {
+ subtype = TREE_TYPE (constructor_fields);
+ if (subtype != error_mark_node)
+ subtype = TYPE_MAIN_VARIANT (subtype);
+ }
+ else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
+ {
+ subtype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
+ }
+ else
+ abort ();
+
+ subcode = TREE_CODE (subtype);
+ if (array && subcode != ARRAY_TYPE)
+ {
+ error_init ("array index in non-array initializer");
+ return 1;
+ }
+ else if (!array && subcode != RECORD_TYPE && subcode != UNION_TYPE)
+ {
+ error_init ("field name not in record or union initializer");
+ return 1;
+ }
+
+ push_init_level (1);
+ return 0;
+}
+
+/* If there are range designators in designator list, push a new designator
+ to constructor_range_stack. RANGE_END is end of such stack range or
+ NULL_TREE if there is no range designator at this level. */
+
+static void
+push_range_stack (range_end)
+ tree range_end;
+{
+ struct constructor_range_stack *p;
+
+ p = (struct constructor_range_stack *)
+ ggc_alloc (sizeof (struct constructor_range_stack));
+ p->prev = constructor_range_stack;
+ p->next = 0;
+ p->fields = constructor_fields;
+ p->range_start = constructor_index;
+ p->index = constructor_index;
+ p->stack = constructor_stack;
+ p->range_end = range_end;
+ if (constructor_range_stack)
+ constructor_range_stack->next = p;
+ constructor_range_stack = p;
+}
+
/* Within an array initializer, specify the next index to be initialized.
FIRST is that index. If LAST is nonzero, then initialize a range
of indices, running from FIRST through LAST. */
@@ -5447,6 +5597,9 @@ void
set_init_index (first, last)
tree first, last;
{
+ if (set_designator (1))
+ return;
+
while ((TREE_CODE (first) == NOP_EXPR
|| TREE_CODE (first) == CONVERT_EXPR
|| TREE_CODE (first) == NON_LVALUE_EXPR)
@@ -5466,18 +5619,30 @@ set_init_index (first, last)
error_init ("nonconstant array index in initializer");
else if (last != 0 && TREE_CODE (last) != INTEGER_CST)
error_init ("nonconstant array index in initializer");
- else if (! constructor_unfilled_index)
+ else if (TREE_CODE (constructor_type) != ARRAY_TYPE)
error_init ("array index in non-array initializer");
- else if (tree_int_cst_lt (first, constructor_unfilled_index))
- error_init ("duplicate array index in initializer");
else
{
constructor_index = convert (bitsizetype, first);
if (last != 0 && tree_int_cst_lt (last, first))
- error_init ("empty index range in initializer");
- else
- constructor_range_end = last ? convert (bitsizetype, last) : 0;
+ {
+ error_init ("empty index range in initializer");
+ last = 0;
+ }
+ else if (last)
+ {
+ last = convert (bitsizetype, last);
+ if (constructor_max_index != 0
+ && tree_int_cst_lt (constructor_max_index, last))
+ {
+ error_init ("array index range in initializer exceeds array bounds");
+ last = 0;
+ }
+ }
+ designator_depth++;
+ if (constructor_range_stack || last)
+ push_range_stack (last);
}
}
@@ -5488,18 +5653,20 @@ set_init_label (fieldname)
tree fieldname;
{
tree tail;
- int passed = 0;
- /* Don't die if an entire brace-pair level is superfluous
- in the containing level. */
- if (constructor_type == 0)
+ if (set_designator (0))
return;
+ if (TREE_CODE (constructor_type) != RECORD_TYPE
+ && TREE_CODE (constructor_type) != UNION_TYPE)
+ {
+ error_init ("field name not in record or union initializer");
+ return;
+ }
+
for (tail = TYPE_FIELDS (constructor_type); tail;
tail = TREE_CHAIN (tail))
{
- if (tail == constructor_unfilled_fields)
- passed = 1;
if (DECL_NAME (tail) == fieldname)
break;
}
@@ -5507,11 +5674,13 @@ set_init_label (fieldname)
if (tail == 0)
error ("unknown field `%s' specified in initializer",
IDENTIFIER_POINTER (fieldname));
- else if (!passed)
- error ("field `%s' already initialized",
- IDENTIFIER_POINTER (fieldname));
else
- constructor_fields = tail;
+ {
+ constructor_fields = tail;
+ designator_depth++;
+ if (constructor_range_stack)
+ push_range_stack (NULL_TREE);
+ }
}
/* Add a new initializer to the tree of pending initializers. PURPOSE
@@ -5534,24 +5703,36 @@ add_pending_init (purpose, value)
p = *q;
if (tree_int_cst_lt (purpose, p->purpose))
q = &p->left;
- else if (p->purpose != purpose)
+ else if (tree_int_cst_lt (p->purpose, purpose))
q = &p->right;
else
- abort ();
+ {
+ if (TREE_SIDE_EFFECTS (p->value))
+ warning_init ("initialized field with side-effects overwritten");
+ p->value = value;
+ return;
+ }
}
}
else
{
+ tree bitpos;
+
+ bitpos = bit_position (purpose);
while (*q != NULL)
{
p = *q;
- if (tree_int_cst_lt (bit_position (purpose),
- bit_position (p->purpose)))
+ if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
q = &p->left;
else if (p->purpose != purpose)
q = &p->right;
else
- abort ();
+ {
+ if (TREE_SIDE_EFFECTS (p->value))
+ warning_init ("initialized field with side-effects overwritten");
+ p->value = value;
+ return;
+ }
}
}
@@ -5720,41 +5901,178 @@ add_pending_init (purpose, value)
}
}
-/* Return nonzero if FIELD is equal to the index of a pending initializer. */
+/* Build AVL tree from a sorted chain. */
-static int
-pending_init_member (field)
+static void
+set_nonincremental_init ()
+{
+ tree chain;
+
+ if (TREE_CODE (constructor_type) != RECORD_TYPE
+ && TREE_CODE (constructor_type) != ARRAY_TYPE)
+ return;
+
+ for (chain = constructor_elements; chain; chain = TREE_CHAIN (chain))
+ add_pending_init (TREE_PURPOSE (chain), TREE_VALUE (chain));
+ constructor_elements = 0;
+ if (TREE_CODE (constructor_type) == RECORD_TYPE)
+ {
+ constructor_unfilled_fields = TYPE_FIELDS (constructor_type);
+ /* Skip any nameless bit fields at the beginning. */
+ while (constructor_unfilled_fields != 0
+ && DECL_C_BIT_FIELD (constructor_unfilled_fields)
+ && DECL_NAME (constructor_unfilled_fields) == 0)
+ constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);
+
+ }
+ else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
+ {
+ if (TYPE_DOMAIN (constructor_type))
+ constructor_unfilled_index
+ = convert (bitsizetype,
+ TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
+ else
+ constructor_unfilled_index = bitsize_zero_node;
+ }
+ constructor_incremental = 0;
+}
+
+/* Build AVL tree from a string constant. */
+
+static void
+set_nonincremental_init_from_string (str)
+ tree str;
+{
+ tree value, purpose, type;
+ HOST_WIDE_INT val[2];
+ const char *p, *end;
+ int byte, wchar_bytes, charwidth, bitpos;
+
+ if (TREE_CODE (constructor_type) != ARRAY_TYPE)
+ abort ();
+
+ if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str)))
+ == TYPE_PRECISION (char_type_node))
+ wchar_bytes = 1;
+ else if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str)))
+ == TYPE_PRECISION (wchar_type_node))
+ wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
+ else
+ abort ();
+
+ charwidth = TYPE_PRECISION (char_type_node);
+ type = TREE_TYPE (constructor_type);
+ p = TREE_STRING_POINTER (str);
+ end = p + TREE_STRING_LENGTH (str);
+
+ for (purpose = bitsize_zero_node;
+ p < end && !tree_int_cst_lt (constructor_max_index, purpose);
+ purpose = size_binop (PLUS_EXPR, purpose, bitsize_one_node))
+ {
+ if (wchar_bytes == 1)
+ {
+ val[1] = (unsigned char) *p++;
+ val[0] = 0;
+ }
+ else
+ {
+ val[0] = 0;
+ val[1] = 0;
+ for (byte = 0; byte < wchar_bytes; byte++)
+ {
+ if (BYTES_BIG_ENDIAN)
+ bitpos = (wchar_bytes - byte - 1) * charwidth;
+ else
+ bitpos = byte * charwidth;
+ val[bitpos < HOST_BITS_PER_WIDE_INT]
+ |= ((unsigned HOST_WIDE_INT) ((unsigned char) *p++))
+ << (bitpos % HOST_BITS_PER_WIDE_INT);
+ }
+ }
+
+ if (!TREE_UNSIGNED (type))
+ {
+ bitpos = ((wchar_bytes - 1) * charwidth) + HOST_BITS_PER_CHAR;
+ if (bitpos < HOST_BITS_PER_WIDE_INT)
+ {
+ if (val[1] & (((HOST_WIDE_INT) 1) << (bitpos - 1)))
+ {
+ val[1] |= ((HOST_WIDE_INT) -1) << bitpos;
+ val[0] = -1;
+ }
+ }
+ else if (bitpos == HOST_BITS_PER_WIDE_INT)
+ {
+ if (val[1] < 0)
+ val[0] = -1;
+ }
+ else if (val[0] & (((HOST_WIDE_INT) 1)
+ << (bitpos - 1 - HOST_BITS_PER_WIDE_INT)))
+ val[0] |= ((HOST_WIDE_INT) -1)
+ << (bitpos - HOST_BITS_PER_WIDE_INT);
+ }
+
+ value = build_int_2 (val[1], val[0]);
+ TREE_TYPE (value) = type;
+ add_pending_init (purpose, value);
+ }
+
+ constructor_incremental = 0;
+}
+
+/* Return value of FIELD in pending initializer or zero if the field was
+ not initialized yet. */
+
+static tree
+find_init_member (field)
tree field;
{
struct init_node *p;
- p = constructor_pending_elts;
if (TREE_CODE (constructor_type) == ARRAY_TYPE)
{
+ if (constructor_incremental
+ && tree_int_cst_lt (field, constructor_unfilled_index))
+ set_nonincremental_init ();
+
+ p = constructor_pending_elts;
while (p)
{
- if (field == p->purpose)
- return 1;
- else if (tree_int_cst_lt (field, p->purpose))
+ if (tree_int_cst_lt (field, p->purpose))
p = p->left;
- else
+ else if (tree_int_cst_lt (p->purpose, field))
p = p->right;
+ else
+ return p->value;
}
}
- else
+ else if (TREE_CODE (constructor_type) == RECORD_TYPE)
{
+ tree bitpos = bit_position (field);
+
+ if (constructor_incremental
+ && (!constructor_unfilled_fields
+ || tree_int_cst_lt (bitpos,
+ bit_position (constructor_unfilled_fields))))
+ set_nonincremental_init ();
+
+ p = constructor_pending_elts;
while (p)
{
if (field == p->purpose)
- return 1;
- else if (tree_int_cst_lt (bit_position (field),
- bit_position (p->purpose)))
+ return p->value;
+ else if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
p = p->left;
else
p = p->right;
}
}
-
+ else if (TREE_CODE (constructor_type) == UNION_TYPE)
+ {
+ if (constructor_elements
+ && TREE_PURPOSE (constructor_elements) == field)
+ return TREE_VALUE (constructor_elements);
+ }
return 0;
}
@@ -5773,8 +6091,6 @@ output_init_element (value, type, field,
tree value, type, field;
int pending;
{
- int duplicate = 0;
-
if (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE
|| (TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE
&& !(TREE_CODE (value) == STRING_CST
@@ -5807,85 +6123,95 @@ output_init_element (value, type, field,
value = error_mark_node;
}
- /* If this element duplicates one on constructor_pending_elts,
- print a message and ignore it. Don't do this when we're
- processing elements taken off constructor_pending_elts,
- because we'd always get spurious errors. */
- if (pending)
- {
- if (TREE_CODE (constructor_type) == RECORD_TYPE
- || TREE_CODE (constructor_type) == UNION_TYPE
- || TREE_CODE (constructor_type) == ARRAY_TYPE)
- {
- if (pending_init_member (field))
- {
- error_init ("duplicate initializer");
- duplicate = 1;
- }
- }
- }
+ /* If this field is empty, don't do anything other than checking the
+ initializer. */
+ if (field && (TREE_TYPE (field) == error_mark_node
+ || (COMPLETE_TYPE_P (TREE_TYPE (field))
+ && integer_zerop (TYPE_SIZE (TREE_TYPE (field))))))
+ return;
/* If this element doesn't come next in sequence,
put it on constructor_pending_elts. */
if (TREE_CODE (constructor_type) == ARRAY_TYPE
- && ! tree_int_cst_equal (field, constructor_unfilled_index))
+ && (!constructor_incremental
+ || !tree_int_cst_equal (field, constructor_unfilled_index)))
{
- if (! duplicate)
- add_pending_init (field,
- digest_init (type, value, require_constant_value,
- require_constant_elements));
+ if (constructor_incremental
+ && tree_int_cst_lt (field, constructor_unfilled_index))
+ set_nonincremental_init ();
+
+ add_pending_init (field,
+ digest_init (type, value, require_constant_value,
+ require_constant_elements));
+ return;
}
else if (TREE_CODE (constructor_type) == RECORD_TYPE
- && field != constructor_unfilled_fields)
+ && (!constructor_incremental
+ || field != constructor_unfilled_fields))
{
/* We do this for records but not for unions. In a union,
no matter which field is specified, it can be initialized
right away since it starts at the beginning of the union. */
- if (!duplicate)
- add_pending_init (field,
- digest_init (type, value, require_constant_value,
- require_constant_elements));
+ if (constructor_incremental)
+ {
+ tree bitpos, unfillpos;
+
+ bitpos = bit_position (field);
+ unfillpos = bit_position (constructor_unfilled_fields);
+
+ if (tree_int_cst_lt (bitpos, unfillpos))
+ set_nonincremental_init ();
+ }
+
+ add_pending_init (field,
+ digest_init (type, value, require_constant_value,
+ require_constant_elements));
+ return;
}
- else
+ else if (TREE_CODE (constructor_type) == UNION_TYPE
+ && constructor_elements)
{
- /* Otherwise, output this element either to
- constructor_elements or to the assembler file. */
+ if (TREE_SIDE_EFFECTS (TREE_VALUE (constructor_elements)))
+ warning_init ("initialized field with side-effects overwritten");
- if (!duplicate)
- {
- if (field && TREE_CODE (field) == INTEGER_CST)
- field = copy_node (field);
- constructor_elements
- = tree_cons (field, digest_init (type, value,
- require_constant_value,
- require_constant_elements),
- constructor_elements);
- }
+ /* We can have just one union field set. */
+ constructor_elements = 0;
+ }
- /* Advance the variable that indicates sequential elements output. */
- if (TREE_CODE (constructor_type) == ARRAY_TYPE)
- constructor_unfilled_index
- = size_binop (PLUS_EXPR, constructor_unfilled_index,
- bitsize_one_node);
- else if (TREE_CODE (constructor_type) == RECORD_TYPE)
- {
- constructor_unfilled_fields
- = TREE_CHAIN (constructor_unfilled_fields);
-
- /* Skip any nameless bit fields. */
- while (constructor_unfilled_fields != 0
- && DECL_C_BIT_FIELD (constructor_unfilled_fields)
- && DECL_NAME (constructor_unfilled_fields) == 0)
- constructor_unfilled_fields =
- TREE_CHAIN (constructor_unfilled_fields);
- }
- else if (TREE_CODE (constructor_type) == UNION_TYPE)
- constructor_unfilled_fields = 0;
+ /* Otherwise, output this element either to
+ constructor_elements or to the assembler file. */
- /* Now output any pending elements which have become next. */
- if (pending)
- output_pending_init_elements (0);
+ if (field && TREE_CODE (field) == INTEGER_CST)
+ field = copy_node (field);
+ constructor_elements
+ = tree_cons (field, digest_init (type, value,
+ require_constant_value,
+ require_constant_elements),
+ constructor_elements);
+
+ /* Advance the variable that indicates sequential elements output. */
+ if (TREE_CODE (constructor_type) == ARRAY_TYPE)
+ constructor_unfilled_index
+ = size_binop (PLUS_EXPR, constructor_unfilled_index,
+ bitsize_one_node);
+ else if (TREE_CODE (constructor_type) == RECORD_TYPE)
+ {
+ constructor_unfilled_fields
+ = TREE_CHAIN (constructor_unfilled_fields);
+
+ /* Skip any nameless bit fields. */
+ while (constructor_unfilled_fields != 0
+ && DECL_C_BIT_FIELD (constructor_unfilled_fields)
+ && DECL_NAME (constructor_unfilled_fields) == 0)
+ constructor_unfilled_fields =
+ TREE_CHAIN (constructor_unfilled_fields);
}
+ else if (TREE_CODE (constructor_type) == UNION_TYPE)
+ constructor_unfilled_fields = 0;
+
+ /* Now output any pending elements which have become next. */
+ if (pending)
+ output_pending_init_elements (0);
}
/* Output any pending elements which have become next.
@@ -5961,18 +6287,23 @@ output_pending_init_elements (all)
else if (TREE_CODE (constructor_type) == RECORD_TYPE
|| TREE_CODE (constructor_type) == UNION_TYPE)
{
+ tree ctor_unfilled_bitpos, elt_bitpos;
+
/* If the current record is complete we are done. */
if (constructor_unfilled_fields == 0)
break;
- if (elt->purpose == constructor_unfilled_fields)
- {
- output_init_element (elt->value,
- TREE_TYPE (constructor_unfilled_fields),
- constructor_unfilled_fields,
- 0);
+
+ ctor_unfilled_bitpos = bit_position (constructor_unfilled_fields);
+ elt_bitpos = bit_position (elt->purpose);
+ /* We can't compare fields here because there might be empty
+ fields in between. */
+ if (tree_int_cst_equal (elt_bitpos, ctor_unfilled_bitpos))
+ {
+ constructor_unfilled_fields = elt->purpose;
+ output_init_element (elt->value, TREE_TYPE (elt->purpose),
+ elt->purpose, 0);
}
- else if (tree_int_cst_lt (bit_position (constructor_unfilled_fields),
- bit_position (elt->purpose)))
+ else if (tree_int_cst_lt (ctor_unfilled_bitpos, elt_bitpos))
{
/* Advance to the next smaller node. */
if (elt->left)
@@ -5998,9 +6329,8 @@ output_pending_init_elements (all)
elt = elt->parent;
elt = elt->parent;
if (elt
- && (tree_int_cst_lt
- (bit_position (constructor_unfilled_fields),
- bit_position (elt->purpose))))
+ && (tree_int_cst_lt (ctor_unfilled_bitpos,
+ bit_position (elt->purpose))))
{
next = elt->purpose;
break;
@@ -6043,6 +6373,8 @@ process_init_element (value)
tree orig_value = value;
int string_flag = value != 0 && TREE_CODE (value) == STRING_CST;
+ designator_depth = 0;
+
/* Handle superfluous braces around string cst as in
char x[] = {"foo"}; */
if (string_flag
@@ -6085,6 +6417,10 @@ process_init_element (value)
break;
}
+ /* In the case of [LO ... HI] = VALUE, only evaluate VALUE once. */
+ if (constructor_range_stack)
+ value = save_expr (value);
+
while (1)
{
if (TREE_CODE (constructor_type) == RECORD_TYPE)
@@ -6152,9 +6488,8 @@ process_init_element (value)
&& DECL_C_BIT_FIELD (constructor_fields)
&& DECL_NAME (constructor_fields) == 0)
constructor_fields = TREE_CHAIN (constructor_fields);
- break;
}
- if (TREE_CODE (constructor_type) == UNION_TYPE)
+ else if (TREE_CODE (constructor_type) == UNION_TYPE)
{
tree fieldtype;
enum tree_code fieldcode;
@@ -6213,9 +6548,8 @@ process_init_element (value)
}
constructor_fields = 0;
- break;
}
- if (TREE_CODE (constructor_type) == ARRAY_TYPE)
+ else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
{
tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
enum tree_code eltcode = TREE_CODE (elttype);
@@ -6246,61 +6580,93 @@ process_init_element (value)
break;
}
- /* In the case of [LO .. HI] = VALUE, only evaluate VALUE once. */
- if (constructor_range_end)
+ /* Now output the actual element. */
+ if (value)
{
- if (constructor_max_index != 0
- && tree_int_cst_lt (constructor_max_index,
- constructor_range_end))
- {
- pedwarn_init ("excess elements in array initializer");
- constructor_range_end = constructor_max_index;
- }
-
- value = save_expr (value);
+ push_array_bounds (tree_low_cst (constructor_index, 0));
+ output_init_element (value, elttype, constructor_index, 1);
+ RESTORE_SPELLING_DEPTH (constructor_depth);
}
- /* Now output the actual element.
- Ordinarily, output once.
- If there is a range, repeat it till we advance past the range. */
- do
- {
- if (value)
- {
- push_array_bounds (tree_low_cst (constructor_index, 0));
- output_init_element (value, elttype, constructor_index, 1);
- RESTORE_SPELLING_DEPTH (constructor_depth);
- }
-
- constructor_index
- = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node);
-
- if (! value)
- /* If we are doing the bookkeeping for an element that was
- directly output as a constructor, we must update
- constructor_unfilled_index. */
- constructor_unfilled_index = constructor_index;
- }
- while (! (constructor_range_end == 0
- || tree_int_cst_lt (constructor_range_end,
- constructor_index)));
+ constructor_index
+ = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node);
- break;
+ if (! value)
+ /* If we are doing the bookkeeping for an element that was
+ directly output as a constructor, we must update
+ constructor_unfilled_index. */
+ constructor_unfilled_index = constructor_index;
}
/* Handle the sole element allowed in a braced initializer
for a scalar variable. */
- if (constructor_fields == 0)
+ else if (constructor_fields == 0)
{
pedwarn_init ("excess elements in scalar initializer");
break;
}
+ else
+ {
+ if (value)
+ output_init_element (value, constructor_type, NULL_TREE, 1);
+ constructor_fields = 0;
+ }
+
+ /* Handle range initializers either at this level or anywhere higher
+ in the designator stack. */
+ if (constructor_range_stack)
+ {
+ struct constructor_range_stack *p, *range_stack;
+ int finish = 0;
+
+ range_stack = constructor_range_stack;
+ constructor_range_stack = 0;
+ while (constructor_stack != range_stack->stack)
+ {
+ if (!constructor_stack->implicit)
+ abort ();
+ process_init_element (pop_init_level (1));
+ }
+ for (p = range_stack;
+ !p->range_end || tree_int_cst_equal (p->index, p->range_end);
+ p = p->prev)
+ {
+ if (!constructor_stack->implicit)
+ abort ();
+ process_init_element (pop_init_level (1));
+ }
+
+ p->index = size_binop (PLUS_EXPR, p->index, bitsize_one_node);
+ if (tree_int_cst_equal (p->index, p->range_end) && !p->prev)
+ finish = 1;
+
+ while (1)
+ {
+ constructor_index = p->index;
+ constructor_fields = p->fields;
+ if (finish && p->range_end && p->index == p->range_start)
+ {
+ finish = 0;
+ p->prev = 0;
+ }
+ p = p->next;
+ if (!p)
+ break;
+ push_init_level (1);
+ p->stack = constructor_stack;
+ if (p->range_end && tree_int_cst_equal (p->index, p->range_end))
+ p->index = p->range_start;
+ }
+
+ if (!finish)
+ constructor_range_stack = range_stack;
+ continue;
+ }
- if (value)
- output_init_element (value, constructor_type, NULL_TREE, 1);
- constructor_fields = 0;
break;
}
+
+ constructor_range_stack = 0;
}
/* Expand an ASM statement with operands, handling output operands
--- gcc/extend.texi.jj Tue Nov 28 10:05:42 2000
+++ gcc/extend.texi Tue Dec 5 17:21:57 2000
@@ -1209,6 +1209,10 @@ int widths[] = @{ [0 ... 9] = 1, [10 ...
@end example
@noindent
+If the value in it has side-effects, the side-effects will happen only once,
+not for each initialized field by the range initializer.
+
+@noindent
Note that the length of the array is the highest value specified
plus one.
@@ -1292,6 +1296,12 @@ example, with the @samp{struct point} de
@example
struct point ptarray[10] = @{ [2].y = yv2, [2].x = xv2, [0].x = xv0 @};
@end example
+
+@noindent
+If the same field is initialized multiple times, it will have value from
+the last initialization. If any such overridden initialization has
+side-effect, it is undefined whether the side-effect happen or not.
+Currently, gcc will discard them and issue a warning.
@node Case Ranges
@section Case Ranges
--- gcc/testsuite/gcc.c-torture/execute/20000801-3.x.jj Thu Aug 3 09:36:13 2000
+++ gcc/testsuite/gcc.c-torture/execute/20000801-3.x Tue Dec 5 16:58:41 2000
@@ -1,2 +0,0 @@
-set torture_execute_xfail "*-*-*"
-return 0
--- gcc/testsuite/gcc.dg/c99-init-1.c.jj Fri Dec 1 17:35:22 2000
+++ gcc/testsuite/gcc.dg/c99-init-1.c Tue Dec 5 17:06:02 2000
@@ -0,0 +1,78 @@
+/* Test for C99 designated initializers */
+/* Origin: Jakub Jelinek <jakub@redhat.com> */
+/* { dg-do run } */
+/* { dg-options "-std=c99 -pedantic-errors" } */
+
+typedef __SIZE_TYPE__ size_t;
+typedef __WCHAR_TYPE__ wchar_t;
+extern int memcmp (const void *, const void *, size_t);
+extern void abort (void);
+extern void exit (int);
+
+int a[10] = { 10, 0, 12, 13, 14, 0, 0, 17, 0, 0 };
+int b[10] = { 10, [4] = 15, [2] = 12, [4] = 14, [7] = 17 };
+int c[10] = { 10, [4] = 15, [2] = 12, [3] = 13, 14, [7] = 17 };
+struct A {
+ int B;
+ short C[2];
+};
+struct A d[] = { { 0, { 1, 2 } }, { 0, { 0, 0 } }, { 10, { 11, 12 } } };
+struct A e[] = { 0, 1, 2, [2] = 10, 11, 12 };
+struct A f[] = { 0, 1, 2, [2].C = 11, 12, 13 };
+struct A g[] = { 0, 1, 2, [2].C[1] = 12, 13, 14 };
+struct A h[] = { 0, 1, 2, [2] = { .C[1] = 12 }, 13, 14 };
+struct A i[] = { 0, 1, 2, [2] = { .C = { [1] = 12 } }, 13, 14 };
+union D {
+ int E;
+ double F;
+ struct A G;
+};
+union D j[] = { [4] = 1, [4].F = 1.0, [1].G.C[1] = 4 };
+struct H {
+ char I[6];
+ int J;
+} k[] = { { { "foo" }, 1 }, [0].I[0] = 'b' };
+struct K {
+ wchar_t L[6];
+ int M;
+} l[] = { { { L"foo" }, 1 }, [0].L[2] = L'x', [0].L[4] = L'y' };
+struct H m[] = { { { "foo" }, 1 }, [0] = { .I[0] = 'b' } };
+struct H n[] = { { { "foo" }, 1 }, [0].I = { "a" }, [0].J = 2 };
+int o = { 22 };
+
+int main (void)
+{
+ if (b[3])
+ abort ();
+ b[3] = 13;
+ if (memcmp (a, b, sizeof (a)) || memcmp (a, c, sizeof (a)))
+ abort ();
+ if (memcmp (d, e, sizeof (d)) || sizeof (d) != sizeof (e))
+ abort ();
+ if (f[2].B != 0 || g[2].B != 0 || g[2].C[0] != 0)
+ abort ();
+ if (memcmp (g, h, sizeof (g)) || memcmp (g, i, sizeof (g)))
+ abort ();
+ f[2].B = 10;
+ g[2].B = 10;
+ g[2].C[0] = 11;
+ if (memcmp (d, f, sizeof (d)) || memcmp (d, g, sizeof (d)))
+ abort ();
+ if (f[3].B != 13 || g[3].B != 13 || g[3].C[0] != 14)
+ abort ();
+ if (j[0].E || j[1].G.B || j[1].G.C[0] || j[1].G.C[1] != 4)
+ abort ();
+ if (j[2].E || j[3].E || j[4].F != 1.0)
+ abort ();
+ if (memcmp (k[0].I, "boo\0\0", 6) || k[0].J != 1)
+ abort ();
+ if (memcmp (l[0].L, L"fox\0y", 6 * sizeof(wchar_t)) || l[0].M != 1)
+ abort ();
+ if (memcmp (m[0].I, "b\0\0\0\0", 6) || m[0].J)
+ abort ();
+ if (memcmp (n[0].I, "a\0\0\0\0", 6) || n[0].J != 2)
+ abort ();
+ if (o != 22)
+ abort ();
+ exit (0);
+}
--- gcc/testsuite/gcc.dg/c99-init-2.c.jj Fri Dec 1 18:01:29 2000
+++ gcc/testsuite/gcc.dg/c99-init-2.c Fri Dec 1 22:34:54 2000
@@ -0,0 +1,12 @@
+/* Test for C99 designated initializer errors */
+/* Origin: Jakub Jelinek <jakub@redhat.com> */
+/* { dg-do compile } */
+/* { dg-options "-std=iso9899:1999 -pedantic-errors" } */
+
+struct A {
+ int B;
+ short C[2];
+};
+struct A a = { [2] = 1 }; /* { dg-error "(array index in non-array)|(near initialization)" } */
+struct A b[] = { .B = 1 }; /* { dg-error "(field name not in record)|(near initialization)" } */
+struct A c[] = { [0].D = 1 }; /* { dg-error "unknown field" } */
--- gcc/testsuite/gcc.dg/c99-init-3.c.jj Tue Dec 5 16:18:58 2000
+++ gcc/testsuite/gcc.dg/c99-init-3.c Tue Dec 5 16:48:36 2000
@@ -0,0 +1,62 @@
+/* Test for C99 designated initializers */
+/* Origin: Jakub Jelinek <jakub@redhat.com> */
+/* { dg-do run } */
+/* { dg-options "-std=gnu99" } */
+
+typedef __SIZE_TYPE__ size_t;
+extern int memcmp (const void *, const void *, size_t);
+extern void abort (void);
+extern void exit (int);
+
+int a[][2][4] = { [2 ... 4][0 ... 1][2 ... 3] = 1, [2] = 2, [2][0][2] = 3 };
+struct E {};
+struct F { struct E H; };
+struct G { int I; struct E J; int K; };
+struct H { int I; struct F J; int K; };
+struct G k = { .J = {}, 1 };
+struct H l = { .J.H = {}, 2 };
+struct H m = { .J = {}, 3 };
+struct I { int J; int K[3]; int L; };
+struct M { int N; struct I O[3]; int P; };
+struct M n[] = { [0 ... 5].O[1 ... 2].K[0 ... 1] = 4, 5, 6, 7 };
+
+int main (void)
+{
+ int x, y, z;
+
+ if (a[2][0][0] != 2 || a[2][0][2] != 3)
+ abort ();
+ a[2][0][0] = 0;
+ a[2][0][2] = 1;
+ for (x = 0; x <= 4; x++)
+ for (y = 0; y <= 1; y++)
+ for (z = 0; z <= 3; z++)
+ if (a[x][y][z] != (x >= 2 && z >= 2))
+ abort ();
+ if (k.I || l.I || m.I || k.K != 1 || l.K != 2 || m.K != 3)
+ abort ();
+ for (x = 0; x <= 5; x++)
+ {
+ if (n[x].N || n[x].O[0].J || n[x].O[0].L)
+ abort ();
+ for (y = 0; y <= 2; y++)
+ if (n[x].O[0].K[y])
+ abort ();
+ for (y = 1; y <= 2; y++)
+ {
+ if (n[x].O[y].J)
+ abort ();
+ if (n[x].O[y].K[0] != 4)
+ abort ();
+ if (n[x].O[y].K[1] != 4)
+ abort ();
+ if ((x < 5 || y < 2) && (n[x].O[y].K[2] || n[x].O[y].L))
+ abort ();
+ }
+ if (x < 5 && n[x].P)
+ abort ();
+ }
+ if (n[5].O[2].K[2] != 5 || n[5].O[2].L != 6 || n[5].P != 7)
+ abort ();
+ exit (0);
+}
Jakub