Rip out all gori and ranger comparison code from EVPR.

Leave the vr_comparison class in for future comparison.

2 files changed, 9 insertions, 243 deletions

diff --git a/gcc/gimple-ssa-evrp-analyze.c b/gcc/gimple-ssa-evrp-analyze.c
index 001f50d..f2757e5 100644
--- a/gcc/gimple-ssa-evrp-analyze.c
+++ b/gcc/gimple-ssa-evrp-analyze.c
@@ -41,36 +41,8 @@ along with GCC; see the file COPYING3.  If not see
 #include "tree-cfgcleanup.h"
 #include "vr-values.h"
 #include "gimple-ssa-evrp-analyze.h"
-#include "dbgcnt.h"
-#include "gimple-range-stmt.h"
 #include "gimple-ranger.h"
 
-class vr_gori_interface : public trace_gori_compute
-{
-public:
-  vr_gori_interface (range_store *store) : store (store) { }
-  virtual bool outgoing_edge_range_p (irange &, edge, tree name,
-				      const irange *name_range = NULL);
-  bool gori_computable_p (tree name, basic_block);
-protected:
-  virtual bool refine_range_with_equivalences (irange &, edge, tree name);
-private:
-  virtual void range_of_ssa_name (irange &r, tree op, gimple * = NULL);
-  bool solve_name_at_statement (irange &, tree, gimple *stmt, const irange &);
-  bool solve_name_given_equivalence (irange &r, tree name, tree equiv,
-				     const irange &equiv_range);
-  range_store *store;
-};
-
-class trace_vr_gori_interface : public vr_gori_interface
-{
-public:
-  trace_vr_gori_interface (range_store *store) : vr_gori_interface (store) { }
-private:
-  virtual bool refine_range_with_equivalences (irange &, edge, tree name);
-  typedef vr_gori_interface super;
-};
-
 evrp_range_analyzer::evrp_range_analyzer (bool update_global_ranges)
   : stack (10), m_update_global_ranges (update_global_ranges)
 {
@@ -84,16 +56,6 @@ evrp_range_analyzer::evrp_range_analyzer (bool update_global_ranges)
         e->flags |= EDGE_EXECUTABLE;
     }
   vr_values = new class vr_values_tester;
-  ranger = new trace_ranger;
-  gori = new trace_vr_gori_interface (vr_values);
-}
-
-evrp_range_analyzer::~evrp_range_analyzer (void)
-{
-  delete vr_values;
-  stack.release ();
-  delete ranger;
-  delete gori;
 }
 
 /* Push an unwinding marker onto the unwinding stack.  */
@@ -191,146 +153,6 @@ all_uses_feed_or_dominated_by_stmt (tree name, gimple *stmt)
   return true;
 }
 
