Gori_compute inherits from gimple_outgoing_range.

Make gimple_outgoing_range a base class for the GORI API, and provide
base routines returning false.   gori_compute inherits from
gimple_outgoing_range and no longer needs it as a private member.
Rename outgoing_edge_range_p to edge_range_p.

	* gimple-range-cache.cc (ranger_cache::ranger_cache): Adjust
	m_gori constructor.
	(ranger_cache::edge_range): Use renamed edge_range_p name.
	(ranger_cache::range_from_dom): Likewise.
	* gimple-range-edge.h (gimple_outgoing_range::condexpr_adjust): New.
	(gimple_outgoing_range::has_edge_range_p): New.
	(gimple_outgoing_range::dump): New.
	(gimple_outgoing_range::compute_operand_range): New.
	(gimple_outgoing_range::map): New.
	* gimple-range-fold.cc (fur_source::register_outgoing_edges ): Use
	renamed edge_range_p routine
	* gimple-range-gori.cc (gori_compute::gori_compute): Adjust
	constructor.
	(gori_compute::~gori_compute): New.
	(gori_compute::edge_range_p): Rename from outgoing_edge_range_p
	and use inherited routine instead of member method.
	* gimple-range-gori.h (class gori_compute): Inherit from
	gimple_outgoing_range, adjust protoypes.
	(gori_compute::outgpoing): Delete.
	* gimple-range-path.cc (path_range_query::compute_ranges_in_block): Use
	renamed edge_range_p routine.
	* tree-ssa-loop-unswitch.cc (evaluate_control_stmt_using_entry_checks):
	Likewise.

7 files changed, 36 insertions, 20 deletions

diff --git a/gcc/gimple-range-cache.cc b/gcc/gimple-range-cache.cc
index c524758..40e4baa 100644
--- a/gcc/gimple-range-cache.cc
+++ b/gcc/gimple-range-cache.cc
@@ -950,7 +950,7 @@ update_list::pop ()
 // --------------------------------------------------------------------------
 
 ranger_cache::ranger_cache (int not_executable_flag, bool use_imm_uses)
-						: m_gori (not_executable_flag)
+  : m_gori (not_executable_flag, param_vrp_switch_limit)
 {
   m_workback.create (0);
   m_workback.safe_grow_cleared (last_basic_block_for_fn (cfun));
@@ -1178,7 +1178,7 @@ ranger_cache::edge_range (vrange &r, edge e, tree name, enum rfd_mode mode)
   if ((e->flags & (EDGE_EH | EDGE_ABNORMAL)) == 0)
     infer_oracle ().maybe_adjust_range (r, name, e->src);
   Value_Range er (TREE_TYPE (name));
-  if (m_gori.outgoing_edge_range_p (er, e, name, *this))
+  if (m_gori.edge_range_p (er, e, name, *this))
     r.intersect (er);
   return true;
 }
