re PR tree-optimization/23329 (hack in may_propagate_copy should be able to removed)

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.

From-SVN: r147082

3 files changed, 19 insertions, 55 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 6c0bd51..581b3b5 100644
--- 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
--- 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
--- 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.  */