-void
-vr_gori_interface::range_of_ssa_name (irange &r, tree op,
-				      gimple *stmt ATTRIBUTE_UNUSED)
-{
-  r = *store->get_value_range (op);
-  if (r.undefined_p ())
-    r.set_varying (TREE_TYPE (op));
-  r.normalize_symbolics ();
-}
-
-// Return TRUE if NAME is computable by GORI in BB.
-
-bool
-vr_gori_interface::gori_computable_p (tree name, basic_block bb)
-{
-  return m_gori_map.is_export_p (name, bb);
-}
-
-// Calculate the range for NAME on edge E and return it in R.
-// Return FALSE if unable to compute a range.
-
-bool
-vr_gori_interface::outgoing_edge_range_p (irange &r, edge e, tree name,
-				const irange *known_range ATTRIBUTE_UNUSED)
-{
-  if (!gori_compute_cache::outgoing_edge_range_p (r, e, name))
-    r.set_varying (TREE_TYPE (name));
-  if (!r.singleton_p ())
-    refine_range_with_equivalences (r, e, name);
-  widest_irange tmp;
-  range_of_ssa_name (tmp, name);
-  r.intersect (tmp);
-  return !r.varying_p ();
-}
-
-// R is a known range for NAME on edge E.  Refine it with any
-// equivalences NAME may have.
-
-bool
-vr_gori_interface::refine_range_with_equivalences (irange &r,
-						   edge e, tree name)
-{
-  widest_irange branch_range, tmp;
-  gimple *branch = gimple_outgoing_edge_range_p (branch_range, e);
-  if (!branch)
-    return false;
-
-  // Solve each equivalence and use them to refine the range.
-  bitmap_iterator bi;
-  unsigned i;
-  bitmap gori_exports = m_gori_map.exports (e->src);
-  EXECUTE_IF_SET_IN_BITMAP (gori_exports, 0, i, bi)
-    {
-      tree equiv = ssa_name (i);
-      if (equiv == name)
-	continue;
-      widest_irange equiv_range;
-      if (solve_name_at_statement (equiv_range, equiv, branch, branch_range))
-	{
-	  gimple *equiv_def = SSA_NAME_DEF_STMT (equiv);
-	  if (!equiv_def->bb
-	      || !dominated_by_p (CDI_DOMINATORS, e->src, equiv_def->bb))
-	    continue;
-
-	  if (solve_name_given_equivalence (tmp, name, equiv, equiv_range))
-	    r.intersect (tmp);
-	}
-    }
-  return !r.varying_p ();
-}
-
-// Compute a range for NAME as it would appear in STMT and return it
-// in R.  LHS is the known range for STMT.
-
-bool
-vr_gori_interface::solve_name_at_statement (irange &r,
-					    tree name, gimple *stmt,
-					    const irange &lhs)
-{
-  widest_irange name_range;
-  range_of_ssa_name (name_range, name, stmt);
-  return compute_operand_range (r, stmt, lhs, name, &name_range);
-}
-
-bool
-vr_gori_interface::solve_name_given_equivalence (irange &r,
-						 tree name,
-						 tree equiv,
-						 const irange &equiv_range)
-{
-  // Solve NAME in EQUIV = USE(NAME).
-  gimple *def = SSA_NAME_DEF_STMT (equiv);
-  if (gimple_range_handler (def) && gimple_range_operand1 (def) == name)
-    {
-      widest_irange op2_range;
-      if (tree op2 = gimple_range_operand2 (def))
-	range_of_expr (op2_range, op2, def);
-      else
-	{
-	  tree type = TREE_TYPE (gimple_range_operand1 (def));
-	  op2_range.set_varying (type);
-	}
-      return gimple_range_calc_op1 (def, r, equiv_range, op2_range);
-    }
-  // Solve NAME in NAME = USE(EQUIV).
-  def =  SSA_NAME_DEF_STMT (name);
-  if (gimple_range_handler (def) && gimple_range_operand1 (def) == equiv)
-    {
-      widest_irange op2_range;
-      if (tree op2 = gimple_range_operand2 (def))
-	range_of_expr (op2_range, op2, def);
-      else
-	{
-	  tree type = gimple_expr_type (def);
-	  op2_range.set_varying (type);
-	}
-      return gimple_range_fold (def, r, equiv_range, op2_range);
-    }
-  return false;
-}
-
-bool
-trace_vr_gori_interface::refine_range_with_equivalences (irange &r,
-							   edge e, tree name)
-{
-  unsigned idx = ++trace_count;
-  if (dumping (idx))
-    {
-      fprintf (dump_file, "refine_range_with_equivalences (");
-      print_generic_expr (dump_file, name, TDF_SLIM);
-      fprintf (dump_file, ") on edge %d->%d, with range ",
-	       e->src->index, e->dest->index);
-      r.dump (dump_file);
-      fputc ('\n', dump_file);
-      indent += bump;
-    }
-  bool res = super::refine_range_with_equivalences (r, e, name);
-  return trailer (idx, "refine_range_with_equivalences", res, name, r);
-}
-
 // ?? Eventually overload extract_range_from_stmt instead, since it is
 // higher level and more comparable to gimple_ranger::range_of_stmt.
 
@@ -361,65 +183,6 @@ vr_values_tester::extract_range_basic (value_range_equiv *vr, gimple *stmt)
   comp.compare (stmt);
 }
 
