return NULL_RTX;
wide_int min, max;
- value_range r;
+ int_range_max r;
get_global_range_query ()->range_of_expr (r, bound);
if (r.varying_p () || r.undefined_p ())
return NULL_RTX;
if (TREE_CODE (len) == SSA_NAME)
{
- value_range r;
+ int_range_max r;
tree tmin, tmax;
get_global_range_query ()->range_of_expr (r, len);
range_type = get_legacy_range (r, tmin, tmax);
/* a != MIN_RANGE<a> ? a : MIN_RANGE<a>+1 -> MAX_EXPR<MIN_RANGE<a>+1, a> */
if (cmp == NE_EXPR && TREE_CODE (exp0) == SSA_NAME)
{
- value_range r;
+ int_range_max r;
get_range_query (cfun)->range_of_expr (r, exp0);
if (r.undefined_p ())
r.set_varying (TREE_TYPE (exp0));
/* a != MAX_RANGE<a> ? a : MAX_RANGE<a>-1 -> MIN_EXPR<MIN_RANGE<a>-1, a> */
if (cmp == NE_EXPR && TREE_CODE (exp0) == SSA_NAME)
{
- value_range r;
+ int_range_max r;
get_range_query (cfun)->range_of_expr (r, exp0);
if (r.undefined_p ())
r.set_varying (TREE_TYPE (exp0));
check_out_of_bounds_and_warn (location_t location, tree ref,
tree low_sub_org, tree low_sub, tree up_sub,
tree up_bound, tree up_bound_p1,
- const value_range *vr,
+ const irange *vr,
bool ignore_off_by_one, bool for_array_bound,
bool *out_of_bound)
{
tree up_sub = low_sub_org;
tree low_sub = low_sub_org;
- value_range vr;
+ int_range_max vr;
if (TREE_CODE (low_sub_org) == SSA_NAME)
{
get_value_range (vr, low_sub_org, stmt);
can be stored in ssize_t, the signed counterpart of size_t. */
wide_int ssize_max = wi::lshift (wi::one (prec), prec - 1) - 1;
wide_int zero = wi::zero (TYPE_PRECISION (type));
- value_range valid_range (type, zero, ssize_max);
- value_range vr;
+ int_range_max valid_range (type, zero, ssize_max);
+ int_range_max vr;
get_range_query (cfun)->range_of_expr (vr, size);
if (vr.undefined_p ())
flag_var >= [min, max] -> flag_var > [min-1, max]
if no overflow/wrap. */
tree type = TREE_TYPE (cond_lhs);
- value_range r;
+ int_range_max r;
if (!INTEGRAL_TYPE_P (type)
|| !get_range_query (cfun)->range_of_expr (r, cond_rhs)
|| r.undefined_p ()
&& TYPE_PRECISION (argtype) <= TYPE_PRECISION (type))
{
/* Try to determine the range of values of the integer argument. */
- value_range vr;
+ int_range_max vr;
query->range_of_expr (vr, arg, stmt);
if (!vr.undefined_p () && !vr.varying_p ())
{
/* Try to determine the range of values of the integer argument
(range information is not available for pointers). */
- value_range vr;
+ int_range_max vr;
ptr_qry.rvals->range_of_expr (vr, arg, dir.info->callstmt);
if (!vr.varying_p () && !vr.undefined_p ())
wide_int min = wi::shwi (retval[0], prec);
wide_int max = wi::shwi (retval[1], prec);
- value_range r (TREE_TYPE (lhs), min, max);
+ int_range_max r (TREE_TYPE (lhs), min, max);
set_range_info (lhs, r);
setrange = true;
/* Try to determine the range of values of the argument
and use the greater of the two at level 1 and the smaller
of them at level 2. */
- value_range vr;
+ int_range_max vr;
ptr_qry.rvals->range_of_expr (vr, size, info.callstmt);
if (!vr.undefined_p ())
as signed. */
wide_int min, max;
value_range_kind rng = VR_VARYING;
- value_range vr;
+ int_range_max vr;
if (m_ptr_qry.rvals->range_of_expr (vr, offset, stmt))
{
tree vr_min, vr_max;
add_param_constraints (scop_p scop, graphite_dim_t p, tree parameter)
{
tree type = TREE_TYPE (parameter);
- value_range r;
+ int_range_max r;
wide_int min, max;
gcc_assert (INTEGRAL_TYPE_P (type) || POINTER_TYPE_P (type));
}
if (TREE_CODE (arg) != SSA_NAME)
return prec + (orig_sign != sign);
- value_range r;
+ int_range_max r;
while (!get_global_range_query ()->range_of_expr (r, arg)
|| r.varying_p ()
|| r.undefined_p ())
if (TYPE_OVERFLOW_UNDEFINED (type))
{
#if GIMPLE
- value_range vr0;
+ int_range_max vr0;
if (ovf1 == wi::OVF_NONE && ovf2 == wi::OVF_NONE
&& get_global_range_query ()->range_of_expr (vr0, @4)
&& !vr0.varying_p () && !vr0.undefined_p ())
if (TYPE_OVERFLOW_UNDEFINED (type))
{
#if GIMPLE
- value_range vr0;
+ int_range_max vr0;
if (ovf1 == wi::OVF_NONE && ovf2 == wi::OVF_NONE
&& get_global_range_query ()->range_of_expr (vr0, @0)
&& !vr0.varying_p () && !vr0.undefined_p ())
(if (TYPE_OVERFLOW_UNDEFINED (type) && !TYPE_OVERFLOW_SANITIZED (type))
@0
#if GIMPLE
- (with {value_range vr0, vr1;}
+ (with {int_range_max vr0, vr1;}
(if (INTEGRAL_TYPE_P (type)
&& get_range_query (cfun)->range_of_expr (vr0, @0)
&& get_range_query (cfun)->range_of_expr (vr1, @1)
&& wi::multiple_of_p (wi::to_widest (@1), wi::to_widest (@2), SIGNED))
(if (TYPE_OVERFLOW_UNDEFINED (type) && !TYPE_OVERFLOW_SANITIZED (type))
(mult @0 (div! @1 @2))
- (with {value_range vr0, vr1;}
+ (with {int_range_max vr0, vr1;}
(if (get_range_query (cfun)->range_of_expr (vr0, @0)
&& get_range_query (cfun)->range_of_expr (vr1, @1)
&& range_op_handler (MULT_EXPR).overflow_free_p (vr0, vr1))
(if (TYPE_OVERFLOW_UNDEFINED (type) && !TYPE_OVERFLOW_SANITIZED (type))
(div @1 @2)
#if GIMPLE
- (with {value_range vr0, vr1, vr2;}
+ (with {int_range_max vr0, vr1, vr2;}
(if (get_range_query (cfun)->range_of_expr (vr0, @0)
&& get_range_query (cfun)->range_of_expr (vr1, @1)
&& get_range_query (cfun)->range_of_expr (vr2, @2)
/* Simplify (X + M*N) / N -> X / N + M. */
(simplify
(div (plus:c@4 @0 (mult:c@3 @1 @2)) @2)
- (with {value_range vr0, vr1, vr2, vr3, vr4;}
+ (with {int_range_max vr0, vr1, vr2, vr3, vr4;}
(if (INTEGRAL_TYPE_P (type)
&& get_range_query (cfun)->range_of_expr (vr1, @1)
&& get_range_query (cfun)->range_of_expr (vr2, @2)
/* Simplify (X - M*N) / N -> X / N - M. */
(simplify
(div (minus@4 @0 (mult:c@3 @1 @2)) @2)
- (with {value_range vr0, vr1, vr2, vr3, vr4;}
+ (with {int_range_max vr0, vr1, vr2, vr3, vr4;}
(if (INTEGRAL_TYPE_P (type)
&& get_range_query (cfun)->range_of_expr (vr1, @1)
&& get_range_query (cfun)->range_of_expr (vr2, @2)
: wi::div_trunc (v, n, TYPE_SIGN (type)))
#define exact_mod(v) (shift ? wi::ctz (v) >= n.to_shwi () \
: wi::multiple_of_p (v, n, TYPE_SIGN (type)))
- value_range vr0, vr1, vr3;
+ int_range_max vr0, vr1, vr3;
}
(if (INTEGRAL_TYPE_P (type)
&& get_range_query (cfun)->range_of_expr (vr0, @0))
{ constant_boolean_node (cmp == NE_EXPR, type); })))
/* ((X inner_op C0) outer_op C1)
- With X being a tree where value_range has reasoned certain bits to always be
+ With X being a tree where range has reasoned certain bits to always be
zero throughout its computed value range,
inner_op = {|,^}, outer_op = {|,^} and inner_op != outer_op
where zero_mask has 1's for all bits that are sure to be 0 in
= wide_int::from (wi::to_wide (@1), TYPE_PRECISION (inner_type),
TYPE_SIGN (inner_type));
- value_range vr;
+ int_range_max vr;
if (get_global_range_query ()->range_of_expr (vr, @0)
&& !vr.varying_p () && !vr.undefined_p ())
{
&& (wi::to_widest (@2) + 1 == wi::to_widest (@3)
|| wi::to_widest (@2) == wi::to_widest (@3) + 1))
(with {
- value_range r;
+ int_range_max r;
get_range_query (cfun)->range_of_expr (r, @0);
if (r.undefined_p ())
r.set_varying (TREE_TYPE (@0));
if (integral)
{
- value_range vr;
+ int_range_max vr;
tree tmin, tmax;
query->range_of_expr (vr, exp, stmt);
return false;
// Build valid range and intersect it with the shift range.
- r = value_range (op.type (),
- wi::shwi (0, TYPE_PRECISION (op.type ())),
- wi::shwi (TYPE_PRECISION (type) - 1, TYPE_PRECISION (op.type ())));
+ r.set (op.type (),
+ wi::shwi (0, TYPE_PRECISION (op.type ())),
+ wi::shwi (TYPE_PRECISION (type) - 1, TYPE_PRECISION (op.type ())));
r.intersect (op);
// If there are no valid ranges in the shift range, returned false.
// (a % b) >= x && x > 0 , then a >= x.
if (wi::gt_p (lhs.lower_bound (), 0, sign))
{
- r = value_range (type, lhs.lower_bound (), wi::max_value (prec, sign));
+ r.set (type, lhs.lower_bound (), wi::max_value (prec, sign));
return true;
}
// (a % b) <= x && x < 0 , then a <= x.
if (wi::lt_p (lhs.upper_bound (), 0, sign))
{
- r = value_range (type, wi::min_value (prec, sign), lhs.upper_bound ());
+ r.set (type, wi::min_value (prec, sign), lhs.upper_bound ());
return true;
}
return false;
if (wi::gt_p (lhs.lower_bound (), 0, sign))
{
if (sign == SIGNED)
- r = value_range (type, wi::neg (lhs.lower_bound ()),
- lhs.lower_bound (), VR_ANTI_RANGE);
+ r.set (type, wi::neg (lhs.lower_bound ()),
+ lhs.lower_bound (), VR_ANTI_RANGE);
else if (wi::lt_p (lhs.lower_bound (), wi::max_value (prec, sign),
sign))
- r = value_range (type, lhs.lower_bound () + 1,
- wi::max_value (prec, sign));
+ r.set (type, lhs.lower_bound () + 1, wi::max_value (prec, sign));
else
return false;
return true;
if (wi::lt_p (lhs.upper_bound (), 0, sign))
{
if (wi::gt_p (lhs.upper_bound (), wi::min_value (prec, sign), sign))
- r = value_range (type, lhs.upper_bound (),
- wi::neg (lhs.upper_bound ()), VR_ANTI_RANGE);
+ r.set (type, lhs.upper_bound (),
+ wi::neg (lhs.upper_bound ()), VR_ANTI_RANGE);
else
return false;
return true;
#include "ssa.h"
#include "range.h"
-value_range
+int_range<2>
range_positives (tree type)
{
unsigned prec = TYPE_PRECISION (type);
signop sign = TYPE_SIGN (type);
- return value_range (type, wi::zero (prec), wi::max_value (prec, sign));
+ return int_range<2> (type, wi::zero (prec), wi::max_value (prec, sign));
}
-value_range
+int_range<2>
range_negatives (tree type)
{
unsigned prec = TYPE_PRECISION (type);
signop sign = TYPE_SIGN (type);
- value_range r;
+ int_range<2> r;
if (sign == UNSIGNED)
r.set_undefined ();
else
- r = value_range (type, wi::min_value (prec, sign), wi::minus_one (prec));
+ r.set (type, wi::min_value (prec, sign), wi::minus_one (prec));
return r;
}
#ifndef GCC_RANGE_H
#define GCC_RANGE_H
-value_range range_positives (tree type);
-value_range range_negatives (tree type);
+int_range<2> range_positives (tree type);
+int_range<2> range_negatives (tree type);
// Return an irange instance that is a boolean TRUE.
for below case:
(T1)(X *+- CST) -> (T1)X *+- (T1)CST
if X *+- CST doesn't overflow by range information. */
- value_range vr;
+ int_range_max vr;
if (TYPE_UNSIGNED (itype)
&& TYPE_OVERFLOW_WRAPS (itype)
&& TREE_CODE (op1) == INTEGER_CST
precision of A and B. */
static bool
-compute_distributive_range (tree type, value_range &op0_range,
- tree_code code, value_range &op1_range,
- tree *off, value_range *result_range)
+compute_distributive_range (tree type, irange &op0_range,
+ tree_code code, irange &op1_range,
+ tree *off, irange *result_range)
{
gcc_assert (INTEGRAL_TYPE_P (type) && !TYPE_OVERFLOW_TRAPS (type));
if (result_range)
but its range is more conducive to analysis. */
range_cast (op0_range, ssizetype);
range_cast (op1_range, ssizetype);
- value_range wide_range;
+ int_range_max wide_range;
range_op_handler op (code);
bool saved_flag_wrapv = flag_wrapv;
flag_wrapv = 1;
FROM_TYPE are integral types. */
static bool
-nop_conversion_for_offset_p (tree to_type, tree from_type, value_range &range)
+nop_conversion_for_offset_p (tree to_type, tree from_type, irange &range)
{
gcc_assert (INTEGRAL_TYPE_P (to_type)
&& INTEGRAL_TYPE_P (from_type)
static void
split_constant_offset (tree type, tree *var, tree *off,
- value_range *result_range,
+ irange *result_range,
hash_map<tree, std::pair<tree, tree> > &cache,
unsigned *limit);
static bool
split_constant_offset_1 (tree type, tree op0, enum tree_code code, tree op1,
- tree *var, tree *off, value_range *result_range,
+ tree *var, tree *off, irange *result_range,
hash_map<tree, std::pair<tree, tree> > &cache,
unsigned *limit)
{
tree var0, var1;
tree off0, off1;
- value_range op0_range, op1_range;
+ int_range_max op0_range, op1_range;
*var = NULL_TREE;
*off = NULL_TREE;
allowed to process before giving up. */
static void
-split_constant_offset (tree exp, tree *var, tree *off, value_range *exp_range,
+split_constant_offset (tree exp, tree *var, tree *off, irange *exp_range,
hash_map<tree, std::pair<tree, tree> > &cache,
unsigned *limit)
{
code = TREE_CODE (exp);
if (exp_range)
{
- *exp_range = type;
+ exp_range->set_varying (type);
if (code == SSA_NAME)
{
- value_range vr;
+ int_range_max vr;
get_range_query (cfun)->range_of_expr (vr, exp);
if (vr.undefined_p ())
vr.set_varying (TREE_TYPE (exp));
domain, instead of VR_VARYING. The new code normalizes
full-domain ranges to VR_VARYING. */
if (vr_kind == VR_RANGE || vr_kind == VR_VARYING)
- *exp_range = value_range (type, var_min, var_max);
+ exp_range->set (type, var_min, var_max);
}
}
*var = fold_convert (sizetype, *var);
*off = ssize_int (0);
- value_range r;
+ int_range_max r;
if (exp_range && code != SSA_NAME
&& get_range_query (cfun)->range_of_expr (r, exp)
&& !r.undefined_p ())
/* Get the range of values that the unconverted step actually has. */
wide_int step_min, step_max;
- value_range vr;
+ int_range_max vr;
if (TREE_CODE (step) != SSA_NAME
|| !get_range_query (cfun)->range_of_expr (vr, step)
|| vr.undefined_p ())
index. */
seen_variable_array_ref = true;
- value_range vr;
+ int_range_max vr;
range_query *query;
query = get_range_query (cfun);
widest_int nit;
wide_int base_min, base_max, step_min, step_max, type_min, type_max;
signop sgn = TYPE_SIGN (type);
- value_range r;
+ int_range_max r;
if (integer_zerop (step))
return false;
wide_int wm1 = wi::minus_one (TYPE_PRECISION (integer_type_node));
wide_int w2 = wi::two (TYPE_PRECISION (integer_type_node));
- value_range vr (TREE_TYPE (lhs), wm1, w2);
+ int_range<1> vr (TREE_TYPE (lhs), wm1, w2);
set_range_info (lhs, vr);
}
>= TYPE_PRECISION (TREE_TYPE (expr->u.nary->op[0])))
&& SSA_NAME_RANGE_INFO (expr->u.nary->op[0]))
{
- value_range r;
+ int_range_max r;
if (get_range_query (cfun)->range_of_expr (r, expr->u.nary->op[0])
&& !r.undefined_p ()
&& !r.varying_p ()
case, if we would need otherwise 2 or more comparisons, then use
the bit test; in the other cases, the threshold is 3 comparisons. */
bool entry_test_needed;
- value_range r;
+ int_range_max r;
if (TREE_CODE (exp) == SSA_NAME
&& get_range_query (cfun)->range_of_expr (r, exp)
&& !r.undefined_p ()
if (!rvals || TREE_CODE (si->nonzero_chars) != SSA_NAME)
return -1;
- value_range vr;
+ int_range_max vr;
if (!rvals->range_of_expr (vr, si->nonzero_chars, stmt)
|| vr.varying_p ()
|| vr.undefined_p ())
print_generic_expr (fp, si->nonzero_chars);
if (TREE_CODE (si->nonzero_chars) == SSA_NAME)
{
- value_range vr;
+ int_range_max vr;
if (rvals)
rvals->range_of_expr (vr, si->nonzero_chars,
si->stmt);
pdata->minlen = si->nonzero_chars;
else if (TREE_CODE (si->nonzero_chars) == SSA_NAME)
{
- value_range vr;
+ int_range_max vr;
ptr_qry->rvals->range_of_expr (vr, si->nonzero_chars, si->stmt);
if (vr.undefined_p () || vr.varying_p ())
pdata->minlen = build_zero_cst (size_type_node);
}
else if (pdata->minlen && TREE_CODE (pdata->minlen) == SSA_NAME)
{
- value_range vr;
+ int_range_max vr;
ptr_qry->rvals->range_of_expr (vr, si->nonzero_chars, stmt);
if (vr.varying_p () || vr.undefined_p ())
{
}
else if (TREE_CODE (bound) == SSA_NAME)
{
- value_range r;
+ int_range_max r;
get_range_query (cfun)->range_of_expr (r, bound);
if (!r.undefined_p ())
{
if (min == max)
return wide_int_to_tree (size_type_node, min);
- value_range vr (TREE_TYPE (lhs), min, max);
+ int_range_max vr (TREE_TYPE (lhs), min, max);
set_range_info (lhs, vr);
return lhs;
}
return false;
wide_int cntrange[2];
- value_range r;
+ int_range_max r;
if (!get_range_query (cfun)->range_of_expr (r, cnt)
|| r.varying_p ()
|| r.undefined_p ())
}
else if (TREE_CODE (si->nonzero_chars) == SSA_NAME)
{
- value_range r;
+ int_range_max r;
if (get_range_query (cfun)->range_of_expr (r, si->nonzero_chars)
&& !r.undefined_p ()
&& !r.varying_p ())
known to be unequal set the range of the result to non-zero.
This allows the call to be eliminated if its result is only
used in tests for equality to zero. */
- value_range nz;
+ int_range_max nz;
nz.set_nonzero (TREE_TYPE (lhs));
set_range_info (lhs, nz);
return false;
else if (si->nonzero_chars
&& TREE_CODE (si->nonzero_chars) == SSA_NAME)
{
- value_range vr;
+ int_range_max vr;
if (!ptr_qry.rvals->range_of_expr (vr, si->nonzero_chars, stmt)
|| vr.undefined_p ()
|| vr.varying_p ())
/* Reading a character before the final '\0'
character. Just set the value range to ~[0, 0]
if we don't have anything better. */
- value_range r;
+ int_range_max r;
if (!get_range_query (cfun)->range_of_expr (r, lhs)
|| r.varying_p ())
{
/* If every possible relative value of the index expression is a valid shift
amount, then we can merge the entry test in the bit test. */
bool entry_test_needed;
- value_range r;
+ int_range_max r;
if (TREE_CODE (index_expr) == SSA_NAME
&& get_range_query (cfun)->range_of_expr (r, index_expr)
&& !r.undefined_p ()
{
if (niters_no_overflow)
{
- value_range vr (type,
- wi::one (TYPE_PRECISION (type)),
- wi::rshift (wi::max_value (TYPE_PRECISION (type),
- TYPE_SIGN (type)),
- exact_log2 (const_vf),
- TYPE_SIGN (type)));
+ int_range<1> vr (type,
+ wi::one (TYPE_PRECISION (type)),
+ wi::rshift (wi::max_value (TYPE_PRECISION (type),
+ TYPE_SIGN (type)),
+ exact_log2 (const_vf),
+ TYPE_SIGN (type)));
set_range_info (niters_vector, vr);
}
/* For VF == 1 the vector IV might also overflow so we cannot
assert a minimum value of 1. */
else if (const_vf > 1)
{
- value_range vr (type,
- wi::one (TYPE_PRECISION (type)),
- wi::rshift (wi::max_value (TYPE_PRECISION (type),
- TYPE_SIGN (type))
- - (const_vf - 1),
- exact_log2 (const_vf), TYPE_SIGN (type))
- + 1);
+ int_range<1> vr (type,
+ wi::one (TYPE_PRECISION (type)),
+ wi::rshift (wi::max_value (TYPE_PRECISION (type),
+ TYPE_SIGN (type))
+ - (const_vf - 1),
+ exact_log2 (const_vf), TYPE_SIGN (type))
+ + 1);
set_range_info (niters_vector, vr);
}
}
least VF, so set range information for newly generated var. */
if (new_var_p)
{
- value_range vr (type,
- wi::to_wide (build_int_cst (type, lowest_vf)),
- wi::to_wide (TYPE_MAX_VALUE (type)));
+ int_range<1> vr (type,
+ wi::to_wide (build_int_cst (type, lowest_vf)),
+ wi::to_wide (TYPE_MAX_VALUE (type)));
set_range_info (niters, vr);
}
bool
vect_get_range_info (tree var, wide_int *min_value, wide_int *max_value)
{
- value_range vr;
+ int_range_max vr;
tree vr_min, vr_max;
get_range_query (cfun)->range_of_expr (vr, var);
if (vr.undefined_p ())
t3 = t2;
int msb = 1;
- value_range r;
+ int_range_max r;
get_range_query (cfun)->range_of_expr (r, oprnd0);
if (!r.varying_p () && !r.undefined_p ())
{
if (TREE_CODE (arg) != SSA_NAME)
return 3;
- value_range r;
+ int_range_max r;
while (!get_global_range_query ()->range_of_expr (r, arg)
|| r.undefined_p () || r.varying_p ())
{
debug (&vr);
}
-DEBUG_FUNCTION void
-debug (const value_range *vr)
-{
- dump_value_range (stderr, vr);
- fprintf (stderr, "\n");
-}
-
-DEBUG_FUNCTION void
-debug (const value_range &vr)
-{
- dump_value_range (stderr, &vr);
- fprintf (stderr, "\n");
-}
-
/* Return true, if VAL1 and VAL2 are equal values for VRP purposes. */
bool
virtual void visit (const unsupported_range &) const { }
};
-typedef int_range<2> value_range;
-
// This is an "infinite" precision range object for use in temporary
// calculations for any of the handled types. The object can be
// transparently used as a vrange.
/* ?? Errr, this should probably check for [0,0] and [1,1] as well
as [0,1]. */
- value_range vr;
+ int_range_max vr;
return (query->range_of_expr (vr, op, s)
&& vr == range_true_and_false (TREE_TYPE (op)));
}
enum tree_code subcode, tree type,
tree op0, tree op1, bool *ovf, gimple *s = NULL)
{
- value_range vr0, vr1;
+ int_range_max vr0, vr1;
if (!query->range_of_expr (vr0, op0, s) || vr0.undefined_p ())
vr0.set_varying (TREE_TYPE (op0));
if (!query->range_of_expr (vr1, op1, s) || vr1.undefined_p ())
}
else
{
- value_range vro, vri;
+ int_range_max vro, vri;
tree type = TREE_TYPE (op0);
if (code == GT_EXPR || code == GE_EXPR)
{
}
else
gcc_unreachable ();
- value_range vr0;
+ int_range_max vr0;
if (!query->range_of_expr (vr0, op0, stmt))
vr0.set_varying (TREE_TYPE (op0));
/* If vro, the range for OP0 to pass the overflow test, has
Returns true if the default label is not needed. */
static bool
-find_case_label_ranges (gswitch *stmt, const value_range *vr,
+find_case_label_ranges (gswitch *stmt, const irange *vr,
size_t *min_idx1, size_t *max_idx1,
size_t *min_idx2, size_t *max_idx2)
{
if (INTEGRAL_TYPE_P (TREE_TYPE (tem))
&& TYPE_PRECISION (TREE_TYPE (tem)) > 1)
{
- value_range vr (TREE_TYPE (tem),
- wi::zero (TYPE_PRECISION (TREE_TYPE (tem))),
- wi::one (TYPE_PRECISION (TREE_TYPE (tem))));
+ int_range<1> vr (TREE_TYPE (tem),
+ wi::zero (TYPE_PRECISION (TREE_TYPE (tem))),
+ wi::one (TYPE_PRECISION (TREE_TYPE (tem))));
set_range_info (tem, vr);
}
gimple_assign_set_rhs_with_ops (gsi, NOP_EXPR, tem);
tree op1 = gimple_assign_rhs2 (stmt);
tree op0min = NULL_TREE, op0max = NULL_TREE;
tree op1min = op1;
- value_range vr;
+ int_range_max vr;
if (TREE_CODE (op0) == INTEGER_CST)
{
if (rhs_code == TRUNC_MOD_EXPR
&& TREE_CODE (op1) == SSA_NAME)
{
- value_range vr1;
+ int_range_max vr1;
if (!query->range_of_expr (vr1, op1, stmt))
vr1.set_varying (TREE_TYPE (op1));
if (!vr1.varying_p () && !vr1.undefined_p ())
return false;
}
-/* value_range wrapper for wi_set_zero_nonzero_bits.
+/* irange wrapper for wi_set_zero_nonzero_bits.
Return TRUE if VR was a constant range and we were able to compute
the bit masks. */
tree op0 = gimple_assign_rhs1 (stmt);
tree op1 = gimple_assign_rhs2 (stmt);
tree op = NULL_TREE;
- value_range vr0, vr1;
+ int_range_max vr0, vr1;
wide_int may_be_nonzero0, may_be_nonzero1;
wide_int must_be_nonzero0, must_be_nonzero1;
wide_int mask;
static tree
test_for_singularity (enum tree_code cond_code, tree op0,
- tree op1, const value_range *vr)
+ tree op1, const irange *vr)
{
tree min = NULL;
tree max = NULL;
&& INTEGRAL_TYPE_P (TREE_TYPE (op0))
&& is_gimple_min_invariant (op1))
{
- value_range vr;
+ int_range_max vr;
if (!query->range_of_expr (vr, op0, stmt))
vr.set_undefined ();
&& !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (innerop)
&& desired_pro_or_demotion_p (TREE_TYPE (innerop), TREE_TYPE (op0)))
{
- value_range vr;
+ int_range_max vr;
if (query->range_of_expr (vr, innerop)
&& !vr.varying_p ()
simplify_using_ranges::simplify_switch_using_ranges (gswitch *stmt)
{
tree op = gimple_switch_index (stmt);
- value_range vr;
+ int_range_max vr;
bool take_default;
edge e;
edge_iterator ei;
/* Get the value-range of the inner operand. Use global ranges in
case innerop was created during substitute-and-fold. */
wide_int imin, imax;
- value_range vr;
+ int_range_max vr;
if (!INTEGRAL_TYPE_P (TREE_TYPE (innerop)))
return false;
get_range_query (cfun)->range_of_expr (vr, innerop, stmt);
gimple *stmt)
{
tree rhs1 = gimple_assign_rhs1 (stmt);
- value_range vr;
+ int_range_max vr;
scalar_float_mode fltmode
= SCALAR_FLOAT_TYPE_MODE (TREE_TYPE (gimple_assign_lhs (stmt)));
scalar_int_mode mode;
simplify_using_ranges::two_valued_val_range_p (tree var, tree *a, tree *b,
gimple *s)
{
- value_range vr;
+ int_range_max vr;
if (!query->range_of_expr (vr, var, s))
return false;
if (vr.varying_p () || vr.undefined_p ())
projects / thirdparty / gcc.git / commitdiff
