Convert ranger and clients to vrange.

Finally, the meat of the work.  Convert ranger and associated clients
to vrange.

Everything's relatively mechanical given the previous patches.  I did
include a minor cleanup in the edge code.  There's no need to check
that the type of the switch is an integer as non-integer switches are
invalid.  I verified this with an appropriately coded assert.

Tested on x86-64 & ppc64le Linux.

gcc/ChangeLog:

	* gimple-range-cache.cc (ssa_block_ranges::dump): Convert to vrange.
	(sbr_vector::sbr_vector): Same.
	(sbr_vector::grow): Same.
	(sbr_vector::set_bb_range): Same.
	(sbr_vector::get_bb_range): Same.
	(sbr_sparse_bitmap::sbr_sparse_bitmap): Same.
	(sbr_sparse_bitmap::set_bb_range): Same.
	(sbr_sparse_bitmap::get_bb_range): Same.
	(block_range_cache::set_bb_range): Same.
	(block_range_cache::get_bb_range): Same.
	(block_range_cache::dump): Same.
	(ssa_global_cache::get_global_range): Same.
	(ssa_global_cache::set_global_range): Same.
	(ssa_global_cache::clear): Same.
	(ssa_global_cache::dump): Same.
	(ranger_cache::get_global_range): Same.
	(ranger_cache::set_global_range): Same.
	(ranger_cache::range_of_def): Same.
	(ranger_cache::entry_range): Same.
	(ranger_cache::exit_range): Same.
	(ranger_cache::edge_range): Same.
	(ranger_cache::range_of_expr): Same.
	(ranger_cache::range_on_edge): Same.
	(ranger_cache::block_range): Same.
	(ranger_cache::propagate_cache): Same.
	(ranger_cache::fill_block_cache): Same.
	(ranger_cache::range_from_dom): Same.
	* gimple-range-cache.h: Same.
	* gimple-range-edge.cc (gimple_outgoing_range::get_edge_range):
	Same.
	(gimple_outgoing_range::switch_edge_range): Same.
	(gimple_outgoing_range::edge_range_p): Same.
	* gimple-range-edge.h: Same.
	* gimple-range-fold.cc (fur_source::get_operand): Same.
	(fur_source::get_phi_operand): Same.
	(fur_edge::get_operand): Same.
	(fur_edge::get_phi_operand): Same.
	(fur_stmt::get_operand): Same.
	(fur_stmt::get_phi_operand): Same.
	(fur_list::fur_list): Same.
	(fur_list::get_operand): Same.
	(fur_list::get_phi_operand): Same.
	(fold_range): Same.
	(adjust_imagpart_expr): Same.
	(adjust_realpart_expr): Same.
	(gimple_range_adjustment): Same.
	(fold_using_range::fold_stmt): Same.
	(fold_using_range::range_of_range_op): Same.
	(fold_using_range::range_of_address): Same.
	(fold_using_range::range_of_phi): Same.
	(fold_using_range::range_of_call): Same.
	(fold_using_range::range_of_builtin_call): Same.
	(fold_using_range::range_of_builtin_int_call): Same.
	(fold_using_range::range_of_cond_expr): Same.
	(fur_source::register_outgoing_edges): Same.
	* gimple-range-fold.h (fold_range): Same.
	(gimple_range_type): Same.
	(gimple_range_ssa_p): Same.
	* gimple-range-gori.cc (gimple_range_calc_op1): Same.
	(gimple_range_calc_op2): Same.
	(gori_compute::compute_operand_range_switch): Same.
	(gori_compute::compute_operand_range): Same.
	(gori_compute::logical_combine): Same.
	(gori_compute::compute_logical_operands): Same.
	(gori_compute::compute_operand1_range): Same.
	(gori_compute::compute_operand2_range): Same.
	(gori_compute::compute_operand1_and_operand2_range): Same.
	(gori_compute::outgoing_edge_range_p): Same.
	(gori_compute::condexpr_adjust): Same.
	* gimple-range-gori.h (gimple_range_calc_op1): Same.
	(gimple_range_calc_op2): Same.
	* gimple-range-path.cc (path_range_query::get_cache): Same.
	(path_range_query::set_cache): Same.
	(path_range_query::range_on_path_entry): Same.
	(path_range_query::internal_range_of_expr): Same.
	(path_range_query::range_of_expr): Same.
	(path_range_query::ssa_range_in_phi): Same.
	(path_range_query::range_defined_in_block): Same.
	(path_range_query::compute_ranges_in_phis): Same.
	(path_range_query::compute_ranges_in_block): Same.
	(path_range_query::add_to_imports): Same.
	(path_range_query::range_of_stmt): Same.
	* gimple-range-path.h: Same.
	* gimple-range-infer.cc (gimple_infer_range::add_range): Same.
	(gimple_infer_range::~side_effect_manager): Same.
	(gimple_infer_range::get_nonzero): Same.
	(gimple_infer_range::maybe_adjust_range): Same.
	(gimple_infer_range::add_range): Same.
	* gimple-range-infer.h: Same.
	* gimple-range-tests.cc: Same.
	* gimple-range-trace.cc (range_tracer::trailer): Same.
	(debug_seed_ranger): Same.
	* gimple-range-trace.h: Same.
	* gimple-range.cc (gimple_ranger::range_of_expr): Same.
	(gimple_ranger::range_on_entry): Same.
	(gimple_ranger::range_on_exit): Same.
	(gimple_ranger::range_on_edge): Same.
	(gimple_ranger::fold_range_internal): Same.
	(gimple_ranger::range_of_stmt): Same.
	(gimple_ranger::prefill_name): Same.
	(gimple_ranger::prefill_stmt_dependencies): Same.
	(gimple_ranger::export_global_ranges): Same.
	(gimple_ranger::dump_bb): Same.
	* gimple-range.h: Same.
	* gimple-ssa-warn-access.cc (check_nul_terminated_array): Same.
	(memmodel_to_uhwi): Same.
	* tree-ssa-loop-niter.cc (refine_value_range_using_guard): Same.
	(determine_value_range): Same.
	(record_nonwrapping_iv): Same.
	(infer_loop_bounds_from_signedness): Same.
	(scev_var_range_cant_overflow): Same.
	* tree-ssa-threadedge.cc (hybrid_jt_simplifier::simplify): Same.
	* value-query.cc (range_query::range_on_edge): Same.
	(range_query::range_of_stmt): Same.
	(range_query::value_of_expr): Same.
	(range_query::value_on_edge): Same.
	(range_query::value_of_stmt): Same.
	(range_query::get_tree_range): Same.
	(update_global_range): Same.
	(get_range_global): Same.
	(gimple_range_global): Same.
	(global_range_query::range_of_expr): Same.
	(range_query::query_relation): Same.
	* value-query.h (gimple_range_global): Same.
	(update_global_range): Same.
	* vr-values.cc (vr_values::range_of_expr): Same.
	(bounds_of_var_in_loop): Same.
	(simplify_using_ranges::vrp_visit_cond_stmt): Same.
	* vr-values.h (class vr_values): Same.
	* tree-ssa-loop-unswitch.cc (unswitch_predicate): Same.

