2009-05-03 Richard Guenther <rguenther@suse.de>

	PR middle-end/23329
	* tree-ssa.c (useless_type_conversion_p_1): Use get_deref_alias_set.
	Do not lose casts from array types with unknown extent to array
	types with known extent.
	* tree-ssa-copy.c (may_propagate_copy): Remove hack checking for
	alias set compatibility.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@147082 138bc75d-0d04-0410-961f-82ee72b054a4

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 6c0bd51..581b3b5 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,12 @@
+2009-05-03  Richard Guenther  <rguenther@suse.de>
+
+       PR middle-end/23329
+       * tree-ssa.c (useless_type_conversion_p_1): Use get_deref_alias_set.
+       Do not lose casts from array types with unknown extent to array
+       types with known extent.
+       * tree-ssa-copy.c (may_propagate_copy): Remove hack checking for
+       alias set compatibility.
+
 2009-05-03  Manuel López-Ibáñez  <manu@gcc.gnu.org>
 
        * flags.h (extra_warnings): Delete.

diff --git a/gcc/tree-ssa-copy.c b/gcc/tree-ssa-copy.c
index f582ed0..9dad1cd 100644 (file)
--- a/gcc/tree-ssa-copy.c
+++ b/gcc/tree-ssa-copy.c
@@ -78,55 +78,6 @@ may_propagate_copy (tree dest, tree orig)
   if (!useless_type_conversion_p (type_d, type_o))
     return false;
 
-  /* FIXME.  GIMPLE is allowing pointer assignments and comparisons of
-     pointers that have different alias sets.  This means that these
-     pointers will have different memory tags associated to them.
-
-     If we allow copy propagation in these cases, statements de-referencing
-     the new pointer will now have a reference to a different memory tag
-     with potentially incorrect SSA information.
-
-     This was showing up in libjava/java/util/zip/ZipFile.java with code
-     like:
-
-       struct java.io.BufferedInputStream *T.660;
-       struct java.io.BufferedInputStream *T.647;
-       struct java.io.InputStream *is;
-       struct java.io.InputStream *is.662;
-       [ ... ]
-       T.660 = T.647;
-       is = T.660;     <-- This ought to be type-casted
-       is.662 = is;
-
-     Also, f/name.c exposed a similar problem with a COND_EXPR predicate
-     that was causing DOM to generate and equivalence with two pointers of
-     alias-incompatible types:
-
-       struct _ffename_space *n;
-       struct _ffename *ns;
-       [ ... ]
-       if (n == ns)
-         goto lab;
-       ...
-       lab:
-       return n;
-
-     I think that GIMPLE should emit the appropriate type-casts.  For the
-     time being, blocking copy-propagation in these cases is the safe thing
-     to do.  */
-  if (TREE_CODE (dest) == SSA_NAME
-      && TREE_CODE (orig) == SSA_NAME
-      && POINTER_TYPE_P (type_d)
-      && POINTER_TYPE_P (type_o))
-    {
-      if (get_alias_set (TREE_TYPE (type_d))
-         != get_alias_set (TREE_TYPE (type_o)))
-       return false;
-      else if (DECL_NO_TBAA_P (SSA_NAME_VAR (dest))
-              != DECL_NO_TBAA_P (SSA_NAME_VAR (orig)))
-       return false;
-    }
-
   /* Propagating virtual operands is always ok.  */
   if (TREE_CODE (dest) == SSA_NAME && !is_gimple_reg (dest))
     {

diff --git a/gcc/tree-ssa.c b/gcc/tree-ssa.c
index edbae39..10ec35b 100644 (file)
--- a/gcc/tree-ssa.c
+++ b/gcc/tree-ssa.c
@@ -961,12 +961,9 @@ useless_type_conversion_p_1 (tree outer_type, tree inner_type)
          && TYPE_VOLATILE (TREE_TYPE (outer_type)))
        return false;
 
-      /* Do not lose casts between pointers with different
-        TYPE_REF_CAN_ALIAS_ALL setting or alias sets.  */
-      if ((TYPE_REF_CAN_ALIAS_ALL (inner_type)
-          != TYPE_REF_CAN_ALIAS_ALL (outer_type))
-         || (get_alias_set (TREE_TYPE (inner_type))
-             != get_alias_set (TREE_TYPE (outer_type))))
+      /* Do not lose casts between pointers that when dereferenced access
+        memory with different alias sets.  */
+      if (get_deref_alias_set (inner_type) != get_deref_alias_set (outer_type))
        return false;
 
       /* We do not care for const qualification of the pointed-to types
@@ -1002,6 +999,13 @@ useless_type_conversion_p_1 (tree outer_type, tree inner_type)
       if (TREE_CODE (inner_type) != TREE_CODE (outer_type))
        return false;
 
+      /* Conversions from array types with unknown extent to
+        array types with known extent are not useless.  */
+      if (TREE_CODE (inner_type) == ARRAY_TYPE
+         && !TYPE_DOMAIN (inner_type)
+         && TYPE_DOMAIN (outer_type))
+       return false;
+
       /* ???  This seems to be necessary even for aggregates that don't
         have TYPE_STRUCTURAL_EQUALITY_P set.  */