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, 38 insertions, 35 deletions

diff --git a/gcc/value-query.cc b/gcc/value-query.cc
index 31e56ee..e40e358 100644
--- a/gcc/value-query.cc
+++ b/gcc/value-query.cc
@@ -57,13 +57,13 @@ value_query::value_of_stmt (gimple *stmt, tree name)
 // range_query default methods.
 
 bool
-range_query::range_on_edge (irange &r, edge, tree expr)
+range_query::range_on_edge (vrange &r, edge, tree expr)
 {
   return range_of_expr (r, expr);
 }
 
 bool
-range_query::range_of_stmt (irange &r, gimple *stmt, tree name)
+range_query::range_of_stmt (vrange &r, gimple *stmt, tree name)
 {
   if (!name)
     name = gimple_get_lhs (stmt);
@@ -79,11 +79,12 @@ tree
 range_query::value_of_expr (tree expr, gimple *stmt)
 {
   tree t;
-  int_range_max r;
 
-  if (!irange::supports_type_p (TREE_TYPE (expr)))
+  if (!vrange::supports_type_p (TREE_TYPE (expr)))
     return NULL_TREE;
 
+  Value_Range r (TREE_TYPE (expr));
+
   if (range_of_expr (r, expr, stmt))
     {
       // A constant used in an unreachable block oftens returns as UNDEFINED.
@@ -100,10 +101,10 @@ tree
 range_query::value_on_edge (edge e, tree expr)
 {
   tree t;
-  int_range_max r;
 
-  if (!irange::supports_type_p (TREE_TYPE (expr)))
+  if (!vrange::supports_type_p (TREE_TYPE (expr)))
     return NULL_TREE;
+  Value_Range r (TREE_TYPE (expr));
   if (range_on_edge (r, e, expr))
     {
       // A constant used in an unreachable block oftens returns as UNDEFINED.
@@ -121,15 +122,15 @@ tree
 range_query::value_of_stmt (gimple *stmt, tree name)
 {
   tree t;
-  int_range_max r;
 
   if (!name)
     name = gimple_get_lhs (stmt);
 
   gcc_checking_assert (!name || name == gimple_get_lhs (stmt));
 
-  if (!name || !irange::supports_type_p (TREE_TYPE (name)))
+  if (!name || !vrange::supports_type_p (TREE_TYPE (name)))
     return NULL_TREE;
+  Value_Range r (TREE_TYPE (name));
   if (range_of_stmt (r, stmt, name) && r.singleton_p (&t))
     return t;
   return NULL_TREE;
@@ -187,7 +188,7 @@ range_query::~range_query ()
 // representable, and UNDEFINED/false if not.
 
 bool
-range_query::get_tree_range (irange &r, tree expr, gimple *stmt)
+range_query::get_tree_range (vrange &r, tree expr, gimple *stmt)
 {
   tree type;
   if (TYPE_P (expr))
@@ -195,7 +196,7 @@ range_query::get_tree_range (irange &r, tree expr, gimple *stmt)
   else
     type = TREE_TYPE (expr);
 
-  if (!irange::supports_type_p (type))
+  if (!vrange::supports_type_p (type))
     {
       r.set_undefined ();
       return false;
@@ -214,7 +215,7 @@ range_query::get_tree_range (irange &r, tree expr, gimple *stmt)
       return true;
 
     case SSA_NAME:
-      r = gimple_range_global (expr);
+      gimple_range_global (r, expr);
       return true;
 
     case ADDR_EXPR:
@@ -223,7 +224,7 @@ range_query::get_tree_range (irange &r, tree expr, gimple *stmt)
 	bool ov;
 	if (tree_single_nonzero_warnv_p (expr, &ov))
 	  {
-	    r = range_nonzero (type);
+	    r.set_nonzero (type);
 	    return true;
 	  }
 	break;
@@ -237,7 +238,8 @@ range_query::get_tree_range (irange &r, tree expr, gimple *stmt)
       range_op_handler op (TREE_CODE (expr), type);
       if (op)
 	{
-	  int_range_max r0, r1;
+	  Value_Range r0 (TREE_TYPE (TREE_OPERAND (expr, 0)));
+	  Value_Range r1 (TREE_TYPE (TREE_OPERAND (expr, 1)));
 	  range_of_expr (r0, TREE_OPERAND (expr, 0), stmt);
 	  range_of_expr (r1, TREE_OPERAND (expr, 1), stmt);
 	  op.fold_range (r, type, r0, r1);
@@ -250,11 +252,13 @@ range_query::get_tree_range (irange &r, tree expr, gimple *stmt)
     {
       range_op_handler op (TREE_CODE (expr), type);
       tree op0_type = TREE_TYPE (TREE_OPERAND (expr, 0));
-      if (op && irange::supports_type_p (op0_type))
+      if (op && vrange::supports_type_p (op0_type))
 	{
-	  int_range_max r0;
+	  Value_Range r0 (TREE_TYPE (TREE_OPERAND (expr, 0)));
+	  Value_Range r1 (type);
+	  r1.set_varying (type);
 	  range_of_expr (r0, TREE_OPERAND (expr, 0), stmt);
-	  op.fold_range (r, type, r0, int_range<1> (type));
+	  op.fold_range (r, type, r0, r1);
 	}
       else
 	r.set_varying (type);
@@ -311,7 +315,7 @@ get_ssa_name_ptr_info_nonnull (const_tree name)
 // updated.
 
 bool
-update_global_range (irange &r, tree name)
+update_global_range (vrange &r, tree name)
 {
   tree type = TREE_TYPE (name);
 
@@ -330,8 +334,7 @@ update_global_range (irange &r, tree name)
       if (r.undefined_p ())
 	return false;
 
-      value_range vr = r;
-      set_range_info (name, vr);
+      set_range_info (name, as_a <irange> (r));
       return true;
     }
   else if (POINTER_TYPE_P (type))
@@ -349,7 +352,7 @@ update_global_range (irange &r, tree name)
 // return VARYING.
 
 static void
-get_range_global (irange &r, tree name)
+get_range_global (vrange &r, tree name)
 {
   tree type = TREE_TYPE (name);
 
@@ -369,7 +372,7 @@ get_range_global (irange &r, tree name)
 	    r.set_nonzero (type);
 	  else if (INTEGRAL_TYPE_P (type))
 	    {
-	      get_ssa_name_range_info (r, name);
+	      get_ssa_name_range_info (as_a <irange> (r), name);
 	      if (r.undefined_p ())
 		r.set_varying (type);
 	    }
@@ -384,7 +387,8 @@ get_range_global (irange &r, tree name)
    }
   else if (!POINTER_TYPE_P (type) && SSA_NAME_RANGE_INFO (name))
     {
-      get_ssa_name_range_info (r, name);
+      gcc_checking_assert (irange::supports_type_p (TREE_TYPE (name)));
+      get_ssa_name_range_info (as_a <irange> (r), name);
       if (r.undefined_p ())
 	r.set_varying (type);
     }
@@ -414,21 +418,19 @@ get_range_global (irange &r, tree name)
 // See discussion here:
 // https://gcc.gnu.org/pipermail/gcc-patches/2021-June/571709.html
 
-value_range
-gimple_range_global (tree name)
+void
+gimple_range_global (vrange &r, tree name)
 {
   tree type = TREE_TYPE (name);
-  gcc_checking_assert (TREE_CODE (name) == SSA_NAME
-		       && irange::supports_type_p (type));
+  gcc_checking_assert (TREE_CODE (name) == SSA_NAME);
 
   if (SSA_NAME_IS_DEFAULT_DEF (name) || (cfun && cfun->after_inlining)
       || is_a<gphi *> (SSA_NAME_DEF_STMT (name)))
     {
-      value_range vr;
-      get_range_global (vr, name);
-      return vr;
+      get_range_global (r, name);
+      return;
     }
-  return value_range (type);
+  r.set_varying (type);
 }
 
 // ----------------------------------------------
@@ -437,7 +439,7 @@ gimple_range_global (tree name)
 global_range_query global_ranges;
 
 bool
-global_range_query::range_of_expr (irange &r, tree expr, gimple *stmt)
+global_range_query::range_of_expr (vrange &r, tree expr, gimple *stmt)
 {
   tree type = TREE_TYPE (expr);
 
@@ -456,15 +458,16 @@ global_range_query::range_of_expr (irange &r, tree expr, gimple *stmt)
 relation_kind
 range_query::query_relation (gimple *s, tree ssa1, tree ssa2, bool get_range)
 {
-  int_range_max tmp;
   if (!m_oracle || TREE_CODE (ssa1) != SSA_NAME || TREE_CODE (ssa2) != SSA_NAME)
     return VREL_VARYING;
 
   // Ensure ssa1 and ssa2 have both been evaluated.
   if (get_range)
     {
-      range_of_expr (tmp, ssa1, s);
-      range_of_expr (tmp, ssa2, s);
+      Value_Range tmp1 (TREE_TYPE (ssa1));
+      Value_Range tmp2 (TREE_TYPE (ssa2));
+      range_of_expr (tmp1, ssa1, s);
+      range_of_expr (tmp2, ssa2, s);
     }
   return m_oracle->query_relation (gimple_bb (s), ssa1, ssa2);
 }
@@ -477,7 +480,6 @@ relation_kind
 range_query::query_relation (edge e, tree ssa1, tree ssa2, bool get_range)
 {
   basic_block bb;
-  int_range_max tmp;
   if (!m_oracle || TREE_CODE (ssa1) != SSA_NAME || TREE_CODE (ssa2) != SSA_NAME)
     return VREL_VARYING;
 
@@ -492,6 +494,7 @@ range_query::query_relation (edge e, tree ssa1, tree ssa2, bool get_range)
   // Ensure ssa1 and ssa2 have both been evaluated.
   if (get_range)
     {
+      Value_Range tmp (TREE_TYPE (ssa1));
       range_on_edge (tmp, e, ssa1);
       range_on_edge (tmp, e, ssa2);
     }