-value_range_equiv *
-evrp_range_analyzer::try_find_new_range_for_assert (const assert_info &assert,
-						    edge e)
-{
-  tree name = assert.name;
-  widest_irange vr_gori;
-  widest_irange vr_ranger;
-  widest_irange tmp;
-  bitmap_iterator bi;
-  bool gori_can_calculate = (assert.gori_computable_p
-			     && gori->gori_computable_p (name, e->src));
-
-  gori_can_calculate = false;
-  if (gori_can_calculate)
-    {
-      if (!gori->outgoing_edge_range_p (vr_gori, e, name))
-	vr_gori.set_varying (TREE_TYPE (name));
-    }
-
-  value_range_equiv *vr
-    = try_find_new_range (name, assert.expr, assert.comp_code, assert.val);
-
-  ranger->range_on_edge (vr_ranger, e, name);
-  if (vr && vr->equiv() && !bitmap_empty_p (vr->equiv ()))
-    {
-      unsigned x;
-      EXECUTE_IF_SET_IN_BITMAP (vr->equiv (), 0, x, bi)
-	{
-	  if (ssa_name (x) == name)
-	    continue;
-	  ranger->range_on_edge (tmp, e, ssa_name (x));
-	  vr_ranger.intersect (tmp);
-	}
-    }
-
-//  if (vr && gori_can_calculate)
-//    {
-//      tmp = vr_ranger;
-//      tmp.union_ (*vr);
-//      gcc_assert (tmp == *vr);
-//    }
-
-  if (gori_can_calculate)
-    {
-      if (CHECKING_P && dbg_cnt (evrp_find_range))
-	{
-	  vr_comparison comp (vr, &vr_gori, vr_values);
-	  comp.compare (name, e);
-	}
-      if (!vr)
-	{
-	  vr = vr_values->allocate_value_range_equiv ();
-	  vr->set_varying (TREE_TYPE (name));
-	}
-      static_cast <irange *> (vr)->intersect (vr_gori);
-    }
-  return vr;
-}
-
 void
 evrp_range_analyzer::record_ranges_from_incoming_edge (basic_block bb)
 {
@@ -457,7 +220,10 @@ evrp_range_analyzer::record_ranges_from_incoming_edge (basic_block bb)
 	  for (unsigned i = 0; i < asserts.length (); ++i)
 	    {
 	      value_range_equiv *vr
-		= try_find_new_range_for_assert (asserts[i], pred_e);
+		= try_find_new_range (asserts[i].name,
+				      asserts[i].expr,
+				      asserts[i].comp_code,
+				      asserts[i].val);
 	      if (vr)
 		vrs.safe_push (std::make_pair (asserts[i].name, vr));
 	    }
diff --git a/gcc/gimple-ssa-evrp-analyze.h b/gcc/gimple-ssa-evrp-analyze.h
index d157191..8abbbe3 100644
--- a/gcc/gimple-ssa-evrp-analyze.h
+++ b/gcc/gimple-ssa-evrp-analyze.h
@@ -24,7 +24,11 @@ class evrp_range_analyzer
 {
  public:
   evrp_range_analyzer (bool update_global_ranges);
-  ~evrp_range_analyzer (void);
+  ~evrp_range_analyzer (void)
+  {
+    delete vr_values;
+    stack.release ();
+  }
 
   void enter (basic_block);
   void push_marker (void);
@@ -62,7 +66,6 @@ class evrp_range_analyzer
   class vr_values *vr_values;
 
   void pop_value_range ();
-  value_range_equiv *try_find_new_range_for_assert (const assert_info &, edge);
   value_range_equiv *try_find_new_range (tree, tree op, tree_code code,
 					 tree limit);
   void record_ranges_from_incoming_edge (basic_block);
@@ -74,9 +77,6 @@ class evrp_range_analyzer
 
   /* True if we are updating global ranges, false otherwise.  */
   bool m_update_global_ranges;
-
-  class trace_vr_gori_interface *gori;
-  class gimple_ranger *ranger;
 };
 
 #endif /* GCC_GIMPLE_SSA_EVRP_ANALYZE_H */