+2001-01-04 Richard Henderson <rth@redhat.com>
+
+ * c-decl.c (finish_struct): Detect flexible array members
+ used in an inappropriate context.
+ * c-typeck.c (really_start_incremental_init): Special case
+ constructor_max_index for zero length arrays.
+ (pop_init_level): Allow initialization of flexible array
+ members. Deprecate initialization of zero length arrays.
+ Don't issue missing initializer warning for flexible array
+ members or zero length arrays.
+ (process_init_element): Don't dereference null DECL_SIZE.
+ * varasm.c (array_size_for_constructor): Return a HOST_WIDE_INT.
+ Don't abort for empty constructors. Use size_binop
+ (output_constructor): Add commentary regarding zero length
+ array futures. Abort if we try to initialize an array of
+ unspecified length with a non-empty constructor in the middle
+ of a structure.
+
+ * extend.texi (Zero Length): Update and clarify documentation
+ on static initialization.
+
2001-01-05 Michael Hayes <m.hayes@elec.canterbury.ac.nz>
* config/c4x/c4x.c (c4x_expand_prologue): Don't compile an ISR
{
register tree x;
int toplevel = global_binding_level == current_binding_level;
+ int saw_named_field;
/* If this type was previously laid out as a forward reference,
make sure we lay it out again. */
Store 0 there, except for ": 0" fields (so we can find them
and delete them, below). */
+ saw_named_field = 0;
for (x = fieldlist; x; x = TREE_CHAIN (x))
{
DECL_CONTEXT (x) = t;
}
DECL_INITIAL (x) = 0;
+
+ /* Detect flexible array member in an invalid context. */
+ if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
+ && TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
+ && TYPE_DOMAIN (TREE_TYPE (x)) != NULL_TREE
+ && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x))) == NULL_TREE)
+ {
+ if (TREE_CODE (t) == UNION_TYPE)
+ error_with_decl (x, "flexible array member in union");
+ else if (TREE_CHAIN (x) != NULL_TREE)
+ error_with_decl (x, "flexible array member not at end of struct");
+ else if (! saw_named_field)
+ error_with_decl (x, "flexible array member in otherwise empty struct");
+ }
+ if (DECL_NAME (x))
+ saw_named_field = 1;
}
/* Delete all duplicate fields from the fieldlist */
fieldlistp = &TREE_CHAIN (*fieldlistp);
}
- /* Now we have the truly final field list.
- Store it in this type and in the variants. */
+ /* Now we have the truly final field list.
+ Store it in this type and in the variants. */
TYPE_FIELDS (t) = fieldlist;
{
constructor_max_index
= TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
+
+ /* Detect non-empty initializations of zero-length arrays. */
+ if (constructor_max_index == NULL_TREE)
+ constructor_max_index = build_int_2 (-1, -1);
+
constructor_index
= convert (bitsizetype,
TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
constructor_index
= convert (bitsizetype,
TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
+
+ /* ??? For GCC 3.1, remove special case initialization of
+ zero-length array members from pop_init_level and set
+ constructor_max_index such that we get the normal
+ "excess elements" warning. */
}
else
constructor_index = bitsize_zero_node;
/* Error for initializing a flexible array member, or a zero-length
array member in an inappropriate context. */
- if (constructor_type
+ if (constructor_type && constructor_fields
&& TREE_CODE (constructor_type) == ARRAY_TYPE
&& TYPE_DOMAIN (constructor_type)
&& ! TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type)))
{
- if (! TYPE_SIZE (constructor_type))
- error_init ("initialization of a flexible array member");
- /* Silently discard empty initializations of zero-length arrays. */
- else if (integer_zerop (constructor_unfilled_index))
- constructor_type = 0;
- /* Otherwise we must be initializing a member of a top-level
- structure. */
- else if (constructor_depth != 2)
- error_init ("initialization of zero-length array inside a nested structure");
+ /* Silently discard empty initializations. The parser will
+ already have pedwarned for empty brackets. */
+ if (integer_zerop (constructor_unfilled_index))
+ constructor_type = NULL_TREE;
+ else if (! TYPE_SIZE (constructor_type))
+ {
+ if (constructor_depth > 2)
+ error_init ("initialization of flexible array member in a nested context");
+ else if (pedantic)
+ pedwarn_init ("initialization of a flexible array member");
+
+ /* We have already issued an error message for the existance
+ of a flexible array member not at the end of the structure.
+ Discard the initializer so that we do not abort later. */
+ if (TREE_CHAIN (constructor_fields) != NULL_TREE)
+ constructor_type = NULL_TREE;
+ }
+ else
+ {
+ warning_init ("deprecated initialization of zero-length array");
+
+ /* We must be initializing the last member of a top-level struct. */
+ if (TREE_CHAIN (constructor_fields) != NULL_TREE)
+ {
+ error_init ("initialization of zero-length array before end of structure");
+ /* Discard the initializer so that we do not abort later. */
+ constructor_type = NULL_TREE;
+ }
+ else if (constructor_depth > 2)
+ error_init ("initialization of zero-length array inside a nested context");
+ }
}
/* Warn when some struct elements are implicitly initialized to zero. */
&& TREE_CODE (constructor_type) == RECORD_TYPE
&& constructor_unfilled_fields)
{
- push_member_name (constructor_unfilled_fields);
- warning_init ("missing initializer");
- RESTORE_SPELLING_DEPTH (constructor_depth);
+ /* Do not warn for flexible array members or zero-length arrays. */
+ while (constructor_unfilled_fields
+ && (! DECL_SIZE (constructor_unfilled_fields)
+ || integer_zerop (DECL_SIZE (constructor_unfilled_fields))))
+ constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);
+
+ if (constructor_unfilled_fields)
+ {
+ push_member_name (constructor_unfilled_fields);
+ warning_init ("missing initializer");
+ RESTORE_SPELLING_DEPTH (constructor_depth);
+ }
}
/* Now output all pending elements. */
directly output as a constructor. */
{
/* For a record, keep track of end position of last field. */
- constructor_bit_index
- = size_binop (PLUS_EXPR,
- bit_position (constructor_fields),
- DECL_SIZE (constructor_fields));
+ if (DECL_SIZE (constructor_fields))
+ constructor_bit_index
+ = size_binop (PLUS_EXPR,
+ bit_position (constructor_fields),
+ DECL_SIZE (constructor_fields));
constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
/* Skip any nameless bit fields. */
@cindex arrays of length zero
@cindex zero-length arrays
@cindex length-zero arrays
+@cindex flexible array members
Zero-length arrays are allowed in GNU C. They are very useful as the
last element of a structure which is really a header for a variable-length
defining structures containing only a zero-length array. Such usage
is deprecated, and we recommend using zero-length arrays only in
places in which flexible array members would be allowed.
+@end itemize
-@item
-GCC allows static initialization of the zero-length array if the structure
-is not nested inside another structure. In addition, for backward
-compatibility with an earlier versions of gcc, we allow a degenerate empty
-initialization when nested inside another structure. I.e.
+GCC versions before 3.0 allowed zero-length arrays to be statically
+initialized. In addition to those cases that were useful, it also
+allowed initializations in situations that would corrupt later data.
+Non-empty initialization of zero-length arrays is now deprecated.
+
+Instead GCC allows static initialization of flexible array members.
+This is equivalent to defining a new structure containing the original
+structure followed by an array of sufficient size to contain the data.
+I.e. in the following, @code{f1} is constructed as if it were declared
+like @code{f2}.
@example
-struct bar @{ struct line a; @};
+struct f1 @{
+ int x; int y[];
+@} f1 = @{ 1, @{ 2, 3, 4 @} @};
+
+struct f2 @{
+ struct f1 f1; int data[3];
+@} f2 = @{ @{ 1 @}, @{ 2, 3, 4 @} @};
+@end example
-/* Legal. */
-struct line x = @{ 4, @{ 'g', 'o', 'o', 'd' @} @};
+@noindent
+The convenience of this extension is that @code{f1} has the desired
+type, eliminating the need to consistently refer to @code{f2.f1}.
+
+This has symmetry with normal static arrays, in that an array of
+unknown size is also written with @code{[]}.
-/* Illegal. */
-struct bar y = @{ @{ 3, @{ 'b', 'a', 'd' @} @} @};
+Of course, this extension only makes sense if the extra data comes at
+the end of a top-level object, as otherwise we would be overwriting
+data at subsequent offsets. To avoid undue complication and confusion
+with initialization of deeply nested arrays, we simply disallow any
+non-empty initialization except when the structure is the top-level
+object. For example:
-/* Legal. */
-struct bar z = @{ @{ 0, @{ @} @} @};
+@example
+struct foo @{ int x; int y[]; @};
+struct bar @{ struct foo z; @};
+
+struct foo a = @{ 1, @{ 2, 3, 4 @} @}; // Legal.
+struct bar b = @{ @{ 1, @{ 2, 3, 4 @} @} @}; // Illegal.
+struct bar c = @{ @{ 1, @{ @} @} @}; // Legal.
+struct foo d[1] = @{ @{ 1 @{ 2, 3, 4 @} @} @}; // Illegal.
@end example
-@end itemize
@node Variable Length
@section Arrays of Variable Length
struct pool_constant *x_first_pool, *x_last_pool;
/* Current offset in constant pool (does not include any machine-specific
- header. */
+ header). */
int x_pool_offset;
/* Chain of all CONST_DOUBLE rtx's constructed for the current function.
static void mark_constants PARAMS ((rtx));
static int output_addressed_constants PARAMS ((tree));
static void output_after_function_constants PARAMS ((void));
-static int array_size_for_constructor PARAMS ((tree));
+static unsigned HOST_WIDE_INT array_size_for_constructor PARAMS ((tree));
static void output_constructor PARAMS ((tree, int));
#ifdef ASM_WEAKEN_LABEL
static void remove_from_pending_weak_list PARAMS ((const char *));
arrays of unspecified length. VAL must be a CONSTRUCTOR of an array
type with an unspecified upper bound. */
-static int
+static unsigned HOST_WIDE_INT
array_size_for_constructor (val)
tree val;
{
tree max_index, i;
- if (!val || TREE_CODE (val) != CONSTRUCTOR
- || TREE_CODE (TREE_TYPE (val)) != ARRAY_TYPE
- || TYPE_DOMAIN (TREE_TYPE (val)) == NULL_TREE
- || TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (val))) != NULL_TREE
- || TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (val))) == NULL_TREE)
- abort ();
-
max_index = NULL_TREE;
for (i = CONSTRUCTOR_ELTS (val); i ; i = TREE_CHAIN (i))
{
max_index = index;
}
- /* ??? I'm fairly certain if there were no elements, we shouldn't have
- created the constructor in the first place. */
if (max_index == NULL_TREE)
- abort ();
+ return 0;
/* Compute the total number of array elements. */
- i = fold (build (MINUS_EXPR, TREE_TYPE (max_index), max_index,
- TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (val)))));
- i = fold (build (PLUS_EXPR, TREE_TYPE (i), i,
- convert (TREE_TYPE (i), integer_one_node)));
+ i = size_binop (MINUS_EXPR, convert (sizetype, max_index),
+ convert (sizetype,
+ TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (val)))));
+ i = size_binop (PLUS_EXPR, i, convert (sizetype, integer_one_node));
/* Multiply by the array element unit size to find number of bytes. */
- i = fold (build (MULT_EXPR, TREE_TYPE (max_index), i,
- TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (val)))));
+ i = size_binop (MULT_EXPR, i, TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (val))));
return tree_low_cst (i, 1);
}
/* Determine size this element should occupy. */
if (field)
{
- /* If the last field is an array with an unspecified upper
- bound, the initializer determines the size. */
- if (TREE_CHAIN (field) == 0
- && TREE_CODE (TREE_TYPE (field)) == ARRAY_TYPE
- && TYPE_DOMAIN (TREE_TYPE (field)) != 0
- && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (field))) == 0)
+ fieldsize = 0;
+
+ /* If this is an array with an unspecified upper bound,
+ the initializer determines the size. */
+ /* ??? This ought to only checked if DECL_SIZE_UNIT is NULL,
+ but we cannot do this until the deprecated support for
+ initializing zero-length array members is removed. */
+ if (TREE_CODE (TREE_TYPE (field)) == ARRAY_TYPE
+ && TYPE_DOMAIN (TREE_TYPE (field))
+ && ! TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (field))))
+ {
fieldsize = array_size_for_constructor (val);
- else if (DECL_SIZE_UNIT (field)
- && host_integerp (DECL_SIZE_UNIT (field), 1))
- fieldsize = tree_low_cst (DECL_SIZE_UNIT (field), 1);
- else
- fieldsize = 0;
+ /* Given a non-empty initialization, this field had
+ better be last. */
+ if (fieldsize != 0 && TREE_CHAIN (field) != NULL_TREE)
+ abort ();
+ }
+ else if (DECL_SIZE_UNIT (field))
+ {
+ /* ??? This can't be right. If the decl size overflows
+ a host integer we will silently emit no data. */
+ if (host_integerp (DECL_SIZE_UNIT (field), 1))
+ fieldsize = tree_low_cst (DECL_SIZE_UNIT (field), 1);
+ }
}
else
fieldsize = int_size_in_bytes (TREE_TYPE (type));
OSDN Git Service
