#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
// 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 ())
{
}
// 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;
// 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;
}
// 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);
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;
// 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)
{
/* 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);
}
}
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);
}
}
[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)
{
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 };
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 ())
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;
}
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))
{
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);
}
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;
/* 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))
{
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);
}
/* (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);
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);
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));
}
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;
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))
{
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))
{
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;
}
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))
{
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))
{
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;
}
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))
{
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))
{
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;
}
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))
{
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))
{
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
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;
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
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;
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
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;
}
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
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;
}
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
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);
}
{
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;
};
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
/* 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),
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);
}
{
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
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
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);
}
// ----------------------------------------------------------------------------
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
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);
}
// ----------------------------------------------------------------------------
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;
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));
/* 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;
}
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);
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;
}
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;
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))
{
}
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);
}
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);
{
// 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);
}
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;
}
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))
{
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;
}
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);
}
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);
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);
}
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);
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;
}
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;
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;
}
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;
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);
}
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);
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;
}
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;
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,
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;
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;
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,
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))
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.
}
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);
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;
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;
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);
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);
}
// ---------------------------------------------------------------------------
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,
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);
}
// ---------------------------------------------------------------------------
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);
|| wide_int_range_zero_p (lh_lb, lh_ub, prec))
return range_zero (type);
- return irange (type);
+ return value_range_base (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);
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);
}
/* 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
#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))
#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 )
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);
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);
// (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);
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 ();
// 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.
// 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.
// 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);
}
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].
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);
}
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.
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);
}
// 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);
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
projects / thirdparty / gcc.git / commitdiff
