2006-03-30 Paolo Bonzini <bonzini@gnu.org>

	PR tree-optimization/26830

	* tree-ssa-copy.c (copy_prop_visit_assignment): Do not check loop depth.
	(copy_prop_visit_stmt): Remove write-only variable ann.
	(init_copy_prop): Check variable loop depth here.  Do not simulate
	memory-tag and virtual operand PHIs except for store copy prop.

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

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index f7679d1..1c96801 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,12 @@
+2006-03-30  Paolo Bonzini  <bonzini@gnu.org>
+
+       PR tree-optimization/26830
+
+       * tree-ssa-copy.c (copy_prop_visit_assignment): Do not check loop depth.
+       (copy_prop_visit_stmt): Remove write-only variable ann.
+       (init_copy_prop): Check variable loop depth here.  Do not simulate
+       memory-tag and virtual operand PHIs except for store copy prop.
+
 2006-03-30  Richard Guenther  <rguenther@suse.de>
 
        * config/i386/i386.c: Remove builtins for SSE2 ABI intrinsic

diff --git a/gcc/tree-ssa-copy.c b/gcc/tree-ssa-copy.c
index ea8a39e..d3bc533 100644 (file)
--- a/gcc/tree-ssa-copy.c
+++ b/gcc/tree-ssa-copy.c
@@ -550,14 +550,6 @@ copy_prop_visit_assignment (tree stmt, tree *result_p)
       if (!may_propagate_copy (lhs, rhs))
        return SSA_PROP_VARYING;
 
-      /* Avoid copy propagation from an inner into an outer loop.
-        Otherwise, this may move loop variant variables outside of
-        their loops and prevent coalescing opportunities.  If the
-        value was loop invariant, it will be hoisted by LICM and
-        exposed for copy propagation.  */
-      if (loop_depth_of_name (rhs) > loop_depth_of_name (lhs))
-       return SSA_PROP_VARYING;
-
       /* Notice that in the case of assignments, we make the LHS be a
         copy of RHS's value, not of RHS itself.  This avoids keeping
         unnecessary copy-of chains (assignments cannot be in a cycle
@@ -671,7 +663,6 @@ copy_prop_visit_cond_stmt (tree stmt, edge *taken_edge_p)
 static enum ssa_prop_result
 copy_prop_visit_stmt (tree stmt, edge *taken_edge_p, tree *result_p)
 {
-  stmt_ann_t ann;
   enum ssa_prop_result retval;
 
   if (dump_file && (dump_flags & TDF_DETAILS))
@@ -681,8 +672,6 @@ copy_prop_visit_stmt (tree stmt, edge *taken_edge_p, tree *result_p)
       fprintf (dump_file, "\n");
     }
 
-  ann = stmt_ann (stmt);
-
   if (TREE_CODE (stmt) == MODIFY_EXPR
       && TREE_CODE (TREE_OPERAND (stmt, 1)) == SSA_NAME
       && (do_store_copy_prop
@@ -856,37 +845,54 @@ init_copy_prop (void)
   FOR_EACH_BB (bb)
     {
       block_stmt_iterator si;
-      tree phi;
+      tree phi, def;
+      int depth = bb->loop_depth;
 
       for (si = bsi_start (bb); !bsi_end_p (si); bsi_next (&si))
        {
          tree stmt = bsi_stmt (si);
+         ssa_op_iter iter;
 
          /* The only statements that we care about are those that may
             generate useful copies.  We also need to mark conditional
             jumps so that their outgoing edges are added to the work
-            lists of the propagator.  */
+            lists of the propagator.
+
+            Avoid copy propagation from an inner into an outer loop.
+            Otherwise, this may move loop variant variables outside of
+            their loops and prevent coalescing opportunities.  If the
+            value was loop invariant, it will be hoisted by LICM and
+            exposed for copy propagation.  */
          if (stmt_ends_bb_p (stmt))
            DONT_SIMULATE_AGAIN (stmt) = false;
-         else if (stmt_may_generate_copy (stmt))
+         else if (stmt_may_generate_copy (stmt)
+                  && loop_depth_of_name (TREE_OPERAND (stmt, 1)) <= depth)
            DONT_SIMULATE_AGAIN (stmt) = false;
          else
-           {
-             tree def;
-             ssa_op_iter iter;
-
-             /* No need to simulate this statement anymore.  */
-             DONT_SIMULATE_AGAIN (stmt) = true;
-
-             /* Mark all the outputs of this statement as not being
-                the copy of anything.  */
-             FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_ALL_DEFS)
-               set_copy_of_val (def, def, NULL_TREE);
-           }
+           DONT_SIMULATE_AGAIN (stmt) = true;
+
+         /* Mark all the outputs of this statement as not being
+            the copy of anything.  */
+         FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_ALL_DEFS)
+           if (DONT_SIMULATE_AGAIN (stmt))
+             set_copy_of_val (def, def, NULL_TREE);
+           else
+             cached_last_copy_of[SSA_NAME_VERSION (def)] = def;
        }
 
       for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
-       DONT_SIMULATE_AGAIN (phi) = false;
+       {
+         def = PHI_RESULT (phi);
+         if (!do_store_copy_prop && !is_gimple_reg (def))
+           DONT_SIMULATE_AGAIN (phi) = true;
+         else
+           DONT_SIMULATE_AGAIN (phi) = false;
+
+         if (DONT_SIMULATE_AGAIN (phi))
+           set_copy_of_val (def, def, NULL_TREE);
+         else
+           cached_last_copy_of[SSA_NAME_VERSION (def)] = def;
+       }
     }
 }