2008-12-30 Richard Guenther <rguenther@suse.de>

	PR tree-optimization/38645
	* tree-ssa-ccp.c (fold_gimple_assign): Use the correct pointer
	type.
	* tree-ssa-dom.c (cprop_operand): Simplify.  Do not propagate
	volatileness changing operands.

	* gcc.dg/pr38645.c: New testcase.

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

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 5d437b6..d680ff7 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,11 @@
+2008-12-30  Richard Guenther  <rguenther@suse.de>
+
+       PR tree-optimization/38645
+       * tree-ssa-ccp.c (fold_gimple_assign): Use the correct pointer
+       type.
+       * tree-ssa-dom.c (cprop_operand): Simplify.  Do not propagate
+       volatileness changing operands.
+
 2008-12-30  Steven Bosscher  <steven@gcc.gnu.org>
 
        * tree-cfg.c (verify_eh_throw_stmt_node): Return nonzero,

diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog
index 81e86b3..969273e 100644 (file)
--- a/gcc/testsuite/ChangeLog
+++ b/gcc/testsuite/ChangeLog
@@ -1,3 +1,8 @@
+2008-12-30  Richard Guenther  <rguenther@suse.de>
+
+       PR tree-optimization/38645
+       * gcc.dg/pr38645.c: New testcase.
+
 2008-12-30  Andrew Pinski  <pinskia@gmail.com>
 
        PR middle-end/38661

diff --git a/gcc/testsuite/gcc.dg/pr38645.c b/gcc/testsuite/gcc.dg/pr38645.c
new file mode 100644 (file)
index 0000000..3268f2a
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pr38645.c
@@ -0,0 +1,17 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+
+int foo()
+{
+  volatile int a[1];
+  int i, *p = (int*)a;
+
+  a[0] = 1;
+  for (i = 0; i < 1; ++i)
+    if (p[i])
+      return -1;
+  return 0;
+}
+
+/* { dg-final { scan-tree-dump "a.0. ={v} 1;" "optimized" } } */
+/* { dg-final { cleanup-tree-dump "optimized" } } */

diff --git a/gcc/tree-ssa-ccp.c b/gcc/tree-ssa-ccp.c
index 0908d54..d68337f 100644 (file)
--- a/gcc/tree-ssa-ccp.c
+++ b/gcc/tree-ssa-ccp.c
@@ -2720,10 +2720,19 @@ fold_gimple_assign (gimple_stmt_iterator *si)
     case GIMPLE_BINARY_RHS:
       /* Try to fold pointer addition.  */
       if (gimple_assign_rhs_code (stmt) == POINTER_PLUS_EXPR)
-        result = maybe_fold_stmt_addition (
-                   TREE_TYPE (gimple_assign_lhs (stmt)),
-                   gimple_assign_rhs1 (stmt),
-                   gimple_assign_rhs2 (stmt));
+       {
+         tree type = TREE_TYPE (gimple_assign_rhs1 (stmt));
+         if (TREE_CODE (TREE_TYPE (type)) == ARRAY_TYPE)
+           {
+             type = build_pointer_type (TREE_TYPE (TREE_TYPE (type)));
+             if (!useless_type_conversion_p
+                   (TREE_TYPE (gimple_assign_lhs (stmt)), type))
+               type = TREE_TYPE (gimple_assign_rhs1 (stmt));
+           }
+         result = maybe_fold_stmt_addition (type,
+                                            gimple_assign_rhs1 (stmt),
+                                            gimple_assign_rhs2 (stmt));
+       }
 
       if (!result)
         result = fold_binary (subcode,

diff --git a/gcc/tree-ssa-dom.c b/gcc/tree-ssa-dom.c
index bf2049e..6d6d02b 100644 (file)
--- a/gcc/tree-ssa-dom.c
+++ b/gcc/tree-ssa-dom.c
@@ -2045,8 +2045,6 @@ cprop_operand (gimple stmt, use_operand_p op_p)
   val = SSA_NAME_VALUE (op);
   if (val && val != op)
     {
-      tree op_type, val_type;
-
       /* Do not change the base variable in the virtual operand
         tables.  That would make it impossible to reconstruct
         the renamed virtual operand if we later modify this
@@ -2063,38 +2061,20 @@ cprop_operand (gimple stmt, use_operand_p op_p)
          && !may_propagate_copy_into_asm (op))
        return false;
 
-      /* Get the toplevel type of each operand.  */
-      op_type = TREE_TYPE (op);
-      val_type = TREE_TYPE (val);
-
-      /* While both types are pointers, get the type of the object
-        pointed to.  */
-      while (POINTER_TYPE_P (op_type) && POINTER_TYPE_P (val_type))
-       {
-         op_type = TREE_TYPE (op_type);
-         val_type = TREE_TYPE (val_type);
-       }
-
-      /* Make sure underlying types match before propagating a constant by
-        converting the constant to the proper type.  Note that convert may
-        return a non-gimple expression, in which case we ignore this
-        propagation opportunity.  */
-      if (TREE_CODE (val) != SSA_NAME)
-       {
-         if (!useless_type_conversion_p (op_type, val_type))
-           {
-             val = fold_convert (TREE_TYPE (op), val);
-             if (!is_gimple_min_invariant (val))
-               return false;
-           }
-       }
-
       /* Certain operands are not allowed to be copy propagated due
         to their interaction with exception handling and some GCC
         extensions.  */
-      else if (!may_propagate_copy (op, val))
+      if (!may_propagate_copy (op, val))
        return false;
-      
+
+      /* Do not propagate addresses that point to volatiles into memory
+        stmts without volatile operands.  */
+      if (POINTER_TYPE_P (TREE_TYPE (val))
+         && TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (val)))
+         && gimple_has_mem_ops (stmt)
+         && !gimple_has_volatile_ops (stmt))
+       return false;
+
       /* Do not propagate copies if the propagated value is at a deeper loop
         depth than the propagatee.  Otherwise, this may move loop variant
         variables outside of their loops and prevent coalescing