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.

diff --git a/gcc/gimple-range-cache.cc b/gcc/gimple-range-cache.cc
index c52475852a97a507a530e660d710e4a63441fe24..40e4baa6289515cc63e928628bc8bf7f121cef4d 100644 (file)
--- 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 ce8b04f6bada1ec605ea9bdf42fb488f703f9deb..be1f0c2cc15ae48325f453b79daadac43391978c 100644 (file)
--- 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 b626855c51a13209ef932b532027a61be7a304f0..37c16761ba6f4198939c7239530cbd0eeb132256 100644 (file)
--- 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 fa4a235f08b4feb6afcd7ad7cb4577df913106e7..a75430642587c0c619090dcf250274249d34f722 100644 (file)
--- 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 ae857ecb2b5655b4ecf79200a90f487382b50fae..c7a707ee72450acded92c66c18d2e08c99790c50 100644 (file)
--- 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 5043c00d482cc54d27ba0924100ad48bfc624eb8..03f73218a57d28269f43c59bab07b247bec0cda9 100644 (file)
--- 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 9c284ce26ae155060703aeb1449e218d56563bca..14b0df1aefe720460b254f68d4052f804de29ea1 100644 (file)
--- 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 ())