1 files changed, 28 insertions, 19 deletions

diff --git a/gcc/gimple-range-path.cc b/gcc/gimple-range-path.cc
index 66f433d..f8ae6fb 100644
--- a/gcc/gimple-range-path.cc
+++ b/gcc/gimple-range-path.cc
@@ -83,7 +83,7 @@ path_range_query::clear_cache (tree name)
 // If NAME has a cache entry, return it in R, and return TRUE.
 
 inline bool
-path_range_query::get_cache (irange &r, tree name)
+path_range_query::get_cache (vrange &r, tree name)
 {
   if (!gimple_range_ssa_p (name))
     return get_global_range_query ()->range_of_expr (r, name);
@@ -98,7 +98,7 @@ path_range_query::get_cache (irange &r, tree name)
 // Set the cache entry for NAME to R.
 
 void
-path_range_query::set_cache (const irange &r, tree name)
+path_range_query::set_cache (const vrange &r, tree name)
 {
   unsigned v = SSA_NAME_VERSION (name);
   bitmap_set_bit (m_has_cache_entry, v);
@@ -149,7 +149,7 @@ path_range_query::defined_outside_path (tree name)
 // Return the range of NAME on entry to the path.
 
 void
-path_range_query::range_on_path_entry (irange &r, tree name)
+path_range_query::range_on_path_entry (vrange &r, tree name)
 {
   gcc_checking_assert (defined_outside_path (name));
   basic_block entry = entry_bb ();
@@ -168,7 +168,7 @@ path_range_query::range_on_path_entry (irange &r, tree name)
   // block.  This can happen when we're querying a block with only an
   // outgoing edge (no statement but the fall through edge), but for
   // which we can determine a range on entry to the block.
-  int_range_max tmp;
+  Value_Range tmp (TREE_TYPE (name));
   bool changed = false;
   r.set_undefined ();
   for (unsigned i = 0; i < EDGE_COUNT (entry->preds); ++i)
@@ -190,9 +190,9 @@ path_range_query::range_on_path_entry (irange &r, tree name)
 // Return the range of NAME at the end of the path being analyzed.
 
 bool
-path_range_query::internal_range_of_expr (irange &r, tree name, gimple *stmt)
+path_range_query::internal_range_of_expr (vrange &r, tree name, gimple *stmt)
 {
-  if (!irange::supports_type_p (TREE_TYPE (name)))
+  if (!vrange::supports_type_p (TREE_TYPE (name)))
     return false;
 
   if (get_cache (r, name))
@@ -209,18 +209,22 @@ path_range_query::internal_range_of_expr (irange &r, tree name, gimple *stmt)
       && range_defined_in_block (r, name, gimple_bb (stmt)))
     {
       if (TREE_CODE (name) == SSA_NAME)
-	r.intersect (gimple_range_global (name));
+	{
+	  Value_Range glob (TREE_TYPE (name));
+	  gimple_range_global (glob, name);
+	  r.intersect (glob);
+	}
 
       set_cache (r, name);
       return true;
     }
 
-  r = gimple_range_global (name);
+  gimple_range_global (r, name);
   return true;
 }
 
 bool
-path_range_query::range_of_expr (irange &r, tree name, gimple *stmt)
+path_range_query::range_of_expr (vrange &r, tree name, gimple *stmt)
 {
   if (internal_range_of_expr (r, name, stmt))
     {
@@ -269,7 +273,7 @@ path_range_query::ssa_defined_in_bb (tree name, basic_block bb)
 // calculating the PHI's range must not trigger additional lookups.
 
 void
-path_range_query::ssa_range_in_phi (irange &r, gphi *phi)
+path_range_query::ssa_range_in_phi (vrange &r, gphi *phi)
 {
   tree name = gimple_phi_result (phi);
   basic_block bb = gimple_bb (phi);
@@ -283,7 +287,7 @@ path_range_query::ssa_range_in_phi (irange &r, gphi *phi)
       // Try to fold the phi exclusively with global or cached values.
       // This will get things like PHI <5(99), 6(88)>.  We do this by
       // calling range_of_expr with no context.
-      int_range_max arg_range;
+      Value_Range arg_range (TREE_TYPE (name));
       r.set_undefined ();
       for (size_t i = 0; i < nargs; ++i)
 	{
@@ -312,7 +316,7 @@ path_range_query::ssa_range_in_phi (irange &r, gphi *phi)
 	  {
 	    if (m_resolve)
 	      {
-		int_range_max tmp;
+		Value_Range tmp (TREE_TYPE (name));
 		// Using both the range on entry to the path, and the
 		// range on this edge yields significantly better
 		// results.
@@ -335,7 +339,7 @@ path_range_query::ssa_range_in_phi (irange &r, gphi *phi)
 // TRUE.  Otherwise, return FALSE.
 
 bool
-path_range_query::range_defined_in_block (irange &r, tree name, basic_block bb)
+path_range_query::range_defined_in_block (vrange &r, tree name, basic_block bb)
 {
   gimple *def_stmt = SSA_NAME_DEF_STMT (name);
   basic_block def_bb = gimple_bb (def_stmt);
@@ -377,7 +381,6 @@ path_range_query::range_defined_in_block (irange &r, tree name, basic_block bb)
 void
 path_range_query::compute_ranges_in_phis (basic_block bb)
 {
-  int_range_max r;
   auto_bitmap phi_set;
 
   // PHIs must be resolved simultaneously on entry to the block
@@ -390,7 +393,11 @@ path_range_query::compute_ranges_in_phis (basic_block bb)
       gphi *phi = iter.phi ();
       tree name = gimple_phi_result (phi);
 
-      if (import_p (name) && range_defined_in_block (r, name, bb))
+      if (!import_p (name))
+	continue;
+
+      Value_Range r (TREE_TYPE (name));
+      if (range_defined_in_block (r, name, bb))
 	{
 	  unsigned v = SSA_NAME_VERSION (name);
 	  set_cache (r, name);
@@ -423,7 +430,6 @@ void
 path_range_query::compute_ranges_in_block (basic_block bb)
 {
   bitmap_iterator bi;
-  int_range_max r, cached_range;
   unsigned i;
 
   if (m_resolve && !at_entry ())
@@ -444,6 +450,7 @@ path_range_query::compute_ranges_in_block (basic_block bb)
   EXECUTE_IF_SET_IN_BITMAP (m_imports, 0, i, bi)
     {
       tree name = ssa_name (i);
+      Value_Range r (TREE_TYPE (name));
 
       if (gimple_code (SSA_NAME_DEF_STMT (name)) != GIMPLE_PHI
 	  && range_defined_in_block (r, name, bb))
@@ -480,8 +487,10 @@ path_range_query::compute_ranges_in_block (basic_block bb)
 
       if (bitmap_bit_p (exports, i))
 	{
+	  Value_Range r (TREE_TYPE (name));
 	  if (g.outgoing_edge_range_p (r, e, name, *this))
 	    {
+	      Value_Range cached_range (TREE_TYPE (name));
 	      if (get_cache (cached_range, name))
 		r.intersect (cached_range);
 
@@ -539,7 +548,7 @@ bool
 path_range_query::add_to_imports (tree name, bitmap imports)
 {
   if (TREE_CODE (name) == SSA_NAME
-      && irange::supports_type_p (TREE_TYPE (name)))
+      && vrange::supports_type_p (TREE_TYPE (name)))
     return bitmap_set_bit (imports, SSA_NAME_VERSION (name));
   return false;
 }
@@ -751,11 +760,11 @@ jt_fur_source::query_relation (tree op1, tree op2)
 // Return the range of STMT at the end of the path being analyzed.
 
 bool
-path_range_query::range_of_stmt (irange &r, gimple *stmt, tree)
+path_range_query::range_of_stmt (vrange &r, gimple *stmt, tree)
 {
   tree type = gimple_range_type (stmt);
 
-  if (!type || !irange::supports_type_p (type))
+  if (!type || !vrange::supports_type_p (type))
     return false;
 
   // If resolving unknowns, fold the statement making use of any