[PATCH] Fix miscompilation of initializers with flexible array members (4.1 regression, PR tree-optimization/22043, take 3)
Jakub Jelinek
jakub@redhat.com
Mon Aug 22 19:09:00 GMT 2005
On Tue, Jun 14, 2005 at 09:51:26AM -0700, Mark Mitchell wrote:
> I think the longer version should probably be integrated with
> count_type_elements, by passing a flag saying that you want special
> treatment for flexible arrays. Otherwise, you're duplicating the logic
> of count_type_elements, as well as walking the type twice at runtime.
> The short version would be OK for mainline too, if you're not eager to
> do more work here.
Sorry for the delay.
Like this?
Bootstrapped/regtested on i386-linux.
2005-08-22 Jakub Jelinek <jakub@redhat.com>
PR tree-optimization/22043
* tree.h (count_type_elements): Add ALLOW_FLEXARR argument.
* expr.c (count_type_elements): Add ALLOW_FLEXARR argument.
If ALLOW_FLEXARR, handle types ending with flexible array member.
Pass false as second argument to recursive count_type_elements calls.
(categorize_ctor_elements_1, mostly_zeros_p): Pass false as second
argument to count_type_elements call.
* tree-sra.c (decide_block_copy): Likewise.
* gimplify.c (gimplify_init_constructor): If num_type_elements < 0
for a constant-sized object, set cleared as well. Pass true as
second argument to count_type_elements call.
* gcc.c-torture/execute/20050613-1.c: New test.
--- gcc/tree.h.jj 2005-08-06 10:40:04.000000000 +0200
+++ gcc/tree.h 2005-08-22 18:15:19.000000000 +0200
@@ -3554,7 +3554,7 @@ extern bool initializer_zerop (tree);
extern void categorize_ctor_elements (tree, HOST_WIDE_INT *, HOST_WIDE_INT *,
HOST_WIDE_INT *, bool *);
-extern HOST_WIDE_INT count_type_elements (tree);
+extern HOST_WIDE_INT count_type_elements (tree, bool);
/* add_var_to_bind_expr (bind_expr, var) binds var to bind_expr. */
--- gcc/expr.c.jj 2005-08-16 16:23:58.000000000 +0200
+++ gcc/expr.c 2005-08-22 18:08:23.000000000 +0200
@@ -4504,7 +4504,7 @@ categorize_ctor_elements_1 (tree ctor, H
/* And now we have to find out if the element itself is fully
constructed. E.g. for union { struct { int a, b; } s; } u
= { .s = { .a = 1 } }. */
- if (elt_count == count_type_elements (init_sub_type))
+ if (elt_count == count_type_elements (init_sub_type, false))
clear_this = false;
}
}
@@ -4532,10 +4532,11 @@ categorize_ctor_elements (tree ctor, HOS
}
/* Count the number of scalars in TYPE. Return -1 on overflow or
- variable-sized. */
+ variable-sized. If ALLOW_FLEXARR is true, don't count flexible
+ array member at the end of the structure. */
HOST_WIDE_INT
-count_type_elements (tree type)
+count_type_elements (tree type, bool allow_flexarr)
{
const HOST_WIDE_INT max = ~((HOST_WIDE_INT)1 << (HOST_BITS_PER_WIDE_INT-1));
switch (TREE_CODE (type))
@@ -4546,7 +4547,7 @@ count_type_elements (tree type)
if (telts && host_integerp (telts, 1))
{
HOST_WIDE_INT n = tree_low_cst (telts, 1) + 1;
- HOST_WIDE_INT m = count_type_elements (TREE_TYPE (type));
+ HOST_WIDE_INT m = count_type_elements (TREE_TYPE (type), false);
if (n == 0)
return 0;
else if (max / n > m)
@@ -4563,9 +4564,23 @@ count_type_elements (tree type)
for (f = TYPE_FIELDS (type); f ; f = TREE_CHAIN (f))
if (TREE_CODE (f) == FIELD_DECL)
{
- t = count_type_elements (TREE_TYPE (f));
+ t = count_type_elements (TREE_TYPE (f), false);
if (t < 0)
- return -1;
+ {
+ /* Check for structures with flexible array member. */
+ tree tf = TREE_TYPE (f);
+ if (allow_flexarr
+ && TREE_CHAIN (f) == NULL
+ && TREE_CODE (tf) == ARRAY_TYPE
+ && TYPE_DOMAIN (tf)
+ && TYPE_MIN_VALUE (TYPE_DOMAIN (tf))
+ && integer_zerop (TYPE_MIN_VALUE (TYPE_DOMAIN (tf)))
+ && !TYPE_MAX_VALUE (TYPE_DOMAIN (tf))
+ && int_size_in_bytes (type) >= 0)
+ break;
+
+ return -1;
+ }
n += t;
}
@@ -4623,7 +4638,7 @@ mostly_zeros_p (tree exp)
if (must_clear)
return 1;
- elts = count_type_elements (TREE_TYPE (exp));
+ elts = count_type_elements (TREE_TYPE (exp), false);
return nz_elts < elts / 4;
}
--- gcc/tree-sra.c.jj 2005-08-06 10:40:01.000000000 +0200
+++ gcc/tree-sra.c 2005-08-22 18:14:58.000000000 +0200
@@ -1338,7 +1338,7 @@ decide_block_copy (struct sra_elt *elt)
: MOVE_RATIO;
full_size = tree_low_cst (size_tree, 1);
- full_count = count_type_elements (elt->type);
+ full_count = count_type_elements (elt->type, false);
inst_count = sum_instantiated_sizes (elt, &inst_size);
/* ??? What to do here. If there are two fields, and we've only
--- gcc/gimplify.c.jj 2005-08-16 16:23:59.000000000 +0200
+++ gcc/gimplify.c 2005-08-22 18:13:02.000000000 +0200
@@ -2691,13 +2691,18 @@ gimplify_init_constructor (tree *expr_p,
parts in, then generate code for the non-constant parts. */
/* TODO. There's code in cp/typeck.c to do this. */
- num_type_elements = count_type_elements (TREE_TYPE (ctor));
+ num_type_elements = count_type_elements (type, true);
+ /* If count_type_elements could not determine number of type elements
+ for a constant-sized object, assume clearing is needed.
+ Don't do this for variable-sized objects, as store_constructor
+ will ignore the clearing of variable-sized objects. */
+ if (num_type_elements < 0 && int_size_in_bytes (type) >= 0)
+ cleared = true;
/* If there are "lots" of zeros, then block clear the object first. */
- if (num_type_elements - num_nonzero_elements > CLEAR_RATIO
- && num_nonzero_elements < num_type_elements/4)
+ else if (num_type_elements - num_nonzero_elements > CLEAR_RATIO
+ && num_nonzero_elements < num_type_elements/4)
cleared = true;
-
/* ??? This bit ought not be needed. For any element not present
in the initializer, we should simply set them to zero. Except
we'd need to *find* the elements that are not present, and that
--- gcc/testsuite/gcc.c-torture/execute/20050613-1.c.jj 2005-08-22 12:21:00.108311280 +0200
+++ gcc/testsuite/gcc.c-torture/execute/20050613-1.c 2005-06-14 19:05:25.000000000 +0200
@@ -0,0 +1,27 @@
+/* PR tree-optimization/22043 */
+
+extern void abort (void);
+
+struct A { int i; int j; int k; int l; };
+struct B { struct A a; int r[1]; };
+struct C { struct A a; int r[0]; };
+struct D { struct A a; int r[]; };
+
+void
+foo (struct A *x)
+{
+ if (x->i != 0 || x->j != 5 || x->k != 0 || x->l != 0)
+ abort ();
+}
+
+int
+main ()
+{
+ struct B b = { .a.j = 5 };
+ struct C c = { .a.j = 5 };
+ struct D d = { .a.j = 5 };
+ foo (&b.a);
+ foo (&c.a);
+ foo (&d.a);
+ return 0;
+}
Jakub
More information about the Gcc-patches
mailing list