Rename all uses of irange to value_range_base in range-op.*.

If using irange in branch set the following define:
	#define value_range_base irange

From-SVN: r274826

3 files changed, 736 insertions, 555 deletions

diff --git a/gcc/range-op.cc b/gcc/range-op.cc
index de6f236..165acca 100644
--- a/gcc/range-op.cc
+++ b/gcc/range-op.cc
@@ -47,6 +47,11 @@ along with GCC; see the file COPYING3.  If not see
 #include "range-op.h"
 #include "wide-int-range.h"
 
+#if USE_IRANGE
+#define value_range_base irange
+#define value_range_storage irange_storage
+#endif
+
 // Auxiliary routine to return the upper limit for a type.
 
 inline wide_int
@@ -67,7 +72,9 @@ min_limit (const_tree type)
 // undefined and return true.
 
 inline bool
-empty_range_check (irange &r, const irange &op1, const irange & op2)
+empty_range_check (value_range_base &r,
+		   const value_range_base &op1,
+		   const value_range_base & op2)
 {
   if (op1.undefined_p () || op2.undefined_p ())
     {
@@ -79,23 +86,24 @@ empty_range_check (irange &r, const irange &op1, const irange & op2)
 }
 
 // Default wide_int fold operation returns [min , max].
-irange
+value_range_base
 range_operator::wi_fold (tree type,
 			 const wide_int &lh_lb ATTRIBUTE_UNUSED,
 			 const wide_int &lh_ub ATTRIBUTE_UNUSED,
 			 const wide_int &rh_lb ATTRIBUTE_UNUSED,
 			 const wide_int &rh_ub ATTRIBUTE_UNUSED) const
 {
-  return irange (type);
+  return value_range_base (type);
 }
 
 // The default for fold is to break all ranges into subranges
 // and invoke the 'wi_fold' method on each subrange pair.
-irange
-range_operator::fold_range (tree type, const irange &lh,
-			    const irange &rh) const
+value_range_base
+range_operator::fold_range (tree type,
+			    const value_range_base &lh,
+			    const value_range_base &rh) const
 {
-  irange r;
+  value_range_base r;
   if (empty_range_check (r, lh, rh))
     return r;
 
@@ -116,20 +124,20 @@ range_operator::fold_range (tree type, const irange &lh,
 
 // The default for op1_range is to return false.
 bool
-range_operator::op1_range (irange &r ATTRIBUTE_UNUSED,
+range_operator::op1_range (value_range_base &r ATTRIBUTE_UNUSED,
 			   tree type ATTRIBUTE_UNUSED,
-			   const irange &lhs ATTRIBUTE_UNUSED,
-			   const irange &op2 ATTRIBUTE_UNUSED) const
+			   const value_range_base &lhs ATTRIBUTE_UNUSED,
+			   const value_range_base &op2 ATTRIBUTE_UNUSED) const
 {
   return false;
 }
 
 // The default for op2_range is to return false.
 bool
-range_operator::op2_range (irange &r ATTRIBUTE_UNUSED,
+range_operator::op2_range (value_range_base &r ATTRIBUTE_UNUSED,
 			   tree type ATTRIBUTE_UNUSED,
-			   const irange &lhs ATTRIBUTE_UNUSED,
-			   const irange &op1 ATTRIBUTE_UNUSED) const
+			   const value_range_base &lhs ATTRIBUTE_UNUSED,
+			   const value_range_base &op1 ATTRIBUTE_UNUSED) const
 {
   return false;
 }
@@ -142,7 +150,7 @@ range_operator::op2_range (irange &r ATTRIBUTE_UNUSED,
 // the case where there are 2 possible overflows, or none.
 
 static void
-adjust_overflow_bound (irange &r, tree type, const wide_int &wmin,
+adjust_overflow_bound (value_range_base &r, tree type, const wide_int &wmin,
 		       const wide_int &wmax)
 {
   const signop sgn = TYPE_SIGN (type);
@@ -166,7 +174,7 @@ adjust_overflow_bound (irange &r, tree type, const wide_int &wmin,
     r.set_varying (type);
   else
     {
-      irange tmp (VR_ANTI_RANGE, type, tmin, tmax);
+      value_range_base tmp (VR_ANTI_RANGE, type, tmin, tmax);
       r.union_ (tmp);
     }
   return;
@@ -176,7 +184,7 @@ adjust_overflow_bound (irange &r, tree type, const wide_int &wmin,
 // overflow bits to determine how to add [lbound, ubound] into range R.
 
 static void
-accumulate_range (irange &r, tree type, const wide_int &wmin,
+accumulate_range (value_range_base &r, tree type, const wide_int &wmin,
 		  const wide_int &wmax,
 		  wi::overflow_type min_ovf = wi::OVF_NONE,
 		  wi::overflow_type max_ovf = wi::OVF_NONE)
@@ -209,7 +217,7 @@ accumulate_range (irange &r, tree type, const wide_int &wmin,
 	    {
 	      /* No overflow or both overflow or underflow.  The
 		 range kind stays normal.  */
-	      irange tmp (type, tmin, tmax);
+	      value_range_base tmp (type, tmin, tmax);
 	      r.union_ (tmp);
 	    }
 	}
@@ -238,7 +246,7 @@ accumulate_range (irange &r, tree type, const wide_int &wmin,
 	new_ub = wi::max_value (prec, sgn);
       else
         new_ub = wmax;
-      irange tmp (type, new_lb, new_ub);
+      value_range_base tmp (type, new_lb, new_ub);
       r.union_ (tmp);
     }
 }
@@ -248,7 +256,7 @@ accumulate_range (irange &r, tree type, const wide_int &wmin,
    [10,5] into [MIN,5][10,MAX].  */
 
 static inline void
-accumulate_possibly_reversed_range (irange &r, tree type,
+accumulate_possibly_reversed_range (value_range_base &r, tree type,
 				    const wide_int &new_lb,
 				    const wide_int &new_ub)
 {
@@ -260,35 +268,35 @@ accumulate_possibly_reversed_range (irange &r, tree type,
       return;
     }
   // Otherwise its just a normal range.
-  irange tmp (type, new_lb, new_ub);
+  value_range_base tmp (type, new_lb, new_ub);
   r.union_ (tmp);
 }
 
-// Return an irange instance that is a boolean TRUE.
+// Return a value_range_base instance that is a boolean TRUE.
 
-static irange
+static value_range_base
 range_true (tree type)
 {
   unsigned prec = TYPE_PRECISION (type);
-  return irange (type, wi::one (prec), wi::one (prec));
+  return value_range_base (type, wi::one (prec), wi::one (prec));
 }
 
-// Return an irange instance that is a boolean FALSE.
+// Return a value_range_base instance that is a boolean FALSE.
 
-static irange
+static value_range_base
 range_false (tree type)
 {
   unsigned prec = TYPE_PRECISION (type);
-  return irange (type, wi::zero (prec), wi::zero (prec));
+  return value_range_base (type, wi::zero (prec), wi::zero (prec));
 }
 
-// Return an irange instance that is a boolean FALSE.
+// Return a value_range_base instance that is a boolean FALSE.
 
-static irange
+static value_range_base
 range_true_and_false (tree type)
 {
   unsigned prec = TYPE_PRECISION (type);
-  return irange (type, wi::zero (prec), wi::one (prec));
+  return value_range_base (type, wi::zero (prec), wi::one (prec));
 }
 
 enum bool_range_state { BRS_FALSE, BRS_TRUE, BRS_EMPTY, BRS_FULL };
@@ -298,7 +306,8 @@ enum bool_range_state { BRS_FALSE, BRS_TRUE, BRS_EMPTY, BRS_FULL };
    range for TYPE, for BRS_TRUE and BRS false, return the negatiuon of
    the bool range.  */
 static bool_range_state
-get_bool_state (irange &r, const irange &lhs, tree val_type)
+get_bool_state (value_range_base &r,
+		const value_range_base &lhs, tree val_type)
 {
   /* If there is no result, then this is unexectuable, so no range. */
   if (lhs.undefined_p ())
@@ -324,22 +333,26 @@ get_bool_state (irange &r, const irange &lhs, tree val_type)
 class operator_equal : public range_operator
 {
 public:
-  virtual irange fold_range (tree type,
-			     const irange &op1, const irange &op2) const;
-  virtual bool op1_range (irange &r, tree type, const irange &lhs,
-			  const irange &val) const;
-  virtual bool op2_range (irange &r, tree type, const irange &lhs,
-			  const irange &val) const;
+  virtual value_range_base fold_range (tree type,
+				       const value_range_base &op1,
+				       const value_range_base &op2) const;
+  virtual bool op1_range (value_range_base &r, tree type,
+			  const value_range_base &lhs,
+			  const value_range_base &val) const;
+  virtual bool op2_range (value_range_base &r, tree type,
+			  const value_range_base &lhs,
+			  const value_range_base &val) const;
 } op_equal;
 
 
 
 /* Fold comparison of the 2 ranges.  */
-irange
+value_range_base
 operator_equal::fold_range (tree type,
-			    const irange &op1, const irange &op2) const
+			    const value_range_base &op1,
+			    const value_range_base &op2) const
 {
-  irange r;
+  value_range_base r;
   if (empty_range_check (r, op1, op2))
     return r;
 
@@ -368,8 +381,9 @@ operator_equal::fold_range (tree type,
 }
 
 bool
-operator_equal::op1_range (irange &r, tree type, const irange &lhs,
-			    const irange &op2) const
+operator_equal::op1_range (value_range_base &r, tree type,
+			   const value_range_base &lhs,
+			   const value_range_base &op2) const
 {
   switch (get_bool_state (r, lhs, type))
     {
@@ -395,8 +409,9 @@ operator_equal::op1_range (irange &r, tree type, const irange &lhs,
 
 
 bool
-operator_equal::op2_range (irange &r, tree type, const irange &lhs,
-			    const irange &op1) const
+operator_equal::op2_range (value_range_base &r, tree type,
+			   const value_range_base &lhs,
+			   const value_range_base &op1) const
 {
   return operator_equal::op1_range (r, type, lhs, op1);
 }
@@ -407,20 +422,24 @@ operator_equal::op2_range (irange &r, tree type, const irange &lhs,
 class operator_not_equal : public range_operator
 {
 public:
-  virtual irange fold_range (tree type,
-			     const irange &op1, const irange &op2) const;
-  virtual bool op1_range (irange &r, tree type, const irange &lhs,
-			   const irange &op2) const;
-  virtual bool op2_range (irange &r, tree type, const irange &lhs,
-			   const irange &op1) const;
+  virtual value_range_base fold_range (tree type,
+				       const value_range_base &op1,
+				       const value_range_base &op2) const;
+  virtual bool op1_range (value_range_base &r, tree type,
+			  const value_range_base &lhs,
+			  const value_range_base &op2) const;
+  virtual bool op2_range (value_range_base &r, tree type,
+			  const value_range_base &lhs,
+			  const value_range_base &op1) const;
 } op_not_equal;
 
 /* Fold comparison of the 2 ranges.  */
-irange
+value_range_base
 operator_not_equal::fold_range (tree type,
-				const irange &op1, const irange &op2) const
+				const value_range_base &op1,
+				const value_range_base &op2) const
 {
-  irange r;
+  value_range_base r;
   if (empty_range_check (r, op1, op2))
     return r;
 
@@ -450,8 +469,9 @@ operator_not_equal::fold_range (tree type,
 
 /* Calculate the range of op1 being == to VAL based on LHS.  */
 bool
-operator_not_equal::op1_range (irange &r, tree type, const irange &lhs,
-				const irange &op2) const
+operator_not_equal::op1_range (value_range_base &r, tree type,
+			       const value_range_base &lhs,
+			       const value_range_base &op2) const
 {
   switch (get_bool_state (r, lhs, type))
     {
@@ -477,8 +497,9 @@ operator_not_equal::op1_range (irange &r, tree type, const irange &lhs,
 
 
 bool
-operator_not_equal::op2_range (irange &r, tree type, const irange &lhs,
-				const irange &op1) const
+operator_not_equal::op2_range (value_range_base &r, tree type,
+			       const value_range_base &lhs,
+			       const value_range_base &op1) const
 {
   return operator_not_equal::op1_range (r, type, lhs, op1);
 }
@@ -486,7 +507,7 @@ operator_not_equal::op2_range (irange &r, tree type, const irange &lhs,
 
 /* (X < VAL) produces the a range of [MIN, VAL - 1]  */
 static void
-build_lt (irange &r, tree type, const wide_int &val)
+build_lt (value_range_base &r, tree type, const wide_int &val)
 {
   wi::overflow_type ov;
   wide_int lim = wi::sub (val, 1, TYPE_SIGN (type), &ov);
@@ -495,19 +516,19 @@ build_lt (irange &r, tree type, const wide_int &val)
   if (ov)
     r.set_undefined ();
   else
-    r = irange (type, min_limit (type), lim);
+    r = value_range_base (type, min_limit (type), lim);
 }
 
 /* (X <= VAL) produces the a range of [MIN, VAL]  */
 static void
-build_le (irange &r, tree type, const wide_int &val)
+build_le (value_range_base &r, tree type, const wide_int &val)
 {
-  r = irange (type, min_limit (type), val);
+  r = value_range_base (type, min_limit (type), val);
 }
 
 /* (X > VAL) produces the a range of [VAL + 1, MAX]  */
 static void
-build_gt (irange &r, tree type, const wide_int &val)
+build_gt (value_range_base &r, tree type, const wide_int &val)
 {
   wi::overflow_type ov;
   wide_int lim = wi::add (val, 1, TYPE_SIGN (type), &ov);
@@ -515,14 +536,14 @@ build_gt (irange &r, tree type, const wide_int &val)
   if (ov)
     r.set_undefined ();
   else
-    r = irange (type, lim, max_limit (type));
+    r = value_range_base (type, lim, max_limit (type));
 }
 
 /* (X >= val) produces the a range of [VAL, MAX]  */
 static void
-build_ge (irange &r, tree type, const wide_int &val)
+build_ge (value_range_base &r, tree type, const wide_int &val)
 {
-  r = irange (type, val, max_limit (type));
+  r = value_range_base (type, val, max_limit (type));
 }
 
 
@@ -530,18 +551,23 @@ build_ge (irange &r, tree type, const wide_int &val)
 class operator_lt :  public range_operator
 {
 public:
-  virtual irange fold_range (tree type,
-			     const irange &op1, const irange &op2) const;
-  virtual bool op1_range (irange &r, tree type, const irange &lhs,
-			   const irange &op2) const;
-  virtual bool op2_range (irange &r, tree type, const irange &lhs,
-			   const irange &op1) const;
+  virtual value_range_base fold_range (tree type,
+				       const value_range_base &op1,
+				       const value_range_base &op2) const;
+  virtual bool op1_range (value_range_base &r, tree type,
+			  const value_range_base &lhs,
+			  const value_range_base &op2) const;
+  virtual bool op2_range (value_range_base &r, tree type,
+			  const value_range_base &lhs,
+			  const value_range_base &op1) const;
 } op_lt;
 
-irange
-operator_lt::fold_range (tree type, const irange &op1, const irange &op2) const
+value_range_base
+operator_lt::fold_range (tree type,
+			 const value_range_base &op1,
+			 const value_range_base &op2) const
 {
-  irange r;
+  value_range_base r;
   if (empty_range_check (r, op1, op2))
     return r;
 
@@ -560,7 +586,9 @@ operator_lt::fold_range (tree type, const irange &op1, const irange &op2) const
 
 
 bool
-operator_lt::op1_range (irange &r, tree type, const irange &lhs, const irange &op2) const
+operator_lt::op1_range (value_range_base &r, tree type,
+			const value_range_base &lhs,
+			const value_range_base &op2) const
 {
   switch (get_bool_state (r, lhs, type))
     {
@@ -580,7 +608,9 @@ operator_lt::op1_range (irange &r, tree type, const irange &lhs, const irange &o
 
 
 bool
-operator_lt::op2_range (irange &r, tree type, const irange &lhs, const irange &op1) const
+operator_lt::op2_range (value_range_base &r, tree type,
+			const value_range_base &lhs,
+			const value_range_base &op1) const
 {
   switch (get_bool_state (r, lhs, type))
     {
@@ -602,18 +632,23 @@ operator_lt::op2_range (irange &r, tree type, const irange &lhs, const irange &o
 class operator_le :  public range_operator
 {
 public:
-  virtual irange fold_range (tree type,
-			     const irange &op1, const irange &op2) const;
-  virtual bool op1_range (irange &r, tree type,
-			  const irange &lhs, const irange &op2) const;
-  virtual bool op2_range (irange &r, tree type,
-			  const irange &lhs, const irange &op1) const;
+  virtual value_range_base fold_range (tree type,
+				       const value_range_base &op1,
+				       const value_range_base &op2) const;
+  virtual bool op1_range (value_range_base &r, tree type,
+			  const value_range_base &lhs,
+			  const value_range_base &op2) const;
+  virtual bool op2_range (value_range_base &r, tree type,
+			  const value_range_base &lhs,
+			  const value_range_base &op1) const;
 } op_le;
 
-irange
-operator_le::fold_range (tree type, const irange &op1, const irange &op2) const
+value_range_base
+operator_le::fold_range (tree type,
+			 const value_range_base &op1,
+			 const value_range_base &op2) const
 {
-  irange r;
+  value_range_base r;
   if (empty_range_check (r, op1, op2))
     return r;
 
@@ -631,7 +666,9 @@ operator_le::fold_range (tree type, const irange &op1, const irange &op2) const
 }
 
 bool
-operator_le::op1_range (irange &r, tree type, const irange &lhs, const irange &op2) const
+operator_le::op1_range (value_range_base &r, tree type,
+			const value_range_base &lhs,
+			const value_range_base &op2) const
 {
   switch (get_bool_state (r, lhs, type))
     {
@@ -651,7 +688,9 @@ operator_le::op1_range (irange &r, tree type, const irange &lhs, const irange &o
 
 
 bool
-operator_le::op2_range (irange &r, tree type, const irange &lhs, const irange &op1) const
+operator_le::op2_range (value_range_base &r, tree type,
+			const value_range_base &lhs,
+			const value_range_base &op1) const
 {
   switch (get_bool_state (r, lhs, type))
     {
@@ -674,18 +713,23 @@ operator_le::op2_range (irange &r, tree type, const irange &lhs, const irange &o
 class operator_gt :  public range_operator
 {
 public:
-  virtual irange fold_range (tree type,
-			     const irange &op1, const irange &op2) const;
-  virtual bool op1_range (irange &r, tree type,
-			  const irange &lhs, const irange &op2) const;
-  virtual bool op2_range (irange &r, tree type,
-			  const irange &lhs, const irange &op1) const;
+  virtual value_range_base fold_range (tree type,
+				       const value_range_base &op1,
+				       const value_range_base &op2) const;
+  virtual bool op1_range (value_range_base &r, tree type,
+			  const value_range_base &lhs,
+			  const value_range_base &op2) const;
+  virtual bool op2_range (value_range_base &r, tree type,
+			  const value_range_base &lhs,
+			  const value_range_base &op1) const;
 } op_gt;
 
-irange
-operator_gt::fold_range (tree type, const irange &op1, const irange &op2) const
+value_range_base
+operator_gt::fold_range (tree type,
+			 const value_range_base &op1,
+			 const value_range_base &op2) const
 {
-  irange r;
+  value_range_base r;
   if (empty_range_check (r, op1, op2))
     return r;
 
@@ -704,7 +748,9 @@ operator_gt::fold_range (tree type, const irange &op1, const irange &op2) const
 }
 
 bool
-operator_gt::op1_range (irange &r, tree type, const irange &lhs, const irange &op2) const
+operator_gt::op1_range (value_range_base &r, tree type,
+			const value_range_base &lhs,
+			const value_range_base &op2) const
 {
   switch (get_bool_state (r, lhs, type))
     {
@@ -724,7 +770,9 @@ operator_gt::op1_range (irange &r, tree type, const irange &lhs, const irange &o
 
 
 bool
-operator_gt::op2_range (irange &r, tree type, const irange &lhs, const irange &op1) const
+operator_gt::op2_range (value_range_base &r, tree type,
+			const value_range_base &lhs,
+			const value_range_base &op1) const
 {
   switch (get_bool_state (r, lhs, type))
     {
@@ -747,18 +795,23 @@ operator_gt::op2_range (irange &r, tree type, const irange &lhs, const irange &o
 class operator_ge :  public range_operator
 {
 public:
-  virtual irange fold_range (tree type,
-			     const irange &op1, const irange &op2) const;
-  virtual bool op1_range (irange &r, tree type,
-			  const irange &lhs, const irange &op2) const;
-  virtual bool op2_range (irange &r, tree type,
-			  const irange &lhs, const irange &op1) const;
+  virtual value_range_base fold_range (tree type,
+				       const value_range_base &op1,
+				       const value_range_base &op2) const;
+  virtual bool op1_range (value_range_base &r, tree type,
+			  const value_range_base &lhs,
+			  const value_range_base &op2) const;
+  virtual bool op2_range (value_range_base &r, tree type,
+			  const value_range_base &lhs,
+			  const value_range_base &op1) const;
 } op_ge;
 
-irange
-operator_ge::fold_range (tree type, const irange &op1, const irange &op2) const
+value_range_base
+operator_ge::fold_range (tree type,
+			 const value_range_base &op1,
+			 const value_range_base &op2) const
 {
-  irange r;
+  value_range_base r;
   if (empty_range_check (r, op1, op2))
     return r;
 
@@ -777,7 +830,9 @@ operator_ge::fold_range (tree type, const irange &op1, const irange &op2) const
 }
 
 bool
-operator_ge::op1_range (irange &r, tree type, const irange &lhs, const irange &op2) const
+operator_ge::op1_range (value_range_base &r, tree type,
+			const value_range_base &lhs,
+			const value_range_base &op2) const
 {
   switch (get_bool_state (r, lhs, type))
     {
@@ -797,7 +852,9 @@ operator_ge::op1_range (irange &r, tree type, const irange &lhs, const irange &o
 
 
 bool
-operator_ge::op2_range (irange &r, tree type, const irange &lhs, const irange &op1) const
+operator_ge::op2_range (value_range_base &r, tree type,
+			const value_range_base &lhs,
+			const value_range_base &op1) const
 {
   switch (get_bool_state (r, lhs, type))
     {
@@ -821,17 +878,21 @@ operator_ge::op2_range (irange &r, tree type, const irange &lhs, const irange &o
 class operator_plus : public range_operator
 {
 public:
-  virtual bool op1_range (irange &r, tree type, const irange &lhs,
-			   const irange &op2) const;
-  virtual bool op2_range (irange &r, tree type, const irange &lhs,
-			   const irange &op1) const;
-  virtual irange wi_fold (tree type,
-			  const wide_int &lh_lb, const wide_int &lh_ub,
-			  const wide_int &rh_lb, const wide_int &rh_ub) const;
+  virtual bool op1_range (value_range_base &r, tree type,
+			  const value_range_base &lhs,
+			  const value_range_base &op2) const;
+  virtual bool op2_range (value_range_base &r, tree type,
+			  const value_range_base &lhs,
+			  const value_range_base &op1) const;
+  virtual value_range_base wi_fold (tree type,
+				    const wide_int &lh_lb,
+				    const wide_int &lh_ub,
+				    const wide_int &rh_lb,
+				    const wide_int &rh_ub) const;
 } op_plus;
 
 
-irange
+value_range_base
 operator_plus::wi_fold (tree type,
 			const wide_int &lh_lb, const wide_int &lh_ub,
 			const wide_int &rh_lb, const wide_int &rh_ub) const
@@ -842,24 +903,26 @@ operator_plus::wi_fold (tree type,
 
   new_lb = wi::add (lh_lb, rh_lb, s, &ov_lb);
   new_ub = wi::add (lh_ub, rh_ub, s, &ov_ub);
-  irange r;
+  value_range_base r;
   accumulate_range (r, type, new_lb, new_ub, ov_lb, ov_ub);
   return r;
 }
 
-/* Adjust irange to be in terms of op1.
+/* Adjust value_range_base to be in terms of op1.
    Given [range] = op1 + val,  op1 = [range] - val.  */
 bool
-operator_plus::op1_range (irange &r, tree type, const irange &lhs,
-			  const irange &op2) const
+operator_plus::op1_range (value_range_base &r, tree type,
+			  const value_range_base &lhs,
+			  const value_range_base &op2) const
 {
   r = range_op_handler (MINUS_EXPR, type)->fold_range (type, lhs, op2);
   return true;
 }
 
 bool
-operator_plus::op2_range (irange &r, tree type, const irange &lhs,
-			  const irange &op1) const
+operator_plus::op2_range (value_range_base &r, tree type,
+			  const value_range_base &lhs,
+			  const value_range_base &op1) const
 {
   r = range_op_handler (MINUS_EXPR, type)->fold_range (type, lhs, op1);
   return true;
@@ -870,17 +933,21 @@ operator_plus::op2_range (irange &r, tree type, const irange &lhs,
 class operator_minus : public range_operator
 {
 public:
-  virtual bool op1_range (irange &r, tree type, const irange &lhs,
-			   const irange &op2) const;
-  virtual bool op2_range (irange &r, tree type, const irange &lhs,
-			   const irange &op1) const;
-  virtual irange wi_fold (tree type,
-			  const wide_int &lh_lb, const wide_int &lh_ub,
-			  const wide_int &rh_lb, const wide_int &rh_ub) const;
+  virtual bool op1_range (value_range_base &r, tree type,
+			  const value_range_base &lhs,
+			  const value_range_base &op2) const;
+  virtual bool op2_range (value_range_base &r, tree type,
+			  const value_range_base &lhs,
+			  const value_range_base &op1) const;
+  virtual value_range_base wi_fold (tree type,
+				    const wide_int &lh_lb,
+				    const wide_int &lh_ub,
+				    const wide_int &rh_lb,
+				    const wide_int &rh_ub) const;
 } op_minus;
 
 
-irange
+value_range_base
 operator_minus::wi_fold (tree type,
 			 const wide_int &lh_lb, const wide_int &lh_ub,
 			 const wide_int &rh_lb, const wide_int &rh_ub) const
@@ -891,26 +958,28 @@ operator_minus::wi_fold (tree type,
 
   new_lb = wi::sub (lh_lb, rh_ub, s, &ov_lb);
   new_ub = wi::sub (lh_ub, rh_lb, s, &ov_ub);
-  irange r;
+  value_range_base r;
   accumulate_range (r, type, new_lb, new_ub, ov_lb, ov_ub);
   return r;
 }
 
-/* Adjust irange to be in terms of op1.
+/* Adjust value_range_base to be in terms of op1.
    Given lhs = op1 - op2,  op1 = lhs + op2.  */
 bool
-operator_minus::op1_range (irange &r, tree type, const irange &lhs,
-			    const irange &op2) const
+operator_minus::op1_range (value_range_base &r, tree type,
+			   const value_range_base &lhs,
+			   const value_range_base &op2) const
 {
   r = range_op_handler (PLUS_EXPR, type)->fold_range (type, lhs, op2);
   return true;
 }
 
-/* Adjust irange to be in terms of op2.
+/* Adjust value_range_base to be in terms of op2.
    Given lhs = op1 - op2,  -op2 = lhs - op1, therefore op2 = op1 - lhs.  */
 bool
-operator_minus::op2_range (irange &r, tree type, const irange &lhs,
-			   const irange &op1) const
+operator_minus::op2_range (value_range_base &r, tree type,
+			   const value_range_base &lhs,
+			   const value_range_base &op1) const
 {
   r = fold_range (type, op1, lhs);
   return true;
@@ -921,13 +990,15 @@ operator_minus::op2_range (irange &r, tree type, const irange &lhs,
 class operator_min : public range_operator
 {
 public:
-  virtual irange wi_fold (tree type,
-			  const wide_int &lh_lb, const wide_int &lh_ub,
-			  const wide_int &rh_lb, const wide_int &rh_ub) const;
+  virtual value_range_base wi_fold (tree type,
+				    const wide_int &lh_lb,
+				    const wide_int &lh_ub,
+				    const wide_int &rh_lb,
+				    const wide_int &rh_ub) const;
 } op_min;
 
 
-irange
+value_range_base
 operator_min::wi_fold (tree type,
 		       const wide_int &lh_lb, const wide_int &lh_ub,
 		       const wide_int &rh_lb, const wide_int &rh_ub) const
@@ -937,7 +1008,7 @@ operator_min::wi_fold (tree type,
 
   new_lb = wi::min (lh_lb, rh_lb, s);
   new_ub = wi::min (lh_ub, rh_ub, s);
-  irange r;
+  value_range_base r;
   accumulate_range (r, type, new_lb, new_ub);
   return r;
 }
@@ -947,12 +1018,14 @@ operator_min::wi_fold (tree type,
 class operator_max : public range_operator
 {
 public:
-  virtual irange wi_fold (tree type,
-			  const wide_int &lh_lb, const wide_int &lh_ub,
-			  const wide_int &rh_lb, const wide_int &rh_ub) const;
+  virtual value_range_base wi_fold (tree type,
+				    const wide_int &lh_lb,
+				    const wide_int &lh_ub,
+				    const wide_int &rh_lb,
+				    const wide_int &rh_ub) const;
 } op_max;
 
-irange
+value_range_base
 operator_max::wi_fold (tree type,
 		       const wide_int &lh_lb, const wide_int &lh_ub,
 		       const wide_int &rh_lb, const wide_int &rh_ub) const
@@ -962,7 +1035,7 @@ operator_max::wi_fold (tree type,
 
   new_lb = wi::max (lh_lb, rh_lb, s);
   new_ub = wi::max (lh_ub, rh_ub, s);
-  irange r;
+  value_range_base r;
   accumulate_range (r, type, new_lb, new_ub);
   return r;
 }
@@ -973,13 +1046,15 @@ operator_max::wi_fold (tree type,
 class operator_mult : public range_operator
 {
 public:
-  virtual irange wi_fold (tree type,
-			  const wide_int &lh_lb, const wide_int &lh_ub,
-			  const wide_int &rh_lb, const wide_int &rh_ub) const;
+  virtual value_range_base wi_fold (tree type,
+				    const wide_int &lh_lb,
+				    const wide_int &lh_ub,
+				    const wide_int &rh_lb,
+				    const wide_int &rh_ub) const;
 } op_mult;
 
 
-irange
+value_range_base
 operator_mult::wi_fold (tree type,
 			const wide_int &lh_lb, const wide_int &lh_ub,
 			const wide_int &rh_lb, const wide_int &rh_ub) const
@@ -998,11 +1073,11 @@ operator_mult::wi_fold (tree type,
                                          lh_lb, lh_ub, rh_lb, rh_ub);
   if (res)
     {
-      irange r;
+      value_range_base r;
       accumulate_possibly_reversed_range (r, type, new_lb, new_ub);
       return r;
     }
-  return irange (type);
+  return value_range_base (type);
 }
 
 
@@ -1012,9 +1087,11 @@ class operator_div : public range_operator
 {
 public:
   operator_div (enum tree_code c)  { code = c; }
-  virtual irange wi_fold (tree type,
-			  const wide_int &lh_lb, const wide_int &lh_ub,
-			  const wide_int &rh_lb, const wide_int &rh_ub) const;
+  virtual value_range_base wi_fold (tree type,
+				    const wide_int &lh_lb,
+				    const wide_int &lh_ub,
+				    const wide_int &rh_lb,
+				    const wide_int &rh_ub) const;
 private:
   enum tree_code code;
 };
@@ -1024,7 +1101,7 @@ operator_div op_floor_div(FLOOR_DIV_EXPR);
 operator_div op_round_div (ROUND_DIV_EXPR);
 operator_div op_ceil_div (CEIL_DIV_EXPR);
 
-irange
+value_range_base
 operator_div::wi_fold (tree type,
 		       const wide_int &lh_lb, const wide_int &lh_ub,
 		       const wide_int &rh_lb, const wide_int &rh_ub) const
@@ -1036,7 +1113,7 @@ operator_div::wi_fold (tree type,
   /* If we know we will divide by zero, return an empty range,
      which will be interpreted as undefined.  */
   if (rh_lb == 0 && rh_ub == 0)
-    return irange ();
+    return value_range_base ();
 
   if (wide_int_range_div (new_lb, new_ub, code, TYPE_SIGN (type),
 			  TYPE_PRECISION (type),
@@ -1045,13 +1122,13 @@ operator_div::wi_fold (tree type,
 			  TYPE_OVERFLOW_UNDEFINED (type),
 			  extra_range_p, extra_min, extra_max))
     {
-      irange r;
+      value_range_base r;
       accumulate_range (r, type, new_lb, new_ub);
       if (extra_range_p)
 	accumulate_range (r, type, extra_min, extra_max);
       return r;
     }
-  return irange (type);
+  return value_range_base (type);
 }
 
 
@@ -1061,17 +1138,18 @@ class operator_exact_divide : public operator_div
 {
 public:
   operator_exact_divide () : operator_div (EXACT_DIV_EXPR) { }
-  virtual bool op1_range (irange &r, tree type, const irange &lhs,
-			   const irange &op2) const;
+  virtual bool op1_range (value_range_base &r, tree type,
+			  const value_range_base &lhs,
+			  const value_range_base &op2) const;
 
 } op_exact_div;
 
 
-// Adjust irange to be in terms of op1.
+// Adjust value_range_base to be in terms of op1.
 bool
-operator_exact_divide::op1_range (irange &r, tree type,
-				   const irange &lhs,
-				   const irange &op2) const
+operator_exact_divide::op1_range (value_range_base &r, tree type,
+				  const value_range_base &lhs,
+				  const value_range_base &op2) const
 {
   tree offset;
   // [2, 4] = op1 / [3,3]   since its exact divide, no need to worry about
@@ -1094,35 +1172,37 @@ operator_exact_divide::op1_range (irange &r, tree type,
 class operator_lshift : public range_operator
 {
 public:
-  virtual irange fold_range (tree type,
-			     const irange &op1, const irange &op2) const;
+  virtual value_range_base fold_range (tree type,
+				       const value_range_base &op1,
+				       const value_range_base &op2) const;
 
-  virtual irange wi_fold (tree type,
+  virtual value_range_base wi_fold (tree type,
 			  const wide_int &lh_lb, const wide_int &lh_ub,
 			  const wide_int &rh_lb, const wide_int &rh_ub) const;
 } op_lshift;
 
 
 
-irange
+value_range_base
 operator_lshift::fold_range (tree type,
-			     const irange &op1, const irange &op2) const
+			     const value_range_base &op1,
+			     const value_range_base &op2) const
 {
   // Check to see if the shift amount is undefined, and return if so.
   if (op2.undefined_p ())
-    return irange ();
+    return value_range_base ();
 
   if (wide_int_range_shift_undefined_p (TYPE_SIGN (op2.type ()),
 					TYPE_PRECISION (type),
 					op2.lower_bound (),
 					op2.upper_bound ()))
-    return irange (type);
+    return value_range_base (type);
 
   // Otherwise just invoke the normal fold routine.
   return range_operator::fold_range (type, op1, op2);
 }
 
-irange
+value_range_base
 operator_lshift::wi_fold (tree type,
 			  const wide_int &lh_lb, const wide_int &lh_ub,
 			  const wide_int &rh_lb, const wide_int &rh_ub) const
@@ -1134,11 +1214,11 @@ operator_lshift::wi_fold (tree type,
 			     lh_lb, lh_ub, rh_lb, rh_ub,
 			     TYPE_OVERFLOW_UNDEFINED (type)))
     {
-      irange r;
+      value_range_base r;
       accumulate_possibly_reversed_range (r, type, new_lb, new_ub);
       return r;
     }
-  return irange (type);
+  return value_range_base (type);
 }
 
 // ----------------------------------------------------------------------------
@@ -1146,34 +1226,35 @@ operator_lshift::wi_fold (tree type,
 class operator_rshift : public range_operator
 {
 public:
-  virtual irange fold_range (tree type,
-			     const irange &op1, const irange &op2) const;
-  virtual irange wi_fold (tree type,
+  virtual value_range_base fold_range (tree type,
+				       const value_range_base &op1,
+				       const value_range_base &op2) const;
+  virtual value_range_base wi_fold (tree type,
 			  const wide_int &lh_lb, const wide_int &lh_ub,
 			  const wide_int &rh_lb, const wide_int &rh_ub) const;
 } op_rshift;
 
 
-irange
+value_range_base
 operator_rshift::fold_range (tree type,
-			     const irange &op1, const irange &op2) const
+			     const value_range_base &op1,
+			     const value_range_base &op2) const
 {
   // Check to see if the shift amount is undefined, and return if so.
   if (op2.undefined_p ())
-    return irange ();
+    return value_range_base ();
 
   if (wide_int_range_shift_undefined_p (TYPE_SIGN (op2.type ()),
 					TYPE_PRECISION (type),
 					op2.lower_bound (),
 					op2.upper_bound ()))
-    return irange (type);
+    return value_range_base (type);
 
   // Otherwise just invoke the normal fold routine.
   return range_operator::fold_range (type, op1, op2);
-  
 }
 
-irange
+value_range_base
 operator_rshift::wi_fold (tree type,
 			  const wide_int &lh_lb, const wide_int &lh_ub,
 			  const wide_int &rh_lb, const wide_int &rh_ub) const
@@ -1186,11 +1267,11 @@ operator_rshift::wi_fold (tree type,
 					lh_lb, lh_ub, rh_lb, rh_ub,
 					TYPE_OVERFLOW_UNDEFINED (type)))
     {
-      irange r;
+      value_range_base r;
       accumulate_possibly_reversed_range (r, type, new_lb, new_ub);
       return r;
     }
-  return irange (type);
+  return value_range_base (type);
 }
 
 // ----------------------------------------------------------------------------
@@ -1199,21 +1280,24 @@ operator_rshift::wi_fold (tree type,
 class operator_cast: public range_operator
 {
 public:
-  virtual irange fold_range (tree type,
-			     const irange &op1, const irange &op2) const;
-  virtual bool op1_range (irange &r, tree type,
-			  const irange &lhs, const irange &op2) const;
+  virtual value_range_base fold_range (tree type,
+				       const value_range_base &op1,
+				       const value_range_base &op2) const;
+  virtual bool op1_range (value_range_base &r, tree type,
+			  const value_range_base &lhs,
+			  const value_range_base &op2) const;
 
 } op_convert;
 
 
 /* Return LH converted to the type of RH.  */
 
-irange
+value_range_base
 operator_cast::fold_range (tree type ATTRIBUTE_UNUSED,
-			   const irange &lh, const irange &rh) const
+			   const value_range_base &lh,
+			   const value_range_base &rh) const
 {
-  irange r;
+  value_range_base r;
   if (empty_range_check (r, lh, rh))
     return r;
 
@@ -1236,14 +1320,15 @@ operator_cast::fold_range (tree type ATTRIBUTE_UNUSED,
 				  lh_lb, lh_ub))
 	accumulate_possibly_reversed_range (r, type, min, max);
       else
-	return irange (type);
+	return value_range_base (type);
     }
   return r;
 }
 
 bool
-operator_cast::op1_range (irange &r, tree type,
-			  const irange &lhs, const irange &op2) const
+operator_cast::op1_range (value_range_base &r, tree type,
+			  const value_range_base &lhs,
+			  const value_range_base &op2) const
 {
   tree lhs_type = lhs.type ();
   gcc_checking_assert (types_compatible_p (op2.type(), type));
@@ -1256,14 +1341,15 @@ operator_cast::op1_range (irange &r, tree type,
       /* If we've been passed an actual value for the RHS rather than the type
 	 see if it fits the LHS, and if so, then we can allow it.  */
       r = op2;
-      r = fold_range (lhs_type, r, irange (lhs_type));
-      r = fold_range (type, r, irange (type));
+      r = fold_range (lhs_type, r, value_range_base (lhs_type));
+      r = fold_range (type, r, value_range_base (type));
       if (r == op2)
         {
-	  /* We know the value of the RHS fits in the LHS type, so convert the
-	     left hand side and remove any values that arent in OP2.  */
+	  /* We know the value of the RHS fits in the LHS type, so
+	     convert the left hand side and remove any values that
+	     arent in OP2.  */
 	  r = lhs;
-	  r = fold_range (type, r, irange (type));
+	  r = fold_range (type, r, value_range_base (type));
 	  r.intersect (op2);
 	  return true;
 	}
@@ -1277,15 +1363,16 @@ operator_cast::op1_range (irange &r, tree type,
 	      r = op2;
 	      return true;
 	    }
-	  /* Boolean casts are weird in GCC. It's actually an implied mask with
-	      0x01, so all that is known is whether the rightmost bit is 0 or 1,
-	      which implies the only value *not* in the RHS is 0 or -1.  */
+	  /* Boolean casts are weird in GCC. It's actually an implied
+	      mask with 0x01, so all that is known is whether the
+	      rightmost bit is 0 or 1, which implies the only value
+	      *not* in the RHS is 0 or -1.  */
 	  unsigned prec = TYPE_PRECISION (type);
 	  if (lhs.zero_p ())
-	    r = irange (VR_ANTI_RANGE, type,
+	    r = value_range_base (VR_ANTI_RANGE, type,
 			wi::minus_one (prec), wi::minus_one (prec));
 	  else
-	    r = irange (VR_ANTI_RANGE, type,
+	    r = value_range_base (VR_ANTI_RANGE, type,
 			wi::zero (prec), wi::zero (prec));
 	  /* And intersect it with what we know about op2.  */
 	  r.intersect (op2);
@@ -1296,22 +1383,24 @@ operator_cast::op1_range (irange &r, tree type,
       return true;
     }
 
-  /* If the LHS precision is greater than the rhs precision, the LHS range
-     is resticted to the range of the RHS by this assignment.  */
+  /* If the LHS precision is greater than the rhs precision, the LHS
+     range is resticted to the range of the RHS by this
+     assignment.  */
   if (TYPE_PRECISION (lhs_type) > TYPE_PRECISION (type))
     {
       /* Cast the range of the RHS to the type of the LHS. */
-      irange op_type (type);
-      op_type = fold_range (lhs_type, op_type, irange (lhs_type));
+      value_range_base op_type (type);
+      op_type = fold_range (lhs_type, op_type, value_range_base (lhs_type));
 
-      /* Intersect this with the LHS range will produce the RHS range.  */
+      /* Intersect this with the LHS range will produce the RHS
+	 range.  */
       r = range_intersect (lhs, op_type);
     }
   else
     r = lhs;
 
   /* Cast the calculated range to the type of the RHS.  */
-  r = fold_range (type, r, irange (type));
+  r = fold_range (type, r, value_range_base (type));
   return true;
 }
 
@@ -1322,19 +1411,24 @@ operator_cast::op1_range (irange &r, tree type,
 class operator_logical_and : public range_operator
 {
 public:
-  virtual irange fold_range (tree type, const irange &lh, const irange &rh) const;
-  virtual bool op1_range (irange &r, tree type, const irange &lhs,
-			   const irange &op2) const;
-  virtual bool op2_range (irange &r, tree type, const irange &lhs,
-			   const irange &op1) const;
+  virtual value_range_base fold_range (tree type,
+				       const value_range_base &lh,
+				       const value_range_base &rh) const;
+  virtual bool op1_range (value_range_base &r, tree type,
+			  const value_range_base &lhs,
+			  const value_range_base &op2) const;
+  virtual bool op2_range (value_range_base &r, tree type,
+			  const value_range_base &lhs,
+			  const value_range_base &op1) const;
 } op_logical_and;
 
 
-irange
+value_range_base
 operator_logical_and::fold_range (tree type,
-				  const irange &lh, const irange &rh) const
+				  const value_range_base &lh,
+				  const value_range_base &rh) const
 {
-  irange r;
+  value_range_base r;
   if (empty_range_check (r, lh, rh))
     return r;
 
@@ -1356,8 +1450,9 @@ operator_logical_and::fold_range (tree type,
 
 
 bool
-operator_logical_and::op1_range (irange &r, tree type, const irange &lhs,
-				 const irange &op2 ATTRIBUTE_UNUSED) const
+operator_logical_and::op1_range (value_range_base &r, tree type,
+				 const value_range_base &lhs,
+				 const value_range_base &op2 ATTRIBUTE_UNUSED) const
 {
    switch (get_bool_state (r, lhs, type))
      {
@@ -1375,8 +1470,9 @@ operator_logical_and::op1_range (irange &r, tree type, const irange &lhs,
 }
 
 bool
-operator_logical_and::op2_range (irange &r, tree type,
-				 const irange &lhs, const irange &op1) const
+operator_logical_and::op2_range (value_range_base &r, tree type,
+				 const value_range_base &lhs,
+				 const value_range_base &op1) const
 {
   return operator_logical_and::op1_range (r, type, lhs, op1);
 }
@@ -1384,20 +1480,26 @@ operator_logical_and::op2_range (irange &r, tree type,
 class operator_bitwise_and : public range_operator
 {
 public:
-  virtual bool op1_range (irange &r, tree type, const irange &lhs,
-			  const irange &op2) const;
-  virtual bool op2_range (irange &r, tree type, const irange &lhs,
-			  const irange &op1) const;
-  virtual irange wi_fold (tree type,
-			  const wide_int &lh_lb, const wide_int &lh_ub,
-			  const wide_int &rh_lb, const wide_int &rh_ub) const;
+  virtual bool op1_range (value_range_base &r, tree type,
+			  const value_range_base &lhs,
+			  const value_range_base &op2) const;
+  virtual bool op2_range (value_range_base &r, tree type,
+			  const value_range_base &lhs,
+			  const value_range_base &op1) const;
+  virtual value_range_base wi_fold (tree type,
+				    const wide_int &lh_lb,
+				    const wide_int &lh_ub,
+				    const wide_int &rh_lb,
+				    const wide_int &rh_ub) const;
 } op_bitwise_and;
 
 
-irange
+value_range_base
 operator_bitwise_and::wi_fold (tree type,
-			       const wide_int &lh_lb, const wide_int &lh_ub,
-			       const wide_int &rh_lb, const wide_int &rh_ub) const
+			       const wide_int &lh_lb,
+			       const wide_int &lh_ub,
+			       const wide_int &rh_lb,
+			       const wide_int &rh_ub) const
 {
   wide_int new_lb, new_ub, tmp;
   signop s = TYPE_SIGN (type);
@@ -1420,29 +1522,32 @@ operator_bitwise_and::wi_fold (tree type,
     {
       // For AND, calculate each subrange separately, and then union
       // the results.
-      irange tmp;
+      value_range_base tmp;
       accumulate_range (tmp, type, new_lb, new_ub);
       return tmp;
     }
-  return irange (type);
+  return value_range_base (type);
 }
 
 bool
-operator_bitwise_and::op1_range (irange &r, tree type,
-				 const irange &lhs, const irange &op2) const
+operator_bitwise_and::op1_range (value_range_base &r, tree type,
+				 const value_range_base &lhs,
+				 const value_range_base &op2) const
 {
   /* If this is really a logical wi_fold, call that.  */
   if (types_compatible_p (type, boolean_type_node))
     return op_logical_and.op1_range (r, type, lhs, op2);
 
-  /* For now do nothing with bitwise AND of iranges, just return the type. */
+  /* For now do nothing with bitwise AND of value_range's, just return
+     the type. */
   r.set_varying (type);
   return true;
 }
 
 bool
-operator_bitwise_and::op2_range (irange &r, tree type, const irange &lhs,
-				  const irange &op1) const
+operator_bitwise_and::op2_range (value_range_base &r, tree type,
+				 const value_range_base &lhs,
+				 const value_range_base &op1) const
 {
   return operator_bitwise_and::op1_range (r, type, lhs, op1);
 }
@@ -1451,20 +1556,24 @@ operator_bitwise_and::op2_range (irange &r, tree type, const irange &lhs,
 class operator_logical_or : public range_operator
 {
 public:
-  virtual irange fold_range (tree type,
-			     const irange &lh, const irange &rh) const;
-  virtual bool op1_range (irange &r, tree type,
-			  const irange &lhs, const irange &op2) const;
-  virtual bool op2_range (irange &r, tree type,
-			  const irange &lhs, const irange &op1) const;
+  virtual value_range_base fold_range (tree type,
+				       const value_range_base &lh,
+				       const value_range_base &rh) const;
+  virtual bool op1_range (value_range_base &r, tree type,
+			  const value_range_base &lhs,
+			  const value_range_base &op2) const;
+  virtual bool op2_range (value_range_base &r, tree type,
+			  const value_range_base &lhs,
+			  const value_range_base &op1) const;
 } op_logical_or;
 
 
-irange
+value_range_base
 operator_logical_or::fold_range (tree type ATTRIBUTE_UNUSED,
-				 const irange &lh, const irange &rh) const
+				 const value_range_base &lh,
+				 const value_range_base &rh) const
 {
-  irange r;
+  value_range_base r;
   if (empty_range_check (r, lh, rh))
     return r;
 
@@ -1472,8 +1581,8 @@ operator_logical_or::fold_range (tree type ATTRIBUTE_UNUSED,
 }
 
 bool
-operator_logical_or::op1_range (irange &r, tree type, const irange &lhs,
-				const irange &op2 ATTRIBUTE_UNUSED) const
+operator_logical_or::op1_range (value_range_base &r, tree type, const value_range_base &lhs,
+				const value_range_base &op2 ATTRIBUTE_UNUSED) const
 {
    switch (get_bool_state (r, lhs, type))
      {
@@ -1481,8 +1590,9 @@ operator_logical_or::op1_range (irange &r, tree type, const irange &lhs,
        case BRS_FALSE:
          r = range_false (type);
 	 break;
-       /* Any other result means only one side has to be true, the other
-	  side can be anything. SO we cant be sure of any result here.  */
+       /* Any other result means only one side has to be true, the
+	  other side can be anything. SO we cant be sure of any result
+	  here.  */
       default:
 	r = range_true_and_false (type);
 	break;
@@ -1491,8 +1601,9 @@ operator_logical_or::op1_range (irange &r, tree type, const irange &lhs,
 }
 
 bool
-operator_logical_or::op2_range (irange &r, tree type, const irange &lhs,
-				  const irange &op1) const
+operator_logical_or::op2_range (value_range_base &r, tree type,
+				const value_range_base &lhs,
+				const value_range_base &op1) const
 {
   return operator_logical_or::op1_range (r, type, lhs, op1);
 }
@@ -1500,20 +1611,26 @@ operator_logical_or::op2_range (irange &r, tree type, const irange &lhs,
 class operator_bitwise_or : public range_operator
 {
 public:
-  virtual bool op1_range (irange &r, tree type, const irange &lhs,
-			   const irange &op2) const;
-  virtual bool op2_range (irange &r, tree type, const irange &lhs,
-			   const irange &op1) const;
-  virtual irange wi_fold (tree type,
-			  const wide_int &lh_lb, const wide_int &lh_ub,
-			  const wide_int &rh_lb, const wide_int &rh_ub) const;
+  virtual bool op1_range (value_range_base &r, tree type,
+			  const value_range_base &lhs,
+			  const value_range_base &op2) const;
+  virtual bool op2_range (value_range_base &r, tree type,
+			  const value_range_base &lhs,
+			  const value_range_base &op1) const;
+  virtual value_range_base wi_fold (tree type,
+				    const wide_int &lh_lb,
+				    const wide_int &lh_ub,
+				    const wide_int &rh_lb,
+				    const wide_int &rh_ub) const;
 } op_bitwise_or;
 
 
-irange
+value_range_base
 operator_bitwise_or::wi_fold (tree type,
-			      const wide_int &lh_lb, const wide_int &lh_ub,
-			      const wide_int &rh_lb, const wide_int &rh_ub) const
+			      const wide_int &lh_lb,
+			      const wide_int &lh_ub,
+			      const wide_int &rh_lb,
+			      const wide_int &rh_ub) const
 {
   wide_int new_lb, new_ub, tmp;
   signop s = TYPE_SIGN (type);
@@ -1534,29 +1651,32 @@ operator_bitwise_or::wi_fold (tree type,
 			      must_be_nonzero_rh,
 			      may_be_nonzero_rh))
     {
-      irange r;
+      value_range_base r;
       accumulate_range (r, type, new_lb, new_ub);
       return r;
     }
-  return irange (type);
+  return value_range_base (type);
 }
 
 bool
-operator_bitwise_or::op1_range (irange &r, tree type,
-				const irange &lhs, const irange &op2) const
+operator_bitwise_or::op1_range (value_range_base &r, tree type,
+				const value_range_base &lhs,
+				const value_range_base &op2) const
 {
   /* If this is really a logical wi_fold, call that.  */
   if (types_compatible_p (type, boolean_type_node))
     return op_logical_or.op1_range (r, type, lhs, op2);
 
-  /* For now do nothing with bitwise OR of iranges, just return the type. */
+  /* For now do nothing with bitwise OR of value_range's, just
+     return the type. */
   r.set_varying (type);
   return true;
 }
 
 bool
-operator_bitwise_or::op2_range (irange &r, tree type,
-				const irange &lhs, const irange &op1) const
+operator_bitwise_or::op2_range (value_range_base &r, tree type,
+				const value_range_base &lhs,
+				const value_range_base &op1) const
 {
   return operator_bitwise_or::op1_range (r, type, lhs, op1);
 }
@@ -1564,16 +1684,20 @@ operator_bitwise_or::op2_range (irange &r, tree type,
 class operator_bitwise_xor : public range_operator
 {
 public:
-  virtual irange wi_fold (tree type,
-			  const wide_int &lh_lb, const wide_int &lh_ub,
-			  const wide_int &rh_lb, const wide_int &rh_ub) const;
+  virtual value_range_base wi_fold (tree type,
+				    const wide_int &lh_lb,
+				    const wide_int &lh_ub,
+				    const wide_int &rh_lb,
+				    const wide_int &rh_ub) const;
 } op_bitwise_xor;
 
 
-irange
+value_range_base
 operator_bitwise_xor::wi_fold (tree type,
-			       const wide_int &lh_lb, const wide_int &lh_ub,
-			       const wide_int &rh_lb, const wide_int &rh_ub) const
+			       const wide_int &lh_lb,
+			       const wide_int &lh_ub,
+			       const wide_int &rh_lb,
+			       const wide_int &rh_ub) const
 {
   wide_int new_lb, new_ub, tmp;
   signop s = TYPE_SIGN (type);
@@ -1592,38 +1716,42 @@ operator_bitwise_xor::wi_fold (tree type,
 			      must_be_nonzero_rh,
 			      may_be_nonzero_rh))
     {
-      irange r;
+      value_range_base r;
       accumulate_range (r, type, new_lb, new_ub);
       return r;
     }
-  return irange (type);
+  return value_range_base (type);
 }
 
 
 class operator_trunc_mod : public range_operator
 {
 public:
-  virtual irange wi_fold (tree type,
-			  const wide_int &lh_lb, const wide_int &lh_ub,
-			  const wide_int &rh_lb, const wide_int &rh_ub) const;
+  virtual value_range_base wi_fold (tree type,
+				    const wide_int &lh_lb,
+				    const wide_int &lh_ub,
+				    const wide_int &rh_lb,
+				    const wide_int &rh_ub) const;
 } op_trunc_mod;
 
 
-irange
+value_range_base
 operator_trunc_mod::wi_fold (tree type,
-			     const wide_int &lh_lb, const wide_int &lh_ub,
-			     const wide_int &rh_lb, const wide_int &rh_ub) const
+			     const wide_int &lh_lb,
+			     const wide_int &lh_ub,
+			     const wide_int &rh_lb,
+			     const wide_int &rh_ub) const
 {
   wide_int new_lb, new_ub, tmp;
   signop s = TYPE_SIGN (type);
 
   /* Mod 0 is undefined.  Return undefined.  */
   if (wide_int_range_zero_p (rh_lb, rh_ub, TYPE_PRECISION (type)))
-    return irange ();
+    return value_range_base ();
 
   wide_int_range_trunc_mod (new_lb, new_ub, s, TYPE_PRECISION (type),
 			    lh_lb, lh_ub, rh_lb, rh_ub);
-  irange r;
+  value_range_base r;
   accumulate_range (r, type, new_lb, new_ub);
   return r;
 }
@@ -1632,10 +1760,12 @@ operator_trunc_mod::wi_fold (tree type,
 class operator_logical_not : public range_operator
 {
 public:
-  virtual irange fold_range (tree type,
-			     const irange &lh, const irange &rh) const;
-  virtual bool op1_range (irange &r, tree type,
-			  const irange &lhs, const irange &op2) const;
+  virtual value_range_base fold_range (tree type,
+				       const value_range_base &lh,
+				       const value_range_base &rh) const;
+  virtual bool op1_range (value_range_base &r, tree type,
+			  const value_range_base &lhs,
+			  const value_range_base &op2) const;
 } op_logical_not;
 
 
@@ -1652,11 +1782,12 @@ public:
 	 b_2 = x_1 < 20		[0,0] = x_1 < 20,   false, so x_1 == [20, 255]
      which is the result we are looking for.. so.. pass it thru.  */
 
-irange
-operator_logical_not::fold_range (tree type, const irange &lh,
-				  const irange &rh ATTRIBUTE_UNUSED) const
+value_range_base
+operator_logical_not::fold_range (tree type,
+				  const value_range_base &lh,
+				  const value_range_base &rh ATTRIBUTE_UNUSED) const
 {
-  irange r;
+  value_range_base r;
   if (empty_range_check (r, lh, rh))
     return r;
 
@@ -1669,9 +1800,10 @@ operator_logical_not::fold_range (tree type, const irange &lh,
 }
 
 bool
-operator_logical_not::op1_range (irange &r, tree type ATTRIBUTE_UNUSED,
-				 const irange &lhs,
-				 const irange &op2 ATTRIBUTE_UNUSED) const
+operator_logical_not::op1_range (value_range_base &r,
+				 tree type ATTRIBUTE_UNUSED,
+				 const value_range_base &lhs,
+				 const value_range_base &op2 ATTRIBUTE_UNUSED) const
 {
   if (lhs.varying_p () || lhs.undefined_p ())
     r = lhs;
@@ -1684,22 +1816,25 @@ operator_logical_not::op1_range (irange &r, tree type ATTRIBUTE_UNUSED,
 class operator_bitwise_not : public range_operator
 {
 public:
-  virtual irange fold_range (tree type,
-			     const irange &lh, const irange &rh) const;
-  virtual bool op1_range (irange &r, tree type,
-			  const irange &lhs, const irange &op2) const;
+  virtual value_range_base fold_range (tree type,
+				       const value_range_base &lh,
+				       const value_range_base &rh) const;
+  virtual bool op1_range (value_range_base &r, tree type,
+			  const value_range_base &lhs,
+			  const value_range_base &op2) const;
 } op_bitwise_not;
 
-irange
+value_range_base
 operator_bitwise_not::fold_range (tree type,
-				  const irange &lh, const irange &rh) const
+				  const value_range_base &lh,
+				  const value_range_base &rh) const
 {
-  irange r;
+  value_range_base r;
   if (empty_range_check (r, lh, rh))
     return r;
 
   // ~X is simply -1 - X.
-  irange minusone (type,
+  value_range_base minusone (type,
 		   wi::minus_one (TYPE_PRECISION (type)),
 		   wi::minus_one (TYPE_PRECISION (type)));
   r = range_op_handler (MINUS_EXPR, type)->fold_range (type, minusone, lh);
@@ -1707,8 +1842,9 @@ operator_bitwise_not::fold_range (tree type,
 }
 
 bool
-operator_bitwise_not::op1_range (irange &r, tree type,
-				 const irange &lhs, const irange &op2) const
+operator_bitwise_not::op1_range (value_range_base &r, tree type,
+				 const value_range_base &lhs,
+				 const value_range_base &op2) const
 {
   // ~X is -1 - X and since bitwise NOT is involutary...do it again.
   r = fold_range (type, lhs, op2);
@@ -1722,15 +1858,16 @@ operator_bitwise_not::op1_range (irange &r, tree type,
 class operator_cst : public range_operator
 {
 public:
-  virtual irange fold_range (tree type,
-			     const irange &op1, const irange &op2) const;
+  virtual value_range_base fold_range (tree type,
+				       const value_range_base &op1,
+				       const value_range_base &op2) const;
 } op_integer_cst;
 
 
-irange
+value_range_base
 operator_cst::fold_range (tree type ATTRIBUTE_UNUSED,
-			  const irange &lh,
-			  const irange &rh ATTRIBUTE_UNUSED) const
+			  const value_range_base &lh,
+			  const value_range_base &rh ATTRIBUTE_UNUSED) const
 {
   return lh;
 }
@@ -1741,24 +1878,26 @@ operator_cst::fold_range (tree type ATTRIBUTE_UNUSED,
 class operator_identity : public range_operator
 {
 public:
-  virtual irange fold_range (tree type,
-			     const irange &op1, const irange &op2) const;
-  virtual bool op1_range (irange &r, tree type, const irange &lhs,
-			   const irange &op2) const;
+  virtual value_range_base fold_range (tree type,
+				       const value_range_base &op1,
+				       const value_range_base &op2) const;
+  virtual bool op1_range (value_range_base &r, tree type,
+			  const value_range_base &lhs,
+			  const value_range_base &op2) const;
 } op_identity;
 
-irange
+value_range_base
 operator_identity::fold_range (tree type ATTRIBUTE_UNUSED,
-			       const irange &lh,
-			       const irange &rh ATTRIBUTE_UNUSED) const
+			       const value_range_base &lh,
+			       const value_range_base &rh ATTRIBUTE_UNUSED) const
 {
   return lh;
 }
 
 bool
-operator_identity::op1_range (irange &r, tree type ATTRIBUTE_UNUSED,
-			      const irange &lhs,
-			      const irange &op2 ATTRIBUTE_UNUSED) const
+operator_identity::op1_range (value_range_base &r, tree type ATTRIBUTE_UNUSED,
+			      const value_range_base &lhs,
+			      const value_range_base &op2 ATTRIBUTE_UNUSED) const
 {
   r = lhs;
   return true;
@@ -1770,15 +1909,18 @@ operator_identity::op1_range (irange &r, tree type ATTRIBUTE_UNUSED,
 class operator_abs : public range_operator
 {
  public:
-  virtual irange wi_fold (tree type,
-			  const wide_int &lh_lb, const wide_int &lh_ub,
-			  const wide_int &rh_lb, const wide_int &rh_ub) const;
-  virtual bool op1_range (irange &r, tree type,
-			  const irange &lhs, const irange &op2) const;
+  virtual value_range_base wi_fold (tree type,
+				    const wide_int &lh_lb,
+				    const wide_int &lh_ub,
+				    const wide_int &rh_lb,
+				    const wide_int &rh_ub) const;
+  virtual bool op1_range (value_range_base &r, tree type,
+			  const value_range_base &lhs,
+			  const value_range_base &op2) const;
 } op_abs;
 
 
-irange
+value_range_base
 operator_abs::wi_fold (tree type,
 		       const wide_int &lh_lb, const wide_int &lh_ub,
 		       const wide_int &rh_lb ATTRIBUTE_UNUSED,
@@ -1791,14 +1933,15 @@ operator_abs::wi_fold (tree type,
 			  TYPE_PRECISION (type),
 			  lh_lb, lh_ub,
 			  TYPE_OVERFLOW_UNDEFINED (type)))
-    return irange (type, new_lb, new_ub);
-  return irange (type);
+    return value_range_base (type, new_lb, new_ub);
+  return value_range_base (type);
 }
 
 
 bool
-operator_abs::op1_range (irange &r, tree type,
-			 const irange &lhs, const irange &op2) const
+operator_abs::op1_range (value_range_base &r, tree type,
+			 const value_range_base &lhs,
+			 const value_range_base &op2) const
 {
   if (empty_range_check (r, lhs, op2))
     return true;
@@ -1808,13 +1951,13 @@ operator_abs::op1_range (irange &r, tree type,
       return true;
     }
   // Start with the positives because negatives are an impossible result.
-  irange positives = range_positives (type);
+  value_range_base positives = range_positives (type);
   positives.intersect (lhs);
   r = positives;
   // Then add the negative of each pair:
   // ABS(op1) = [5,20] would yield op1 => [-20,-5][5,20].
   for (unsigned i = 0; i < positives.num_pairs (); ++i)
-    r.union_ (irange (type,
+    r.union_ (value_range_base (type,
 		      -positives.upper_bound (i),
 		      -positives.lower_bound (i)));
   return true;
@@ -1823,12 +1966,12 @@ operator_abs::op1_range (irange &r, tree type,
 class operator_absu : public range_operator
 {
  public:
-  virtual irange wi_fold (tree type,
+  virtual value_range_base wi_fold (tree type,
 			  const wide_int &lh_lb, const wide_int &lh_ub,
 			  const wide_int &rh_lb, const wide_int &rh_ub) const;
 } op_absu;
 
-irange
+value_range_base
 operator_absu::wi_fold (tree type,
 			const wide_int &lh_lb, const wide_int &lh_ub,
 			const wide_int &rh_lb ATTRIBUTE_UNUSED,
@@ -1847,8 +1990,8 @@ operator_absu::wi_fold (tree type,
       new_lb = wi::abs (lh_lb);
       new_ub = wi::abs (lh_ub);
 
-      /* If the range contains zero then we know that the minimum value in the
-	 range will be zero.  */
+      /* If the range contains zero then we know that the minimum
+	 value in the range will be zero.  */
       if (wi::ges_p (lh_ub, 0))
 	{
 	  if (wi::gtu_p (new_lb, new_ub))
@@ -1860,27 +2003,30 @@ operator_absu::wi_fold (tree type,
 	std::swap (new_lb, new_ub);
     }
 
-//  r.union_ (irange (unsigned_type_for (type), new_lb, new_ub));
+//  r.union_ (value_range_base (unsigned_type_for (type), new_lb, new_ub));
   gcc_checking_assert (TYPE_UNSIGNED (type));
-  return irange (type, new_lb, new_ub);
+  return value_range_base (type, new_lb, new_ub);
 }
 
 class operator_negate : public range_operator
 {
  public:
-  virtual irange fold_range (tree type,
-			     const irange &op1, const irange &op2) const;
-  virtual bool op1_range (irange &r, tree type, const irange &lhs,
-			  const irange &op2) const;
+  virtual value_range_base fold_range (tree type,
+				       const value_range_base &op1,
+				       const value_range_base &op2) const;
+  virtual bool op1_range (value_range_base &r, tree type,
+			  const value_range_base &lhs,
+			  const value_range_base &op2) const;
 } op_negate;
 
 /* Return the negated range of lh with the type of rh.  */
 
-irange
+value_range_base
 operator_negate::fold_range (tree type,
-			     const irange &lh, const irange &rh) const
+			     const value_range_base &lh,
+			     const value_range_base &rh) const
 {
-  irange r;
+  value_range_base r;
   if (empty_range_check (r, lh, rh))
     return r;
   // -X is simply 0 - X.
@@ -1890,8 +2036,9 @@ operator_negate::fold_range (tree type,
 }
 
 bool
-operator_negate::op1_range (irange &r, tree type,
-			    const irange &lhs, const irange &op2) const
+operator_negate::op1_range (value_range_base &r, tree type,
+			    const value_range_base &lhs,
+			    const value_range_base &op2) const
 {
   // NEGATE is involutory.
   r = fold_range (type, lhs, op2);
@@ -1901,17 +2048,20 @@ operator_negate::op1_range (irange &r, tree type,
 class operator_addr_expr : public range_operator
 {
 public:
-  virtual irange fold_range (tree type,
-			     const irange &op1, const irange &op2) const;
-  virtual bool op1_range (irange &r, tree type, const irange &lhs,
-			  const irange &op2) const;
+  virtual value_range_base fold_range (tree type,
+				       const value_range_base &op1,
+				       const value_range_base &op2) const;
+  virtual bool op1_range (value_range_base &r, tree type,
+			  const value_range_base &lhs,
+			  const value_range_base &op2) const;
 } op_addr;
 
-irange
+value_range_base
 operator_addr_expr::fold_range (tree type,
-				const irange &lh, const irange &rh) const
+				const value_range_base &lh,
+				const value_range_base &rh) const
 {
-  irange r;
+  value_range_base r;
   if (empty_range_check (r, lh, rh))
     return r;
 
@@ -1920,14 +2070,15 @@ operator_addr_expr::fold_range (tree type,
     return range_zero (type);
   if (!lh.contains_p (build_zero_cst (lh.type ())))
     return range_nonzero (type);
-  return irange (type);
+  return value_range_base (type);
 }
 
 // The same functionality for fold() applies to op1_range...
 // effectively copying the non-nullness.
 bool
-operator_addr_expr::op1_range (irange &r, tree type, const irange &lhs,
-			       const irange &op2) const
+operator_addr_expr::op1_range (value_range_base &r, tree type,
+			       const value_range_base &lhs,
+			       const value_range_base &op2) const
 {
   r = operator_addr_expr::fold_range (type, lhs, op2);
   return true;
@@ -1940,16 +2091,18 @@ operator_addr_expr::op1_range (irange &r, tree type, const irange &lhs,
 class pointer_plus_operator : public range_operator
 {
 public:
-  virtual irange wi_fold (tree type,
+  virtual value_range_base wi_fold (tree type,
                           const wide_int &lh_lb, const wide_int &lh_ub,
                           const wide_int &rh_lb, const wide_int &rh_ub) const;
 } op_pointer_plus;
 
 
-irange 
+value_range_base 
 pointer_plus_operator::wi_fold (tree type,
-				const wide_int &lh_lb, const wide_int &lh_ub,
-				const wide_int &rh_lb, const wide_int &rh_ub) const
+				const wide_int &lh_lb,
+				const wide_int &lh_ub,
+				const wide_int &rh_lb,
+				const wide_int &rh_ub) const
 {
   unsigned prec = lh_lb.get_precision ();
   signop sign = TYPE_SIGN (type);
@@ -1978,7 +2131,7 @@ pointer_plus_operator::wi_fold (tree type,
   if (wide_int_range_zero_p (lh_lb, lh_ub, prec)
       && wide_int_range_zero_p (rh_lb, rh_ub, prec))
     return range_zero (type);
-  return irange (type);
+  return value_range_base (type);
 }
 
 // ---------------------------------------------------------------------------
@@ -1986,13 +2139,13 @@ pointer_plus_operator::wi_fold (tree type,
 class pointer_min_max_operator : public range_operator
 {
 public:
-  virtual irange wi_fold (tree type,
+  virtual value_range_base wi_fold (tree type,
                           const wide_int &lh_lb, const wide_int &lh_ub,
                           const wide_int &rh_lb, const wide_int &rh_ub) const;
 } op_ptr_min_max;
 
 
-irange 
+value_range_base 
 pointer_min_max_operator::wi_fold (tree type,
 				   const wide_int &lh_lb,
 				   const wide_int &lh_ub,
@@ -2013,7 +2166,7 @@ pointer_min_max_operator::wi_fold (tree type,
   if (wide_int_range_zero_p (lh_lb, lh_ub, prec)
       && wide_int_range_zero_p (rh_lb, rh_ub, prec))
     return range_zero (type);
-  return irange (type);
+  return value_range_base (type);
 }
 
 // ---------------------------------------------------------------------------
@@ -2021,16 +2174,18 @@ pointer_min_max_operator::wi_fold (tree type,
 class pointer_and_operator : public range_operator
 {
 public:
-  virtual irange wi_fold (tree type,
+  virtual value_range_base wi_fold (tree type,
 			  const wide_int &lh_lb, const wide_int &lh_ub,
 			  const wide_int &rh_lb, const wide_int &rh_ub) const;
 } op_pointer_and;
 
 
-irange
+value_range_base
 pointer_and_operator::wi_fold (tree type,
-			       const wide_int &lh_lb, const wide_int &lh_ub,
-			       const wide_int &rh_lb, const wide_int &rh_ub) const
+			       const wide_int &lh_lb,
+			       const wide_int &lh_ub,
+			       const wide_int &rh_lb,
+			       const wide_int &rh_ub) const
 {
   unsigned prec = lh_lb.get_precision ();
   signop sign = TYPE_SIGN (type);
@@ -2045,7 +2200,7 @@ pointer_and_operator::wi_fold (tree type,
       || wide_int_range_zero_p (lh_lb, lh_ub, prec))
     return range_zero (type);
 
-  return irange (type);
+  return value_range_base (type);
 }
 
 
@@ -2055,16 +2210,18 @@ pointer_and_operator::wi_fold (tree type,
 class pointer_or_operator : public range_operator
 {
 public:
-  virtual irange wi_fold (tree type,
+  virtual value_range_base wi_fold (tree type,
 			  const wide_int &lh_lb, const wide_int &lh_ub,
 			  const wide_int &rh_lb, const wide_int &rh_ub) const;
 } op_pointer_or;
 
 
-irange 
+value_range_base 
 pointer_or_operator::wi_fold (tree type,
-			      const wide_int &lh_lb, const wide_int &lh_ub,
-			      const wide_int &rh_lb, const wide_int &rh_ub) const
+			      const wide_int &lh_lb,
+			      const wide_int &lh_ub,
+			      const wide_int &rh_lb,
+			      const wide_int &rh_ub) const
 {
   unsigned prec = lh_lb.get_precision ();
   signop sign = TYPE_SIGN (type);
@@ -2078,7 +2235,7 @@ pointer_or_operator::wi_fold (tree type,
   if (wide_int_range_zero_p (lh_lb, lh_ub, prec)
       && wide_int_range_zero_p (rh_lb, rh_ub, prec))
     return range_zero (type);
-  return irange (type);
+  return value_range_base (type);
 }
 
 
@@ -2210,10 +2367,10 @@ range_op_handler (enum tree_code code, tree type)
 /* Cast the range in R to TYPE.  */
 
 void
-range_cast (irange &r, tree type)
+range_cast (value_range_base &r, tree type)
 {
   range_operator *op = range_op_handler (CONVERT_EXPR, type);
-  r = op->fold_range (type, r, irange (type));
+  r = op->fold_range (type, r, value_range_base (type));
 }
 
 #if CHECKING_P
@@ -2221,8 +2378,8 @@ range_cast (irange &r, tree type)
 #include "stor-layout.h"
 
 // Ideally this should go in namespace selftest, but range_tests
-// needs to be a friend of class irange so it can access
-// irange::m_max_pairs.
+// needs to be a friend of class value_range_base so it can access
+// value_range_base::m_max_pairs.
 
 #define INT(N) build_int_cst (integer_type_node, (N))
 #define UINT(N) build_int_cstu (unsigned_type_node, (N))
@@ -2235,9 +2392,9 @@ range_cast (irange &r, tree type)
 #define SCHAR(N) build_int_cst (signed_char_type_node, (N))
 
 #define RANGE3(A,B,C,D,E,F)		\
-( i1 = irange (INT (A), INT (B)),	\
-  i2 = irange (INT (C), INT (D)),	\
-  i3 = irange (INT (E), INT (F)),	\
+( i1 = value_range_base (INT (A), INT (B)),	\
+  i2 = value_range_base (INT (C), INT (D)),	\
+  i3 = value_range_base (INT (E), INT (F)),	\
   i1.union_ (i2),			\
   i1.union_ (i3),			\
   i1 )
@@ -2248,31 +2405,31 @@ void
 range_tests ()
 {
   tree u128_type = build_nonstandard_integer_type (128, /*unsigned=*/1);
-  irange i1, i2, i3;
-  irange r0, r1, rold;
+  value_range_base i1, i2, i3;
+  value_range_base r0, r1, rold;
 
   // Test that NOT(255) is [0..254] in 8-bit land.
-  irange not_255 (VR_ANTI_RANGE, UCHAR (255), UCHAR (255));
-  ASSERT_TRUE (not_255 == irange (UCHAR (0), UCHAR (254)));
+  value_range_base not_255 (VR_ANTI_RANGE, UCHAR (255), UCHAR (255));
+  ASSERT_TRUE (not_255 == value_range_base (UCHAR (0), UCHAR (254)));
 
   // Test that NOT(0) is [1..255] in 8-bit land.
-  irange not_zero = range_nonzero (unsigned_char_type_node);
-  ASSERT_TRUE (not_zero == irange (UCHAR (1), UCHAR (255)));
+  value_range_base not_zero = range_nonzero (unsigned_char_type_node);
+  ASSERT_TRUE (not_zero == value_range_base (UCHAR (1), UCHAR (255)));
 
   // Check that [0,127][0x..ffffff80,0x..ffffff]
   //  => ~[128, 0x..ffffff7f].
-  r0 = irange (UINT128 (0), UINT128 (127));
+  r0 = value_range_base (UINT128 (0), UINT128 (127));
   tree high = build_minus_one_cst (u128_type);
   // low = -1 - 127 => 0x..ffffff80.
   tree low = fold_build2 (MINUS_EXPR, u128_type, high, UINT128(127));
-  r1 = irange (low, high); // [0x..ffffff80, 0x..ffffffff]
+  r1 = value_range_base (low, high); // [0x..ffffff80, 0x..ffffffff]
   // r0 = [0,127][0x..ffffff80,0x..fffffff].
   r0.union_ (r1);
   // r1 = [128, 0x..ffffff7f].
-  r1 = irange (UINT128(128),
-	       fold_build2 (MINUS_EXPR, u128_type,
-			    build_minus_one_cst (u128_type),
-			    UINT128(128)));
+  r1 = value_range_base (UINT128(128),
+			 fold_build2 (MINUS_EXPR, u128_type,
+				      build_minus_one_cst (u128_type),
+				      UINT128(128)));
   r0.invert ();
   ASSERT_TRUE (r0 == r1);
 
@@ -2288,127 +2445,128 @@ range_tests ()
   tree maxuint = wide_int_to_tree (unsigned_type_node, r0.upper_bound ());
 
   // Check that ~[0,5] => [6,MAX] for unsigned int.
-  r0 = irange (UINT (0), UINT (5));
+  r0 = value_range_base (UINT (0), UINT (5));
   r0.invert ();
-  ASSERT_TRUE (r0 == irange (UINT(6), maxuint));
+  ASSERT_TRUE (r0 == value_range_base (UINT(6), maxuint));
 
   // Check that ~[10,MAX] => [0,9] for unsigned int.
-  r0 = irange (VR_RANGE, UINT(10), maxuint);
+  r0 = value_range_base (VR_RANGE, UINT(10), maxuint);
   r0.invert ();
-  ASSERT_TRUE (r0 == irange (UINT (0), UINT (9)));
+  ASSERT_TRUE (r0 == value_range_base (UINT (0), UINT (9)));
 
   // Check that ~[0,5] => [6,MAX] for unsigned 128-bit numbers.
-  r0 = irange (VR_ANTI_RANGE, UINT128 (0), UINT128 (5));
-  r1 = irange (UINT128(6), build_minus_one_cst (u128_type));
+  r0 = value_range_base (VR_ANTI_RANGE, UINT128 (0), UINT128 (5));
+  r1 = value_range_base (UINT128(6), build_minus_one_cst (u128_type));
   ASSERT_TRUE (r0 == r1);
 
   // Check that [~5] is really [-MIN,4][6,MAX].
-  r0 = irange (VR_ANTI_RANGE, INT (5), INT (5));
-  r1 = irange (minint, INT (4));
-  r1.union_ (irange (INT (6), maxint));
+  r0 = value_range_base (VR_ANTI_RANGE, INT (5), INT (5));
+  r1 = value_range_base (minint, INT (4));
+  r1.union_ (value_range_base (INT (6), maxint));
   ASSERT_FALSE (r1.undefined_p ());
   ASSERT_TRUE (r0 == r1);
 
-  r1 = irange (INT (5), INT (5));
+  r1 = value_range_base (INT (5), INT (5));
   r1.check ();
-  irange r2 (r1);
+  value_range_base r2 (r1);
   ASSERT_TRUE (r1 == r2);
 
-  r1 = irange (INT (5), INT (10));
+  r1 = value_range_base (INT (5), INT (10));
   r1.check ();
 
-  r1 = irange (integer_type_node,
+  r1 = value_range_base (integer_type_node,
 	       wi::to_wide (INT (5)), wi::to_wide (INT (10)));
   r1.check ();
   ASSERT_TRUE (r1.contains_p (INT (7)));
 
-  r1 = irange (SCHAR (0), SCHAR (20));
+  r1 = value_range_base (SCHAR (0), SCHAR (20));
   ASSERT_TRUE (r1.contains_p (SCHAR(15)));
   ASSERT_FALSE (r1.contains_p (SCHAR(300)));
 
   // If a range is in any way outside of the range for the converted
   // to range, default to the range for the new type.
-  r1 = irange (integer_zero_node, maxint);
+  r1 = value_range_base (integer_zero_node, maxint);
   range_cast (r1, short_integer_type_node);
   ASSERT_TRUE (r1.lower_bound () == wi::to_wide (minshort)
 	       && r1.upper_bound() == wi::to_wide (maxshort));
 
   // (unsigned char)[-5,-1] => [251,255].
-  r0 = rold = irange (SCHAR (-5), SCHAR (-1));
+  r0 = rold = value_range_base (SCHAR (-5), SCHAR (-1));
   range_cast (r0, unsigned_char_type_node);
-  ASSERT_TRUE (r0 == irange (UCHAR (251), UCHAR (255)));
+  ASSERT_TRUE (r0 == value_range_base (UCHAR (251), UCHAR (255)));
   range_cast (r0, signed_char_type_node);
   ASSERT_TRUE (r0 == rold);
 
   // (signed char)[15, 150] => [-128,-106][15,127].
-  r0 = rold = irange (UCHAR (15), UCHAR (150));
+  r0 = rold = value_range_base (UCHAR (15), UCHAR (150));
   range_cast (r0, signed_char_type_node);
-  r1 = irange (SCHAR (15), SCHAR (127));
-  r2 = irange (SCHAR (-128), SCHAR (-106));
+  r1 = value_range_base (SCHAR (15), SCHAR (127));
+  r2 = value_range_base (SCHAR (-128), SCHAR (-106));
   r1.union_ (r2);
   ASSERT_TRUE (r1 == r0);
   range_cast (r0, unsigned_char_type_node);
   ASSERT_TRUE (r0 == rold);
 
   // (unsigned char)[-5, 5] => [0,5][251,255].
-  r0 = rold = irange (SCHAR (-5), SCHAR (5));
+  r0 = rold = value_range_base (SCHAR (-5), SCHAR (5));
   range_cast (r0, unsigned_char_type_node);
-  r1 = irange (UCHAR (251), UCHAR (255));
-  r2 = irange (UCHAR (0), UCHAR (5));
+  r1 = value_range_base (UCHAR (251), UCHAR (255));
+  r2 = value_range_base (UCHAR (0), UCHAR (5));
   r1.union_ (r2);
   ASSERT_TRUE (r0 == r1);
   range_cast (r0, signed_char_type_node);
   ASSERT_TRUE (r0 == rold);
 
   // (unsigned char)[-5,5] => [0,5][251,255].
-  r0 = irange (INT (-5), INT (5));
+  r0 = value_range_base (INT (-5), INT (5));
   range_cast (r0, unsigned_char_type_node);
-  r1 = irange (UCHAR (0), UCHAR (5));
-  r1.union_ (irange (UCHAR (251), UCHAR (255)));
+  r1 = value_range_base (UCHAR (0), UCHAR (5));
+  r1.union_ (value_range_base (UCHAR (251), UCHAR (255)));
   ASSERT_TRUE (r0 == r1);
 
   // (unsigned char)[5U,1974U] => [0,255].
-  r0 = irange (UINT (5), UINT (1974));
+  r0 = value_range_base (UINT (5), UINT (1974));
   range_cast (r0, unsigned_char_type_node);
-  ASSERT_TRUE (r0 == irange (UCHAR (0), UCHAR (255)));
+  ASSERT_TRUE (r0 == value_range_base (UCHAR (0), UCHAR (255)));
   range_cast (r0, integer_type_node);
   // Going to a wider range should not sign extend.
-  ASSERT_TRUE (r0 == irange (INT (0), INT (255)));
+  ASSERT_TRUE (r0 == value_range_base (INT (0), INT (255)));
 
   // (unsigned char)[-350,15] => [0,255].
-  r0 = irange (INT (-350), INT (15));
+  r0 = value_range_base (INT (-350), INT (15));
   range_cast (r0, unsigned_char_type_node);
-  ASSERT_TRUE (r0 == irange (TYPE_MIN_VALUE (unsigned_char_type_node),
-			     TYPE_MAX_VALUE (unsigned_char_type_node)));
+  ASSERT_TRUE (r0 == (value_range_base
+		      (TYPE_MIN_VALUE (unsigned_char_type_node),
+		       TYPE_MAX_VALUE (unsigned_char_type_node))));
 
   // Casting [-120,20] from signed char to unsigned short.
   // => [0, 20][0xff88, 0xffff].
-  r0 = irange (SCHAR (-120), SCHAR (20));
+  r0 = value_range_base (SCHAR (-120), SCHAR (20));
   range_cast (r0, short_unsigned_type_node);
-  r1 = irange (UINT16 (0), UINT16 (20));
-  r2 = irange (UINT16 (0xff88), UINT16 (0xffff));
+  r1 = value_range_base (UINT16 (0), UINT16 (20));
+  r2 = value_range_base (UINT16 (0xff88), UINT16 (0xffff));
   r1.union_ (r2);
   ASSERT_TRUE (r0 == r1);
   // A truncating cast back to signed char will work because [-120, 20]
   // is representable in signed char.
   range_cast (r0, signed_char_type_node);
-  ASSERT_TRUE (r0 == irange (SCHAR (-120), SCHAR (20)));
+  ASSERT_TRUE (r0 == value_range_base (SCHAR (-120), SCHAR (20)));
 
   // unsigned char -> signed short
   //	(signed short)[(unsigned char)25, (unsigned char)250]
   // => [(signed short)25, (signed short)250]
-  r0 = rold = irange (UCHAR (25), UCHAR (250));
+  r0 = rold = value_range_base (UCHAR (25), UCHAR (250));
   range_cast (r0, short_integer_type_node);
-  r1 = irange (INT16 (25), INT16 (250));
+  r1 = value_range_base (INT16 (25), INT16 (250));
   ASSERT_TRUE (r0 == r1);
   range_cast (r0, unsigned_char_type_node);
   ASSERT_TRUE (r0 == rold);
 
   // Test casting a wider signed [-MIN,MAX] to a nar`rower unsigned.
-  r0 = irange (TYPE_MIN_VALUE (long_long_integer_type_node),
+  r0 = value_range_base (TYPE_MIN_VALUE (long_long_integer_type_node),
 	       TYPE_MAX_VALUE (long_long_integer_type_node));
   range_cast (r0, short_unsigned_type_node);
-  r1 = irange (TYPE_MIN_VALUE (short_unsigned_type_node),
+  r1 = value_range_base (TYPE_MIN_VALUE (short_unsigned_type_node),
 	       TYPE_MAX_VALUE (short_unsigned_type_node));
   ASSERT_TRUE (r0 == r1);
 
@@ -2421,25 +2579,25 @@ range_tests ()
   //    (unsigned short)[-5,5][20,30][40,50]...
   // => (unsigned short)[-5,50]
   // => [0,50][65531,65535]
-  r0 = irange (INT16 (-5), INT16 (5));
-  gcc_assert (irange::m_max_pairs * 2 * 10 + 10 < 32767);
+  r0 = value_range_base (INT16 (-5), INT16 (5));
+  gcc_assert (value_range_base::m_max_pairs * 2 * 10 + 10 < 32767);
   unsigned i;
-  for (i = 2; i < irange::m_max_pairs * 2; i += 2)
+  for (i = 2; i < value_range_base::m_max_pairs * 2; i += 2)
     {
-      r1 = irange (INT16 (i * 10), INT16 (i * 10 + 10));
+      r1 = value_range_base (INT16 (i * 10), INT16 (i * 10 + 10));
       r0.union_ (r1);
     }
   range_cast (r0, short_unsigned_type_node);
-  r1 = irange (UINT16 (0), UINT16 ((i - 2) * 10 + 10));
-  r2 = irange (UINT16 (65531), UINT16 (65535));
+  r1 = value_range_base (UINT16 (0), UINT16 ((i - 2) * 10 + 10));
+  r2 = value_range_base (UINT16 (65531), UINT16 (65535));
   r1.union_ (r2);
   ASSERT_TRUE (r0 == r1);
 #endif
 
   // NOT([10,20]) ==> [-MIN,9][21,MAX].
-  r0 = r1 = irange (INT (10), INT (20));
-  r2 = irange (minint, INT(9));
-  r2.union_ (irange (INT(21), maxint));
+  r0 = r1 = value_range_base (INT (10), INT (20));
+  r2 = value_range_base (minint, INT(9));
+  r2.union_ (value_range_base (INT(21), maxint));
   ASSERT_FALSE (r2.undefined_p ());
   r1.invert ();
   ASSERT_TRUE (r1 == r2);
@@ -2448,7 +2606,7 @@ range_tests ()
   ASSERT_TRUE (r0 == r2);
 
   // NOT(-MIN,+MAX) is the empty set and should return false.
-  r0 = irange (minint, maxint);
+  r0 = value_range_base (minint, maxint);
   r0.invert ();
   ASSERT_TRUE (r0.undefined_p ());
   r1.set_undefined ();
@@ -2456,11 +2614,11 @@ range_tests ()
 
   // Test that booleans and their inverse work as expected.
   r0 = range_zero (boolean_type_node);
-  ASSERT_TRUE (r0 == irange (build_zero_cst (boolean_type_node),
-			     build_zero_cst (boolean_type_node)));
+  ASSERT_TRUE (r0 == value_range_base (build_zero_cst (boolean_type_node),
+				       build_zero_cst (boolean_type_node)));
   r0.invert ();
-  ASSERT_TRUE (r0 == irange (build_one_cst (boolean_type_node),
-			     build_one_cst (boolean_type_node)));
+  ASSERT_TRUE (r0 == value_range_base (build_one_cst (boolean_type_node),
+				       build_one_cst (boolean_type_node)));
 
   // Casting NONZERO to a narrower type will wrap/overflow so
   // it's just the entire range for the narrower type.
@@ -2470,8 +2628,8 @@ range_tests ()
   // smaller range.
   r0 = range_nonzero (integer_type_node);
   range_cast (r0, short_integer_type_node);
-  r1 = irange (TYPE_MIN_VALUE (short_integer_type_node),
-	       TYPE_MAX_VALUE (short_integer_type_node));
+  r1 = value_range_base (TYPE_MIN_VALUE (short_integer_type_node),
+			 TYPE_MAX_VALUE (short_integer_type_node));
   ASSERT_TRUE (r0 == r1);
 
   // Casting NONZERO from a narrower signed to a wider signed.
@@ -2480,45 +2638,45 @@ range_tests ()
   // Converting this to 32-bits signed is [-MIN_16,-1][1, +MAX_16].
   r0 = range_nonzero (short_integer_type_node);
   range_cast (r0, integer_type_node);
-  r1 = irange (INT (-32768), INT (-1));
-  r2 = irange (INT (1), INT (32767));
+  r1 = value_range_base (INT (-32768), INT (-1));
+  r2 = value_range_base (INT (1), INT (32767));
   r1.union_ (r2);
   ASSERT_TRUE (r0 == r1);
 
-  if (irange::m_max_pairs > 2)
+  if (value_range_base::m_max_pairs > 2)
     {
       // ([10,20] U [5,8]) U [1,3] ==> [1,3][5,8][10,20].
-      r0 = irange (INT (10), INT (20));
-      r1 = irange (INT (5), INT (8));
+      r0 = value_range_base (INT (10), INT (20));
+      r1 = value_range_base (INT (5), INT (8));
       r0.union_ (r1);
-      r1 = irange (INT (1), INT (3));
+      r1 = value_range_base (INT (1), INT (3));
       r0.union_ (r1);
       ASSERT_TRUE (r0 == RANGE3 (1, 3, 5, 8, 10, 20));
 
       // [1,3][5,8][10,20] U [-5,0] => [-5,3][5,8][10,20].
-      r1 = irange (INT (-5), INT (0));
+      r1 = value_range_base (INT (-5), INT (0));
       r0.union_ (r1);
       ASSERT_TRUE (r0 == RANGE3 (-5, 3, 5, 8, 10, 20));
     }
 
   // [10,20] U [30,40] ==> [10,20][30,40].
-  r0 = irange (INT (10), INT (20));
-  r1 = irange (INT (30), INT (40));
+  r0 = value_range_base (INT (10), INT (20));
+  r1 = value_range_base (INT (30), INT (40));
   r0.union_ (r1);
-  ASSERT_TRUE (r0 == range_union (irange (INT (10), INT (20)),
-				   irange (INT (30), INT (40))));
-  if (irange::m_max_pairs > 2)
+  ASSERT_TRUE (r0 == range_union (value_range_base (INT (10), INT (20)),
+				  value_range_base (INT (30), INT (40))));
+  if (value_range_base::m_max_pairs > 2)
     {
       // [10,20][30,40] U [50,60] ==> [10,20][30,40][50,60].
-      r1 = irange (INT (50), INT (60));
+      r1 = value_range_base (INT (50), INT (60));
       r0.union_ (r1);
       ASSERT_TRUE (r0 == RANGE3 (10, 20, 30, 40, 50, 60));
       // [10,20][30,40][50,60] U [70, 80] ==> [10,20][30,40][50,60][70,80].
-      r1 = irange (INT (70), INT (80));
+      r1 = value_range_base (INT (70), INT (80));
       r0.union_ (r1);
 
       r2 = RANGE3 (10, 20, 30, 40, 50, 60);
-      r2.union_ (irange (INT (70), INT (80)));
+      r2.union_ (value_range_base (INT (70), INT (80)));
       ASSERT_TRUE (r0 == r2);
     }
 
@@ -2531,107 +2689,107 @@ range_tests ()
   r0.invert ();
   ASSERT_TRUE (r0 == r1);
 
-  if (irange::m_max_pairs > 2)
+  if (value_range_base::m_max_pairs > 2)
     {
       // [10,20][30,40][50,60] U [6,35] => [6,40][50,60].
       r0 = RANGE3 (10, 20, 30, 40, 50, 60);
-      r1 = irange (INT (6), INT (35));
+      r1 = value_range_base (INT (6), INT (35));
       r0.union_ (r1);
-      ASSERT_TRUE (r0 == range_union (irange (INT (6), INT (40)),
-				      irange (INT (50), INT (60))));
+      ASSERT_TRUE (r0 == range_union (value_range_base (INT (6), INT (40)),
+				      value_range_base (INT (50), INT (60))));
 
       // [10,20][30,40][50,60] U [6,60] => [6,60] */
       r0 = RANGE3 (10, 20, 30, 40, 50, 60);
-      r1 = irange (INT (6), INT (60));
+      r1 = value_range_base (INT (6), INT (60));
       r0.union_ (r1);
-      ASSERT_TRUE (r0 == irange (INT (6), INT (60)));
+      ASSERT_TRUE (r0 == value_range_base (INT (6), INT (60)));
 
       // [10,20][30,40][50,60] U [6,70] => [6,70].
       r0 = RANGE3 (10, 20, 30, 40, 50, 60);
-      r1 = irange (INT (6), INT (70));
+      r1 = value_range_base (INT (6), INT (70));
       r0.union_ (r1);
-      ASSERT_TRUE (r0 == irange (INT (6), INT (70)));
+      ASSERT_TRUE (r0 == value_range_base (INT (6), INT (70)));
 
       // [10,20][30,40][50,60] U [35,70] => [10,20][30,70].
       r0 = RANGE3 (10, 20, 30, 40, 50, 60);
-      r1 = irange (INT (35), INT (70));
+      r1 = value_range_base (INT (35), INT (70));
       r0.union_ (r1);
-      ASSERT_TRUE (r0 == range_union (irange (INT (10), INT (20)),
-				       irange (INT (30), INT (70))));
+      ASSERT_TRUE (r0 == range_union (value_range_base (INT (10), INT (20)),
+				      value_range_base (INT (30), INT (70))));
     }
 
   // [10,20][30,40] U [25,70] => [10,70].
-  r0 = range_union (irange (INT (10), INT (20)),
-		     irange (INT (30), INT (40)));
-  r1 = irange (INT (25), INT (70));
+  r0 = range_union (value_range_base (INT (10), INT (20)),
+		     value_range_base (INT (30), INT (40)));
+  r1 = value_range_base (INT (25), INT (70));
   r0.union_ (r1);
-  ASSERT_TRUE (r0 == range_union (irange (INT (10), INT (20)),
-				   irange (INT (25), INT (70))));
+  ASSERT_TRUE (r0 == range_union (value_range_base (INT (10), INT (20)),
+				  value_range_base (INT (25), INT (70))));
 
-  if (irange::m_max_pairs > 2)
+  if (value_range_base::m_max_pairs > 2)
     {
       // [10,20][30,40][50,60] U [15,35] => [10,40][50,60].
       r0 = RANGE3 (10, 20, 30, 40, 50, 60);
-      r1 = irange (INT (15), INT (35));
+      r1 = value_range_base (INT (15), INT (35));
       r0.union_ (r1);
-      ASSERT_TRUE (r0 == range_union (irange (INT (10), INT (40)),
-				       irange (INT (50), INT (60))));
+      ASSERT_TRUE (r0 == range_union (value_range_base (INT (10), INT (40)),
+				      value_range_base (INT (50), INT (60))));
     }
 
   // [10,20] U [15, 30] => [10, 30].
-  r0 = irange (INT (10), INT (20));
-  r1 = irange (INT (15), INT (30));
+  r0 = value_range_base (INT (10), INT (20));
+  r1 = value_range_base (INT (15), INT (30));
   r0.union_ (r1);
-  ASSERT_TRUE (r0 == irange (INT (10), INT (30)));
+  ASSERT_TRUE (r0 == value_range_base (INT (10), INT (30)));
 
   // [10,20] U [25,25] => [10,20][25,25].
-  r0 = irange (INT (10), INT (20));
-  r1 = irange (INT (25), INT (25));
+  r0 = value_range_base (INT (10), INT (20));
+  r1 = value_range_base (INT (25), INT (25));
   r0.union_ (r1);
-  ASSERT_TRUE (r0 == range_union (irange (INT (10), INT (20)),
-				   irange (INT (25), INT (25))));
+  ASSERT_TRUE (r0 == range_union (value_range_base (INT (10), INT (20)),
+				  value_range_base (INT (25), INT (25))));
 
-  if (irange::m_max_pairs > 2)
+  if (value_range_base::m_max_pairs > 2)
     {
       // [10,20][30,40][50,60] U [35,35] => [10,20][30,40][50,60].
       r0 = RANGE3 (10, 20, 30, 40, 50, 60);
-      r1 = irange (INT (35), INT (35));
+      r1 = value_range_base (INT (35), INT (35));
       r0.union_ (r1);
       ASSERT_TRUE (r0 == RANGE3 (10, 20, 30, 40, 50, 60));
     }
 
   // [15,40] U [] => [15,40].
-  r0 = irange (INT (15), INT (40));
+  r0 = value_range_base (INT (15), INT (40));
   r1.set_undefined ();
   r0.union_ (r1);
-  ASSERT_TRUE (r0 == irange (INT (15), INT (40)));
+  ASSERT_TRUE (r0 == value_range_base (INT (15), INT (40)));
 
   // [10,20] U [10,10] => [10,20].
-  r0 = irange (INT (10), INT (20));
-  r1 = irange (INT (10), INT (10));
+  r0 = value_range_base (INT (10), INT (20));
+  r1 = value_range_base (INT (10), INT (10));
   r0.union_ (r1);
-  ASSERT_TRUE (r0 == irange (INT (10), INT (20)));
+  ASSERT_TRUE (r0 == value_range_base (INT (10), INT (20)));
 
   // [10,20] U [9,9] => [9,20].
-  r0 = irange (INT (10), INT (20));
-  r1 = irange (INT (9), INT (9));
+  r0 = value_range_base (INT (10), INT (20));
+  r1 = value_range_base (INT (9), INT (9));
   r0.union_ (r1);
-  ASSERT_TRUE (r0 == irange (INT (9), INT (20)));
+  ASSERT_TRUE (r0 == value_range_base (INT (9), INT (20)));
 
-  if (irange::m_max_pairs > 2)
+  if (value_range_base::m_max_pairs > 2)
     {
       // [10,10][12,12][20,100] ^ [15,200].
       r0 = RANGE3 (10, 10, 12, 12, 20, 100);
-      r1 = irange (INT (15), INT (200));
+      r1 = value_range_base (INT (15), INT (200));
       r0.intersect (r1);
-      ASSERT_TRUE (r0 == irange (INT (20), INT (100)));
+      ASSERT_TRUE (r0 == value_range_base (INT (20), INT (100)));
 
       // [10,20][30,40][50,60] ^ [15,25][38,51][55,70]
       // => [15,20][38,40][50,51][55,60]
       r0 = RANGE3 (10, 20, 30, 40, 50, 60);
       r1 = RANGE3 (15, 25, 38, 51, 55, 70);
       r0.intersect (r1);
-      if (irange::m_max_pairs == 3)
+      if (value_range_base::m_max_pairs == 3)
 	{
 	  // When pairs==3, we don't have enough space, so
 	  //  conservatively handle things.  Thus, the ...[50,60].
@@ -2640,7 +2798,7 @@ range_tests ()
       else
 	{
 	  r2 = RANGE3 (15, 20, 38, 40, 50, 51);
-	  r2.union_ (irange (INT (55), INT (60)));
+	  r2.union_ (value_range_base (INT (55), INT (60)));
 	  ASSERT_TRUE (r0 == r2);
 	}
 
@@ -2649,7 +2807,7 @@ range_tests ()
       r0 = RANGE3 (15, 20, 30, 40, 50, 60);
       r1 = RANGE3 (15, 35, 40, 90, 100, 200);
       r0.intersect (r1);
-      if (irange::m_max_pairs == 3)
+      if (value_range_base::m_max_pairs == 3)
 	{
 	  // When pairs==3, we don't have enough space, so
 	  // conservatively handle things.
@@ -2658,7 +2816,7 @@ range_tests ()
       else
 	{
 	  r2 = RANGE3 (15, 20, 30, 35, 40, 40);
-	  r2.union_ (irange (INT (50), INT (60)));
+	  r2.union_ (value_range_base (INT (50), INT (60)));
 	  ASSERT_TRUE (r0 == r2);
 	}
 
@@ -2666,29 +2824,29 @@ range_tests ()
       // range.
       //
       // [8,10][135,255] U [14,14] => [8,10][14,14][135,255]
-      r0 = range_union (irange (INT (8), INT (10)),
-			 irange (INT (135), INT (255)));
-      r1 = irange (INT (14), INT (14));
+      r0 = range_union (value_range_base (INT (8), INT (10)),
+			 value_range_base (INT (135), INT (255)));
+      r1 = value_range_base (INT (14), INT (14));
       r0.union_ (r1);
       ASSERT_TRUE (r0 == RANGE3 (8, 10, 14, 14, 135, 255));
     }
 
   // [10,20] ^ [15,30] => [15,20].
-  r0 = irange (INT (10), INT (20));
-  r1 = irange (INT (15), INT (30));
+  r0 = value_range_base (INT (10), INT (20));
+  r1 = value_range_base (INT (15), INT (30));
   r0.intersect (r1);
-  ASSERT_TRUE (r0 == irange (INT (15), INT (20)));
+  ASSERT_TRUE (r0 == value_range_base (INT (15), INT (20)));
 
   // [10,20][30,40] ^ [40,50] => [40,40].
-  r0 = range_union (irange (INT (10), INT (20)),
-		     irange (INT (30), INT (40)));
-  r1 = irange (INT (40), INT (50));
+  r0 = range_union (value_range_base (INT (10), INT (20)),
+		     value_range_base (INT (30), INT (40)));
+  r1 = value_range_base (INT (40), INT (50));
   r0.intersect (r1);
-  ASSERT_TRUE (r0 == irange (INT (40), INT (40)));
+  ASSERT_TRUE (r0 == value_range_base (INT (40), INT (40)));
 
   // Test non-destructive intersection.
-  r0 = rold = irange (INT (10), INT (20));
-  ASSERT_FALSE (range_intersect (r0, irange (INT (15),
+  r0 = rold = value_range_base (INT (10), INT (20));
+  ASSERT_FALSE (range_intersect (r0, value_range_base (INT (15),
 					     INT (30))).undefined_p ());
   ASSERT_TRUE (r0 == rold);
 
@@ -2697,35 +2855,42 @@ range_tests ()
 			      TYPE_SIGN (boolean_type_node))
 	       == wi::uhwi (1, TYPE_PRECISION (boolean_type_node)));
 
-  // Test irange_storage.
-  r0 = irange (INT (5), INT (10));
-  irange_storage *stow = irange_storage::alloc (r0, integer_type_node);
-  r1 = irange (integer_type_node, stow);
+  // Test value_range_storage.
+  r0 = value_range_base (INT (5), INT (10));
+  value_range_storage *stow;
+  stow = value_range_storage::alloc (r0, integer_type_node);
+  r1 = value_range_base (integer_type_node, stow);
   ASSERT_TRUE (r0 == r1);
 
-  // Test irange_storage with signed 1-bit fields.
+  // Test value_range_storage with signed 1-bit fields.
   tree s1bit_type = make_signed_type (1);
-  r0 = irange (build_int_cst (s1bit_type, -1), build_int_cst (s1bit_type, 0));
-  stow = irange_storage::alloc (r0, s1bit_type);
-  r1 = irange (s1bit_type, stow);
+  r0 = value_range_base (build_int_cst (s1bit_type, -1),
+			 build_int_cst (s1bit_type, 0));
+  stow = value_range_storage::alloc (r0, s1bit_type);
+  r1 = value_range_base (s1bit_type, stow);
   ASSERT_TRUE (r0 == r1);
 
   // Test zero_p().
-  r0 = irange (INT (0), INT (0));
+  r0 = value_range_base (INT (0), INT (0));
   ASSERT_TRUE (r0.zero_p ());
 
   // Test nonzero_p().
-  r0 = irange (INT (0), INT (0));
+  r0 = value_range_base (INT (0), INT (0));
   r0.invert ();
   ASSERT_TRUE (r0.nonzero_p ());
 
-  // Test irange / value_range conversion functions.
-  r0 = irange (VR_ANTI_RANGE, INT (10), INT (20));
-  value_range_base vr = r0;
-  ASSERT_TRUE (vr.kind () == VR_ANTI_RANGE);
-  ASSERT_TRUE (wi::eq_p (10, wi::to_wide (vr.min ()))
-	       && wi::eq_p (20, wi::to_wide (vr.max ())));
-  r1 = vr;
-  ASSERT_TRUE (r0 == r1);
+#if USE_IRANGE
+// Test irange / value_range conversion functions.
+#undef value_range_base
+  {
+    irange r0 = irange (VR_ANTI_RANGE, INT (10), INT (20));
+    value_range_base vr = r0;
+    ASSERT_TRUE (vr.kind () == VR_ANTI_RANGE);
+    ASSERT_TRUE (wi::eq_p (10, wi::to_wide (vr.min ()))
+		 && wi::eq_p (20, wi::to_wide (vr.max ())));
+    irange r1 = vr;
+    ASSERT_TRUE (r0 == r1);
+  }
+#endif // USE_IRANGE
 }
 #endif // CHECKING_P
diff --git a/gcc/range-op.h b/gcc/range-op.h
index b7b370f..bb9662c 100644
--- a/gcc/range-op.h
+++ b/gcc/range-op.h
@@ -21,6 +21,11 @@ along with GCC; see the file COPYING3.  If not see
 #ifndef GCC_RANGE_OP_H
 #define GCC_RANGE_OP_H
 
+#if USE_IRANGE
+#define value_range_base irange
+#define value_range_storage irange_storage
+#endif
+
 // This class is implemented for each kind of operator that is supported by
 // the range generator.  It serves dual purposes.
 //
@@ -48,8 +53,9 @@ class range_operator
 public:
   // Set a range based on this operation between 2 operands.
   // TYPE is the expected type of the range.
-  virtual irange fold_range (tree type, const irange &lh,
-			     const irange &rh) const;
+  virtual value_range_base fold_range (tree type,
+				       const value_range_base &lh,
+				       const value_range_base &rh) const;
 
   // Set the range for op? in the general case. LHS is the range for
   // the LHS of the expression, OP[12]is the range for the other
@@ -58,19 +64,29 @@ public:
   // Return TRUE if the operation is performed and a valid range is available.
   // ie   [LHS] = ??? + OP2
   // is re-formed as  R = [LHS] - OP2.
-  virtual bool op1_range (irange &r, tree type, const irange &lhs,
-			  const irange &op2) const;
-  virtual bool op2_range (irange &r, tree type, const irange &lhs,
-			  const irange &op1) const;
+  virtual bool op1_range (value_range_base &r, tree type,
+			  const value_range_base &lhs,
+			  const value_range_base &op2) const;
+  virtual bool op2_range (value_range_base &r, tree type,
+			  const value_range_base &lhs,
+			  const value_range_base &op1) const;
 protected:
   // Perform this operation on 2 sub ranges, return the result as a
   // range of TYPE.
-  virtual irange wi_fold (tree type, const wide_int &lh_lb, const wide_int &lh_ub,
-			  const wide_int &rh_lb, const wide_int &rh_ub) const;
+  virtual value_range_base wi_fold (tree type,
+				    const wide_int &lh_lb,
+				    const wide_int &lh_ub,
+				    const wide_int &rh_lb,
+				    const wide_int &rh_ub) const;
 };
 
 extern range_operator *range_op_handler(enum tree_code code, tree type);
 
-extern void range_cast (irange &, tree type);
+extern void range_cast (value_range_base &, tree type);
+
+#if USE_IRANGE
+#undef value_range_base
+#undef value_range_storage
+#endif
 
 #endif // GCC_RANGE_OP_H
diff --git a/gcc/selftest.h b/gcc/selftest.h
index 68e78b9..6f2c2af 100644
--- a/gcc/selftest.h
+++ b/gcc/selftest.h
@@ -260,7 +260,7 @@ extern int num_passes;
 } /* end of namespace selftest.  */
 
 /* This is outside of the selftest namespace because it's a friend of
-   class irange.  */
+   value_range_base.  */
 extern void range_tests ();
 
 /* Macros for writing tests.  */