@@ -1738,7 +1738,7 @@ ranger_cache::range_from_dom (vrange &r, tree name, basic_block start_bb,
 
       edge e = single_pred_edge (prev_bb);
       bb = e->src;
-      if (m_gori.outgoing_edge_range_p (er, e, name, *this))
+      if (m_gori.edge_range_p (er, e, name, *this))
 	{
 	  r.intersect (er);
 	  // If this is a normal edge, apply any inferred ranges.
diff --git a/gcc/gimple-range-edge.h b/gcc/gimple-range-edge.h
index ce8b04f..be1f0c2 100644
--- a/gcc/gimple-range-edge.h
+++ b/gcc/gimple-range-edge.h
@@ -48,9 +48,22 @@ class gimple_outgoing_range
 {
 public:
   gimple_outgoing_range (int max_sw_edges = 0);
-  ~gimple_outgoing_range ();
+  virtual ~gimple_outgoing_range ();
   gimple *edge_range_p (irange &r, edge e);
   void set_switch_limit (int max_sw_edges = INT_MAX);
+
+  virtual bool edge_range_p (vrange &, edge, tree, range_query &)
+    { return false; }
+  virtual bool condexpr_adjust (vrange &, vrange &, gimple *, tree, tree, tree,
+				class fur_source &) { return false; }
+  virtual bool has_edge_range_p (tree, basic_block = NULL) { return false; }
+  virtual bool has_edge_range_p (tree, edge ) { return false; }
+  virtual void dump (FILE *) { }
+  virtual bool compute_operand_range (vrange &, gimple *, const vrange &, tree,
+				      fur_source &,
+				      class value_relation * = NULL)
+    { return false; }
+  virtual class gori_map *map () { return NULL; }
 private:
   void calc_switch_ranges (gswitch *sw);
   bool switch_edge_range (irange &r, gswitch *sw, edge e);
diff --git a/gcc/gimple-range-fold.cc b/gcc/gimple-range-fold.cc
index b626855..37c1676 100644
--- a/gcc/gimple-range-fold.cc
+++ b/gcc/gimple-range-fold.cc
@@ -1368,14 +1368,14 @@ fur_source::register_outgoing_edges (gcond *s, irange &lhs_range,
 	{
 	  r1.set_varying (TREE_TYPE (ssa1));
 	  r2.set_varying (TREE_TYPE (ssa2));
-	  if (e0 && gori ()->outgoing_edge_range_p (r, e0, name, *m_query)
+	  if (e0 && gori ()->edge_range_p (r, e0, name, *m_query)
 	      && r.singleton_p ())
 	    {
 	      relation_kind relation = handler.op1_op2_relation (r, r1, r2);
 	      if (relation != VREL_VARYING)
 		register_relation (e0, relation, ssa1, ssa2);
 	    }
-	  if (e1 && gori ()->outgoing_edge_range_p (r, e1, name, *m_query)
+	  if (e1 && gori ()->edge_range_p (r, e1, name, *m_query)
 	      && r.singleton_p ())
 	    {
 	      relation_kind relation = handler.op1_op2_relation (r, r1, r2);
diff --git a/gcc/gimple-range-gori.cc b/gcc/gimple-range-gori.cc
index fa4a235..a754306 100644
--- a/gcc/gimple-range-gori.cc
+++ b/gcc/gimple-range-gori.cc
@@ -557,8 +557,8 @@ debug (gori_map &g)
 
 // Construct a gori_compute object.
 
-gori_compute::gori_compute (int not_executable_flag)
-		      : outgoing (param_vrp_switch_limit), tracer ("GORI ")
+gori_compute::gori_compute (int not_executable_flag, int sw_max_edges)
+  : gimple_outgoing_range (sw_max_edges), tracer ("GORI ")
 {
   m_not_executable_flag = not_executable_flag;
   // Create a boolean_type true and false range.
@@ -568,6 +568,10 @@ gori_compute::gori_compute (int not_executable_flag)
     tracer.enable_trace ();
 }
 
+gori_compute::~gori_compute ()
+{
+}
+
 // Given the switch S, return an evaluation in R for NAME when the lhs
 // evaluates to LHS.  Returning false means the name being looked for
 // was not resolvable.
@@ -1380,8 +1384,7 @@ gori_compute::has_edge_range_p (tree name, edge e)
 // control edge or NAME is not defined by this edge.
 
 bool
-gori_compute::outgoing_edge_range_p (vrange &r, edge e, tree name,
-				     range_query &q)
+gori_compute::edge_range_p (vrange &r, edge e, tree name, range_query &q)
 {
   unsigned idx;
 
@@ -1397,7 +1400,7 @@ gori_compute::outgoing_edge_range_p (vrange &r, edge e, tree name,
   gcc_checking_assert (gimple_range_ssa_p (name));
   int_range_max lhs;
   // Determine if there is an outgoing edge.
-  gimple *stmt = outgoing.edge_range_p (lhs, e);
+  gimple *stmt = gimple_outgoing_range::edge_range_p (lhs, e);
   if (!stmt)
     return false;
 
diff --git a/gcc/gimple-range-gori.h b/gcc/gimple-range-gori.h
index ae857ec..c7a707e 100644
--- a/gcc/gimple-range-gori.h
+++ b/gcc/gimple-range-gori.h
@@ -127,7 +127,7 @@ private:
 //   on *ANY* edge that has been seen.  FALSE indicates that the global value
 //   is applicable everywhere that has been processed.
 //
-// outgoing_edge_range_p (vrange &range, edge e, tree name)
+// edge_range_p (vrange &range, edge e, tree name)
 //   Actually does the calculation of RANGE for name on E
 //   This represents application of whatever static range effect edge E
 //   may have on NAME, not any cumulative effect.
@@ -161,11 +161,12 @@ private:
 
 class value_relation;
 
-class gori_compute
+class gori_compute : public gimple_outgoing_range
 {
 public:
-  gori_compute (int not_executable_flag = 0);
-  bool outgoing_edge_range_p (vrange &r, edge e, tree name, range_query &q);
+  gori_compute (int not_executable_flag = 0, int max_sw_edges = 0);
+  virtual ~gori_compute ();
+  bool edge_range_p (vrange &r, edge e, tree name, range_query &q);
   bool condexpr_adjust (vrange &r1, vrange &r2, gimple *s, tree cond, tree op1,
 			tree op2, fur_source &src);
   bool has_edge_range_p (tree name, basic_block bb = NULL);
@@ -205,7 +206,6 @@ private:
   int_range<2> m_bool_zero;	// Boolean false cached.
   int_range<2> m_bool_one;	// Boolean true cached.
 
-  gimple_outgoing_range outgoing;	// Edge values for COND_EXPR & SWITCH_EXPR.
   range_tracer tracer;
   int m_not_executable_flag;
 };
diff --git a/gcc/gimple-range-path.cc b/gcc/gimple-range-path.cc
index 5043c00..03f7321 100644
--- a/gcc/gimple-range-path.cc
+++ b/gcc/gimple-range-path.cc
@@ -415,7 +415,7 @@ path_range_query::compute_ranges_in_block (basic_block bb)
     {
       tree name = ssa_name (i);
       Value_Range r (TREE_TYPE (name));
-      if (g.outgoing_edge_range_p (r, e, name, *this))
+      if (g.edge_range_p (r, e, name, *this))
 	{
 	  Value_Range cached_range (TREE_TYPE (name));
 	  if (get_cache (cached_range, name))
@@ -424,7 +424,7 @@ path_range_query::compute_ranges_in_block (basic_block bb)
 	  m_cache.set_range (name, r);
 	  if (DEBUG_SOLVER)
 	    {
-	      fprintf (dump_file, "outgoing_edge_range_p for ");
+	      fprintf (dump_file, "edge_range_p for ");
 	      print_generic_expr (dump_file, name, TDF_SLIM);
 	      fprintf (dump_file, " on edge %d->%d ",
 		       e->src->index, e->dest->index);
diff --git a/gcc/tree-ssa-loop-unswitch.cc b/gcc/tree-ssa-loop-unswitch.cc
index 9c284ce..14b0df1 100644
--- a/gcc/tree-ssa-loop-unswitch.cc
+++ b/gcc/tree-ssa-loop-unswitch.cc
@@ -763,8 +763,8 @@ evaluate_control_stmt_using_entry_checks (gimple *stmt,
 	    continue;
 
 	  int_range_max r;
-	  if (!ranger->gori ().outgoing_edge_range_p (r, e, idx,
-						      *get_global_range_query ()))
+	  if (!ranger->gori ().edge_range_p (r, e, idx,
+					     *get_global_range_query ()))
 	    continue;
 	  r.intersect (path_range);
 	  if (r.undefined_p ())