This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
Re: ping a wrong code regression patch
- From: Andrew Pinski <pinskia at physics dot uc dot edu>
- To: mark at codesourcery dot com, joseph at codesourcery dot com
- Cc: gcc-patches at gcc dot gnu dot org
- Date: Sun, 13 Aug 2006 13:16:53 -0700
- Subject: Re: ping a wrong code regression patch
Sorry for breaking the thread, I lost the old email:
http://gcc.gnu.org/ml/gcc-patches/2006-06/msg01194.html
Here is the patch I applied after a bootstrap and test on
i686-linux-gnu.
Thanks,
Andrew Pinski
ChangeLog:
Alexandre Oliva <aoliva@redhat.com>
Andrew Pinski <pinskia@physics.uc.edu>
PR c/27184
* tree.c (build_array_type): Unify array types with
unspecified index_type.
* c-decl.c (grokdeclarator): Make sure we do not modify a
unified incomplete array type.
* c-typeck.c (store_init_value): Create distinct type before
filling in the index type in an initializer from a compound
literal.
* c-decl.c (grokdeclarator): Remove code where we copy the
array type over.
testsuite/ChangeLog:
Alexandre Oliva <aoliva@redhat.com>
PR c/27184
* gcc.dg/torture/pr27184.c: New test.
Index: tree.c
===================================================================
--- tree.c (revision 116115)
+++ tree.c (working copy)
@@ -5158,7 +5158,11 @@ build_array_type (tree elt_type, tree in
if (index_type == 0)
{
- layout_type (t);
+ tree save = t;
+ hashcode = iterative_hash_object (TYPE_HASH (elt_type), hashcode);
+ t = type_hash_canon (hashcode, t);
+ if (save == t)
+ layout_type (t);
return t;
}
Index: testsuite/gcc.dg/torture/pr27184.c
===================================================================
--- testsuite/gcc.dg/torture/pr27184.c (revision 0)
+++ testsuite/gcc.dg/torture/pr27184.c (revision 0)
@@ -0,0 +1,22 @@
+/* Copyright 2006 Free Software Foundation */
+
+/* Make sure a and a1 alias each other.
+ Incomplete array types used to not be unified, which broke aliasing. */
+
+/* { dg-do run } */
+
+typedef long atype[];
+typedef long atype1[];
+int NumSift (atype *a, atype1 *a1)
+{
+ (*a)[0] = 0;
+ (*a1)[0] = 1;
+ return (*a)[0];
+}
+int main(void)
+{
+ long a[2];
+ if (!NumSift(&a, &a))
+ __builtin_abort ();
+ return 0;
+}
Index: c-decl.c
===================================================================
--- c-decl.c (revision 116115)
+++ c-decl.c (working copy)
@@ -4309,6 +4309,18 @@ grokdeclarator (const struct c_declarato
size_varies = 1;
}
}
+ else if (decl_context == TYPENAME)
+ {
+ if (array_parm_vla_unspec_p)
+ {
+ /* The error is printed elsewhere. We use this to
+ avoid messing up with incomplete array types of
+ the same type, that would otherwise be modified
+ below. */
+ itype = build_range_type (sizetype, size_zero_node,
+ NULL_TREE);
+ }
+ }
/* Complain about arrays of incomplete types. */
if (!COMPLETE_TYPE_P (type))
@@ -4317,12 +4329,23 @@ grokdeclarator (const struct c_declarato
type = error_mark_node;
}
else
+ /* When itype is NULL, a shared incomplete array type is
+ returned for all array of a given type. Elsewhere we
+ make sure we don't complete that type before copying
+ it, but here we want to make sure we don't ever
+ modify the shared type, so we gcc_assert (itype)
+ below. */
type = build_array_type (type, itype);
if (type != error_mark_node)
{
if (size_varies)
{
+ /* It is ok to modify type here even if itype is
+ NULL: if size_varies, we're in a
+ multi-dimentional array and the inner type has
+ variable size, so the enclosing shared array type
+ must too. */
if (size && TREE_CODE (size) == INTEGER_CST)
type
= build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
@@ -4334,11 +4357,13 @@ grokdeclarator (const struct c_declarato
zero. */
if (size && integer_zerop (size))
{
+ gcc_assert (itype);
TYPE_SIZE (type) = bitsize_zero_node;
TYPE_SIZE_UNIT (type) = size_zero_node;
}
if (array_parm_vla_unspec_p)
{
+ gcc_assert (itype);
/* The type is complete. C99 6.7.5.2p4 */
TYPE_SIZE (type) = bitsize_zero_node;
TYPE_SIZE_UNIT (type) = size_zero_node;
@@ -4497,21 +4522,6 @@ grokdeclarator (const struct c_declarato
return decl;
}
- /* Detect the case of an array type of unspecified size
- which came, as such, direct from a typedef name.
- We must copy the type, so that each identifier gets
- a distinct type, so that each identifier's size can be
- controlled separately by its own initializer. */
-
- if (type != 0 && typedef_type != 0
- && TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == 0
- && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type))
- {
- type = build_array_type (TREE_TYPE (type), 0);
- if (size_varies)
- C_TYPE_VARIABLE_SIZE (type) = 1;
- }
-
/* If this is a type name (such as, in a cast or sizeof),
compute the type and return it now. */
Index: c-typeck.c
===================================================================
--- c-typeck.c (revision 116115)
+++ c-typeck.c (working copy)
@@ -4326,16 +4326,18 @@ store_init_value (tree decl, tree init)
if (TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR)
{
- tree decl = COMPOUND_LITERAL_EXPR_DECL (inside_init);
+ tree cldecl = COMPOUND_LITERAL_EXPR_DECL (inside_init);
- if (TYPE_DOMAIN (TREE_TYPE (decl)))
+ if (TYPE_DOMAIN (TREE_TYPE (cldecl)))
{
/* For int foo[] = (int [3]){1}; we need to set array size
now since later on array initializer will be just the
brace enclosed list of the compound literal. */
- TYPE_DOMAIN (type) = TYPE_DOMAIN (TREE_TYPE (decl));
+ type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
+ TREE_TYPE (decl) = type;
+ TYPE_DOMAIN (type) = TYPE_DOMAIN (TREE_TYPE (cldecl));
layout_type (type);
- layout_decl (decl, 0);
+ layout_decl (cldecl, 0);
}
}
}