[COMMITTED] Minor cleanups to solver.

diff --git a/gcc/gimple-range-path.cc b/gcc/gimple-range-path.cc
index 0738a5ca159..71e04e4deba 100644
--- a/gcc/gimple-range-path.cc
+++ b/gcc/gimple-range-path.cc
@@ -293,11 +293,11 @@  path_range_query::range_defined_in_block (irange &r, tree name, basic_block bb)
   return true;
 }
 
-// Precompute ranges defined in the current block, or ranges
-// that are exported on an edge to the next block.
+// Compute ranges defined in the current block, or exported to the
+// next block.
 
 void
-path_range_query::precompute_ranges_in_block (basic_block bb)
+path_range_query::compute_ranges_in_block (basic_block bb)
 {
   bitmap_iterator bi;
   int_range_max r, cached_range;
@@ -452,14 +452,14 @@  path_range_query::add_copies_to_imports ()
     }
 }
 
-// Precompute the ranges for IMPORTS along PATH.
+// Compute the ranges for IMPORTS along PATH.
 //
 // IMPORTS are the set of SSA names, any of which could potentially
 // change the value of the final conditional in PATH.
 
 void
-path_range_query::precompute_ranges (const vec<basic_block> &path,
-				     const bitmap_head *imports)
+path_range_query::compute_ranges (const vec<basic_block> &path,
+				  const bitmap_head *imports)
 {
   if (DEBUG_SOLVER)
     fprintf (dump_file, "\n*********** path_range_query ******************\n");
@@ -472,12 +472,12 @@  path_range_query::precompute_ranges (const vec<basic_block> &path,
     {
       add_copies_to_imports ();
       m_oracle->reset_path ();
-      precompute_relations (path);
+      compute_relations (path);
     }
 
   if (DEBUG_SOLVER)
     {
-      fprintf (dump_file, "\npath_range_query: precompute_ranges for path: ");
+      fprintf (dump_file, "\npath_range_query: compute_ranges for path: ");
       for (unsigned i = path.length (); i > 0; --i)
 	{
 	  basic_block bb = path[i - 1];
@@ -504,7 +504,7 @@  path_range_query::precompute_ranges (const vec<basic_block> &path,
 	      bitmap_set_bit (m_imports, SSA_NAME_VERSION (name));
 	}
 
-      precompute_ranges_in_block (bb);
+      compute_ranges_in_block (bb);
       adjust_for_non_null_uses (bb);
 
       if (at_exit ())
@@ -611,12 +611,12 @@  path_range_query::range_of_stmt (irange &r, gimple *stmt, tree)
   return true;
 }
 
-// Precompute relations on a path.  This involves two parts: relations
+// Compute relations on a path.  This involves two parts: relations
 // along the conditionals joining a path, and relations determined by
 // examining PHIs.
 
 void
-path_range_query::precompute_relations (const vec<basic_block> &path)
+path_range_query::compute_relations (const vec<basic_block> &path)
 {
   if (!dom_info_available_p (CDI_DOMINATORS))
     return;
@@ -628,7 +628,7 @@  path_range_query::precompute_relations (const vec<basic_block> &path)
       basic_block bb = path[i - 1];
       gimple *stmt = last_stmt (bb);
 
-      precompute_phi_relations (bb, prev);
+      compute_phi_relations (bb, prev);
 
       // Compute relations in outgoing edges along the path.  Skip the
       // final conditional which we don't know yet.
@@ -656,14 +656,14 @@  path_range_query::precompute_relations (const vec<basic_block> &path)
     }
 }
 
-// Precompute relations for each PHI in BB.  For example:
+// Compute relations for each PHI in BB.  For example:
 //
 //   x_5 = PHI<y_9(5),...>
 //
 // If the path flows through BB5, we can register that x_5 == y_9.
 
 void
-path_range_query::precompute_phi_relations (basic_block bb, basic_block prev)
+path_range_query::compute_phi_relations (basic_block bb, basic_block prev)
 {
   if (prev == NULL)
     return;
diff --git a/gcc/gimple-range-path.h b/gcc/gimple-range-path.h
index f7d9832ac8c..cf49c6dc086 100644
--- a/gcc/gimple-range-path.h
+++ b/gcc/gimple-range-path.h
@@ -26,9 +26,6 @@  along with GCC; see the file COPYING3.  If not see
 // will calculate the range of an SSA or STMT as if the BBs in the
 // path would have been executed in order.
 //
-// Only SSA names passed in IMPORTS are precomputed, and can be
-// queried.
-//
 // Note that the blocks are in reverse order, thus the exit block is
 // path[0].
 
@@ -37,8 +34,7 @@  class path_range_query : public range_query
 public:
   path_range_query (class gimple_ranger &ranger, bool resolve);
   virtual ~path_range_query ();
-  void precompute_ranges (const vec<basic_block> &path,
-			  const bitmap_head *imports);
+  void compute_ranges (const vec<basic_block> &, const bitmap_head *imports);
   bool range_of_expr (irange &r, tree name, gimple * = NULL) override;
   bool range_of_stmt (irange &r, gimple *, tree name = NULL) override;
   bool unreachable_path_p ();
@@ -56,13 +52,13 @@  private:
   bool get_cache (irange &r, tree name);
   void clear_cache (tree name);
 
-  // Methods to precompute ranges for the given path.
+  // Methods to compute ranges for the given path.
   bool range_defined_in_block (irange &, tree name, basic_block bb);
-  void precompute_ranges_in_block (basic_block bb);
+  void compute_ranges_in_block (basic_block bb);
   void adjust_for_non_null_uses (basic_block bb);
   void ssa_range_in_phi (irange &r, gphi *phi);
-  void precompute_relations (const vec<basic_block> &);
-  void precompute_phi_relations (basic_block bb, basic_block prev);
+  void compute_relations (const vec<basic_block> &);
+  void compute_phi_relations (basic_block bb, basic_block prev);
   void add_copies_to_imports ();
   bool add_to_imports (tree name, bitmap imports);
 
diff --git a/gcc/tree-ssa-threadbackward.c b/gcc/tree-ssa-threadbackward.c
index 95542079faf..e6819fe148c 100644
--- a/gcc/tree-ssa-threadbackward.c
+++ b/gcc/tree-ssa-threadbackward.c
@@ -192,7 +192,7 @@  back_threader::find_taken_edge_switch (const vec<basic_block> &path,
   tree name = gimple_switch_index (sw);
   int_range_max r;
 
-  m_solver.precompute_ranges (path, m_imports);
+  m_solver.compute_ranges (path, m_imports);
   m_solver.range_of_expr (r, name, sw);
 
   if (r.undefined_p ())
@@ -216,7 +216,7 @@  back_threader::find_taken_edge_cond (const vec<basic_block> &path,
 {
   int_range_max r;
 
-  m_solver.precompute_ranges (path, m_imports);
+  m_solver.compute_ranges (path, m_imports);
   m_solver.range_of_stmt (r, cond);
 
   if (m_solver.unreachable_path_p ())
diff --git a/gcc/tree-ssa-threadedge.c b/gcc/tree-ssa-threadedge.c
index 29ed60a98b0..0b59cb4845c 100644
--- a/gcc/tree-ssa-threadedge.c
+++ b/gcc/tree-ssa-threadedge.c
@@ -1402,12 +1402,6 @@  jt_state::register_equivs_stmt (gimple *stmt, basic_block bb,
 // Hybrid threader implementation.
 
 
-void
-hybrid_jt_state::register_equivs_stmt (gimple *, basic_block, jt_simplifier *)
-{
-  // Ranger has no need to simplify anything to improve equivalences.
-}
-
 hybrid_jt_simplifier::hybrid_jt_simplifier (gimple_ranger *r,
 					    path_range_query *q)
 {
@@ -1466,5 +1460,5 @@  hybrid_jt_simplifier::compute_ranges_from_state (gimple *stmt, jt_state *state)
 	    bitmap_set_bit (imports, SSA_NAME_VERSION (op));
 	}
     }
-  m_query->precompute_ranges (m_path, imports);
+  m_query->compute_ranges (m_path, imports);
 }
diff --git a/gcc/tree-ssa-threadedge.h b/gcc/tree-ssa-threadedge.h
index ac605a3ac30..c46a5c6c489 100644
--- a/gcc/tree-ssa-threadedge.h
+++ b/gcc/tree-ssa-threadedge.h
@@ -56,16 +56,19 @@  public:
 class hybrid_jt_state : public jt_state
 {
 private:
-  void register_equivs_stmt (gimple *, basic_block, jt_simplifier *) override;
+  void register_equivs_stmt (gimple *, basic_block, jt_simplifier *) override
+  {
+    // Ranger has no need to simplify anything.
+  }
 };
 
 class hybrid_jt_simplifier : public jt_simplifier
 {
 public:
   hybrid_jt_simplifier (class gimple_ranger *r, class path_range_query *q);
+  tree simplify (gimple *stmt, gimple *, basic_block, jt_state *) override;
 
 private:
-  tree simplify (gimple *stmt, gimple *, basic_block, jt_state *) override;
   void compute_ranges_from_state (gimple *stmt, jt_state *);
 
   gimple_ranger *m_ranger;