Add recomputation to outgoing_edge_range.

The gori engine can calculate outgoing ranges for exported values.  This
change allows 1st degree recomputation.  If a name is not exported from a
block, but one of the ssa_names used directly in computing it is, then
we can recompute the ssa_name on the edge using the edge values for its
operands.

	* gimple-range-gori.cc (gori_compute::has_edge_range_p): Check with
	may_recompute_p.
	(gori_compute::may_recompute_p): New.
	(gori_compute::outgoing_edge_range_p): Perform recomputations.
	* gimple-range-gori.h (class gori_compute): Add prototype.

diff --git a/gcc/gimple-range-gori.cc b/gcc/gimple-range-gori.cc
index 09dcd694319b81c6077582b7e15b0af8526858ea..647f4964769aa2f805b5d43b3f224fe2424f3711 100644 (file)
--- a/gcc/gimple-range-gori.cc
+++ b/gcc/gimple-range-gori.cc
@@ -972,16 +972,18 @@ gori_compute::compute_operand1_and_operand2_range (irange &r,
   r.intersect (op_range);
   return true;
 }
-// Return TRUE if a range can be calcalated for NAME on edge E.
+// Return TRUE if a range can be calculated or recomputed for NAME on edge E.
 
 bool
 gori_compute::has_edge_range_p (tree name, edge e)
 {
-  // If no edge is specified, check if NAME is an export on any edge.
-  if (!e)
-    return is_export_p (name);
+  // Check if NAME is an export or can be recomputed.
+  if (e)
+    return is_export_p (name, e->src) || may_recompute_p (name, e);
 
-  return is_export_p (name, e->src);
+  // If no edge is specified, check if NAME can have a range calculated
+  // on any edge.
+  return is_export_p (name) || may_recompute_p (name);
 }
 
 // Dump what is known to GORI computes to listing file F.
@@ -992,6 +994,32 @@ gori_compute::dump (FILE *f)
   gori_map::dump (f);
 }
 
+// Return TRUE if NAME can be recomputed on edge E.  If any direct dependant
+// is exported on edge E, it may change the computed value of NAME.
+
+bool
+gori_compute::may_recompute_p (tree name, edge e)
+{
+  tree dep1 = depend1 (name);
+  tree dep2 = depend2 (name);
+
+  // If the first dependency is not set, there is no recompuation.
+  if (!dep1)
+    return false;
+
+  // Don't recalculate PHIs or statements with side_effects.
+  gimple *s = SSA_NAME_DEF_STMT (name);
+  if (is_a<gphi *> (s) || gimple_has_side_effects (s))
+    return false;
+
+  // If edge is specified, check if NAME can be recalculated on that edge.
+  if (e)
+    return ((is_export_p (dep1, e->src))
+           || (dep2 && is_export_p (dep2, e->src)));
+
+  return (is_export_p (dep1)) || (dep2 && is_export_p (dep2));
+}
+
 // Calculate a range on edge E and return it in R.  Try to evaluate a
 // range for NAME on this edge.  Return FALSE if this is either not a
 // control edge or NAME is not defined by this edge.
@@ -1026,6 +1054,27 @@ gori_compute::outgoing_edge_range_p (irange &r, edge e, tree name,
          return true;
        }
     }
+  // If NAME isn't exported, check if it can be recomputed.
+  else if (may_recompute_p (name, e))
+    {
+      gimple *def_stmt = SSA_NAME_DEF_STMT (name);
+
+      if (dump_file && (dump_flags & TDF_DETAILS))
+       {
+         fprintf (dump_file, "recomputation attempt on edge %d->%d for ",
+                  e->src->index, e->dest->index);
+         print_generic_expr (dump_file, name, TDF_SLIM);
+       }
+      // Simply calculate DEF_STMT on edge E usng the range query Q.
+      fold_range (r, def_stmt, e, &q);
+      if (dump_file && (dump_flags & TDF_DETAILS))
+       {
+         fprintf (dump_file, " : Calculated :");
+         r.dump (dump_file);
+         fputc ('\n', dump_file);
+       }
+      return true;
+    }
   return false;
 }
 

diff --git a/gcc/gimple-range-gori.h b/gcc/gimple-range-gori.h
index 06f3b791359baefbb4141594e89bed8dd94696d3..6f187db08cb05c5fc024c4e3227381b60e8edf06 100644 (file)
--- a/gcc/gimple-range-gori.h
+++ b/gcc/gimple-range-gori.h
@@ -157,6 +157,7 @@ public:
   bool has_edge_range_p (tree name, edge e = NULL);
   void dump (FILE *f);
 private:
+  bool may_recompute_p (tree name, edge e = NULL);
   bool compute_operand_range (irange &r, gimple *stmt, const irange &lhs,
                              tree name, class fur_source &src);
   bool compute_operand_range_switch (irange &r, gswitch *s, const irange &lhs,