more grange/parameter cleanups

From-SVN: r275556

4 files changed, 24 insertions, 124 deletions

diff --git a/gcc/grange.cc b/gcc/grange.cc
index 32d83c5ea59..2a15f331109 100644
--- a/gcc/grange.cc
+++ b/gcc/grange.cc
@@ -270,16 +270,11 @@ gimple_range_operand1 (const grange *s)
 // result in RES.  Return false if the operation fails.
 
 bool
-gimple_range_fold (const grange *s, irange &res, const irange &orig_r1)
+gimple_range_fold (const grange *s, irange &res, const irange &r1)
 {
-  tree lhs = gimple_range_lhs (s);;
-  irange r1, r2;
-  r1 = orig_r1;
+  tree type = gimple_expr_type (s);;
+  irange r2 (type);
   // Single ssa operations require the LHS type as the second range.
-  if (lhs)
-    r2.set_varying (TREE_TYPE (lhs));
-  else
-    r2.set_undefined ();
 
   return gimple_range_fold (s, res, r1, r2);
 }
diff --git a/gcc/ssa-range-gori.cc b/gcc/ssa-range-gori.cc
index fd4035edd8a..a0ab1517192 100644
--- a/gcc/ssa-range-gori.cc
+++ b/gcc/ssa-range-gori.cc
@@ -1051,7 +1051,7 @@ gori_compute::reevaluate_definition (irange &r, tree name, edge e,
 	  // Invoke basic range calculator for the statement so we dont
 	  // get any dynamic calls to range_of_expr which could cause another
 	  // iterative evaluation to fill a cache.
-	  ssa_ranger eval;
+	  stmt_ranger eval;
 	  gcc_assert (eval.range_of_stmt_with_range (r, def_stmt, use,
 						     use_range));
 	  // If this is the root def and it has a range, combine them.
diff --git a/gcc/ssa-range.cc b/gcc/ssa-range.cc
index e7b8399b277..88603a698bc 100644
--- a/gcc/ssa-range.cc
+++ b/gcc/ssa-range.cc
@@ -72,6 +72,7 @@ stmt_ranger::range_of_expr (irange &r, tree expr, gimple *s)
   else
     type = TREE_TYPE (expr);
 
+  // Return false if the type isn't suported.
   if (!irange::supports_type_p (type))
     return false;
 
@@ -176,28 +177,6 @@ stmt_ranger::range_of_stmt_with_range (irange &r, gimple *s, tree name,
   return false;
 }
 
-// Calculate a range for range_op statement S given RANGE1 and RANGE2 and 
-// return it in R.  If a range cannot be calculated, return false.  
-// If valid is false, then one or more of the ranges are invalid, and
-// return false.
-
-inline bool
-stmt_ranger::range_of_grange_core (irange &r, grange *s, bool valid,
-				     irange &range1, irange &range2)
-{
-  if (valid)
-    {
-      if (gimple_range_operand2 (s))
-	valid = gimple_range_fold (s, r, range1, range2);
-      else
-	valid = gimple_range_fold (s, r, range1);
-    }
-
-  // If range_of_expr or fold() fails, return varying.
-  if (!valid)
-    r.set_varying (gimple_expr_type (s));
-  return true;
-}
 
 // Calculate a range for range_op statement S and return it in R.  If any
 // operand matches NAME, replace it with NAME_RANGE.  If a range
@@ -209,7 +188,8 @@ stmt_ranger::range_of_grange (irange &r, grange *s, tree name,
 {
   irange range1, range2;
   bool res = true;
-  gcc_checking_assert (irange::supports_type_p (gimple_expr_type (s)));
+  tree type = gimple_expr_type (s);
+  gcc_checking_assert (irange::supports_type_p (type));
 
   tree op1 = gimple_range_operand1 (s);
   tree op2 = gimple_range_operand2 (s);
@@ -220,16 +200,20 @@ stmt_ranger::range_of_grange (irange &r, grange *s, tree name,
   else
     res = range_of_expr (range1, op1, s);
 
-  // Calculate a result for op2 if it is needed.
-  if (res && op2)
+  if (res)
     {
+      if (!op2)
+	return gimple_range_fold (s, r, range1);
+
       if (op2 == name)
 	range2 = *name_range;
       else
 	res = range_of_expr (range2, op2, s);
+      if (res) 
+	return gimple_range_fold (s, r, range1, range2);
     }
-
-  return range_of_grange_core (r, s, res, range1, range2);
+  r.set_varying (type);
+  return true;
 }
 
 
@@ -243,8 +227,7 @@ stmt_ranger::range_of_grange (irange &r, grange *s, tree name,
 
 bool
 stmt_ranger::range_of_phi (irange &r, gphi *phi, tree name,
-			   const irange *name_range, gimple *eval_from,
-			   edge on_edge)
+			   const irange *name_range)
 {
   tree phi_def = gimple_phi_result (phi);
   tree type = TREE_TYPE (phi_def);
@@ -260,13 +243,10 @@ stmt_ranger::range_of_phi (irange &r, gphi *phi, tree name,
     {
       irange arg_range;
       tree arg = gimple_phi_arg_def (phi, x);
-      edge e = gimple_phi_arg_edge (phi, x);
-      if (on_edge && e != on_edge)
-        continue;
       if (name == arg)
         arg_range = *name_range;
       else 
-	gcc_assert (range_of_expr (arg_range, arg, eval_from));
+	gcc_assert (range_of_expr (arg_range, arg, phi));
 
       r.union_ (arg_range);
       // Once the value reaches varying, stop looking.
@@ -459,34 +439,9 @@ ssa_ranger::range_on_exit (irange &r, basic_block bb, tree name)
 		       || types_compatible_p (r.type(), TREE_TYPE (name)));
 }
 
-// Calculate a range for range_op statement S and return it in R.  Evaluate
-// the statement as if it were on edge EVAL_ON.  If a range cannot be
-// calculated, return false.  
-
-bool
-ssa_ranger::range_of_grange (irange &r, grange *s, edge eval_on)
-{
-  irange range1, range2;
-  bool res = true;
-  gcc_checking_assert (irange::supports_type_p (gimple_expr_type (s)));
-
-  tree op1 = gimple_range_operand1 (s);
-  tree op2 = gimple_range_operand2 (s);
-
-  // Calculate a range for operand 1.
-  range_on_edge (range1, eval_on, op1);
-
-  // Calculate a result for op2 if it is needed.
-  if (op2)
-    range_on_edge (range2, eval_on, op2);
-
-  return range_of_grange_core (r, s, res, range1, range2);
-}
-
 bool
 ssa_ranger::range_of_phi (irange &r, gphi *phi, tree name,
-			   const irange *name_range, gimple *eval_from,
-			   edge on_edge)
+			  const irange *name_range)
 {
   tree phi_def = gimple_phi_result (phi);
   tree type = TREE_TYPE (phi_def);
@@ -503,15 +458,10 @@ ssa_ranger::range_of_phi (irange &r, gphi *phi, tree name,
       irange arg_range;
       tree arg = gimple_phi_arg_def (phi, x);
       edge e = gimple_phi_arg_edge (phi, x);
-      if (on_edge && e != on_edge)
-        continue;
       if (name == arg)
         arg_range = *name_range;
-      else if (valid_range_ssa_p (arg) && !eval_from)
-      // Try to find a range from the edge.  If that fails, return varying.
+      else 
 	range_on_edge (arg_range, e, arg);
-      else
-	gcc_assert (range_of_expr (arg_range, arg, eval_from));
 
       r.union_ (arg_range);
       // Once the value reaches varying, stop looking.
@@ -522,41 +472,6 @@ ssa_ranger::range_of_phi (irange &r, gphi *phi, tree name,
   return true;
 }
 
-// Calculate a range for COND_EXPR statement S and return it in R.  Evaluate 
-// the stateemnt as if it occured on edge ON_EDGE.
-// If a range cannot be calculated, return false. 
-
-bool
-ssa_ranger::range_of_cond_expr  (irange &r, gassign *s, edge on_edge)
-{
-  irange cond_range, range1, range2;
-  tree cond = gimple_assign_rhs1 (s);
-  tree op1 = gimple_assign_rhs2 (s);
-  tree op2 = gimple_assign_rhs3 (s);
-
-  gcc_checking_assert (gimple_assign_rhs_code (s) == COND_EXPR);
-  gcc_checking_assert (useless_type_conversion_p  (TREE_TYPE (op1),
-						   TREE_TYPE (op2)));
-  if (!irange::supports_type_p (TREE_TYPE (op1)))
-    return false;
-
-  range_on_edge (cond_range, on_edge, cond);
-  range_on_edge (range1, on_edge, op1);
-  range_on_edge (range2, on_edge, op2);
-
-  if (cond_range.singleton_p ())
-    {
-      // False, pick second operand
-      if (cond_range.zero_p ())
-        r = range2;
-      else
-        r = range1;
-    }
-  else
-    r = range_union (range1, range2);
-  return true;
-}
-
 // -------------------------------------------------------------------------
 
 // Initialize a global_ranger.
@@ -907,11 +822,9 @@ loop_ranger::adjust_phi_with_loop_info (irange &r, gphi *phi)
 
 bool
 loop_ranger::range_of_phi (irange &r, gphi *phi, tree name,
-			   const irange *name_range, gimple *eval_from,
-			   edge on_edge)
+			   const irange *name_range)
 {
-  bool result = global_ranger::range_of_phi (r, phi, name, name_range,
-					     eval_from, on_edge);
+  bool result = global_ranger::range_of_phi (r, phi, name, name_range);
   if (result && scev_initialized_p ())
     adjust_phi_with_loop_info (r, phi);
   return result;
diff --git a/gcc/ssa-range.h b/gcc/ssa-range.h
index b381a4ee09b..121b1499505 100644
--- a/gcc/ssa-range.h
+++ b/gcc/ssa-range.h
@@ -52,15 +52,11 @@ class stmt_ranger
   virtual bool range_of_stmt_with_range (irange &r, gimple *s, tree name,
 					 const irange &name_range);
 protected:
-  // Calculate a range for a kind of gimple statement .
-  bool range_of_grange_core (irange &r, grange *s, bool valid,
-			       irange &range1, irange &range2);
   bool range_of_grange  (irange &r, grange *s, tree name = NULL_TREE,
 			 const irange *name_range = NULL);
 
   virtual bool range_of_phi (irange &r, gphi *phi, tree name = NULL_TREE,
-			     const irange *name_range = NULL,
-			     gimple *eval_from = NULL, edge on_edge = NULL);
+			     const irange *name_range = NULL);
 
   bool range_of_call (irange &r, gcall *call, tree name = NULL_TREE,
 		      const irange *name_range = NULL,
@@ -82,11 +78,8 @@ class ssa_ranger : public stmt_ranger
 				      irange *name_range = NULL);
   
 protected:
-  bool range_of_cond_expr (irange &r, gassign* call, edge on_edge);
-  bool range_of_grange  (irange &r, grange *s, edge on_edge);
   virtual bool range_of_phi (irange &r, gphi *phi, tree name = NULL_TREE,
-			     const irange *name_range = NULL,
-			     gimple *eval_from = NULL, edge on_edge = NULL);
+			     const irange *name_range = NULL);
 };
 
 // This class utilizes the gori summary to query the range
@@ -151,8 +144,7 @@ public:
 private:
   void adjust_phi_with_loop_info (irange &r, gphi *phi);
   virtual bool range_of_phi (irange &r, gphi *phi, tree name,
-			     const irange *name_range, gimple *eval_from,
-			     edge on_edge);
+			     const irange *name_range);
 
   vr_values *m_vr_values;
 };