This does for num_pairs() what my previous patch did for VR_UNDEFINED
and VR_VARYING.
Note that VR_ANTI_RANGE for legacy is always set to 2 ranges. There
is only one way of representing a range, so a range that can be
represented as a VR_RANGE will never have a kind of VR_ANTI_RANGE.
Also legacy symbolics can also use VR_ANTI_RANGE, but no one will ever
ask for the bounds of such range, so m_num_ranges is irrelevant.
OK?
gcc/ChangeLog:
* value-range.cc (irange::legacy_num_pairs): Remove.
(irange::invert): Change gcc_assert to gcc_checking_assert.
* value-range.h (irange::num_pairs): Adjust for a cached
num_pairs(). Also, rename all gcc_assert's to
gcc_checking_assert's.
---
gcc/value-range.cc | 47 +++++++++-------------------------------------
gcc/value-range.h | 7 +++----
2 files changed, 12 insertions(+), 42 deletions(-)
diff --git a/gcc/value-range.cc b/gcc/value-range.cc
index 369eeabd7d5..6b0dfb439ba 100644
--- a/gcc/value-range.cc
+++ b/gcc/value-range.cc
@@ -369,63 +369,34 @@ irange::verify_range ()
{
if (m_kind == VR_UNDEFINED)
{
- gcc_assert (m_num_ranges == 0);
+ gcc_checking_assert (m_num_ranges == 0);
return;
}
- gcc_assert (m_num_ranges != 0);
-
if (m_kind == VR_VARYING)
{
- gcc_assert (m_num_ranges == 1);
- gcc_assert (irange_varying_p ());
+ gcc_checking_assert (m_num_ranges == 1);
+ gcc_checking_assert (irange_varying_p ());
return;
}
if (!legacy_mode_p ())
{
- gcc_assert (!irange_varying_p ());
+ gcc_checking_assert (m_num_ranges != 0);
+ gcc_checking_assert (!irange_varying_p ());
for (unsigned i = 0; i < m_num_ranges; ++i)
{
tree lb = tree_lower_bound (i);
tree ub = tree_upper_bound (i);
int c = compare_values (lb, ub);
- gcc_assert (c == 0 || c == -1);
+ gcc_checking_assert (c == 0 || c == -1);
}
return;
}
if (m_kind == VR_RANGE || m_kind == VR_ANTI_RANGE)
{
- gcc_assert (m_num_ranges == 1);
+ gcc_checking_assert (m_num_ranges == 1);
int cmp = compare_values (tree_lower_bound (0), tree_upper_bound (0));
- gcc_assert (cmp == 0 || cmp == -1 || cmp == -2);
- }
-}
-
-unsigned
-irange::legacy_num_pairs () const
-{
- gcc_checking_assert (legacy_mode_p ());
-
- if (undefined_p ())
- return 0;
- if (varying_p ())
- return 1;
- // Inlined symbolic_p for performance:
- if (!is_gimple_min_invariant (min ()) || !is_gimple_min_invariant (max ()))
- {
- value_range numeric_range (*this);
- numeric_range.normalize_symbolics ();
- return numeric_range.num_pairs ();
- }
- if (m_kind == VR_ANTI_RANGE)
- {
- // ~[MIN, X] has one sub-range of [X+1, MAX], and
- // ~[X, MAX] has one sub-range of [MIN, X-1].
- if (vrp_val_is_min (min ()) || vrp_val_is_max (max ()))
- return 1;
- return 2;
+ gcc_checking_assert (cmp == 0 || cmp == -1 || cmp == -2);
}
- gcc_checking_assert (m_num_ranges == 1);
- return 1;
}
// Return the lower bound for a sub-range. PAIR is the sub-range in
@@ -1810,7 +1781,7 @@ irange::invert ()
return;
}
- gcc_assert (!undefined_p () && !varying_p ());
+ gcc_checking_assert (!undefined_p () && !varying_p ());
// We always need one more set of bounds to represent an inverse, so
// if we're at the limit, we can't properly represent things.
diff --git a/gcc/value-range.h b/gcc/value-range.h
index bfba1a3469e..d2c3ce958d3 100644
--- a/gcc/value-range.h
+++ b/gcc/value-range.h
@@ -118,7 +118,6 @@ protected:
void legacy_union (irange *, const irange *);
void legacy_intersect (irange *, const irange *);
void verify_range ();
- unsigned legacy_num_pairs () const;
wide_int legacy_lower_bound (unsigned = 0) const;
wide_int legacy_upper_bound (unsigned) const;
int value_inside_range (tree) const;
@@ -207,10 +206,10 @@ irange::kind () const
inline unsigned
irange::num_pairs () const
{
- if (!legacy_mode_p ())
- return m_num_ranges;
+ if (m_kind == VR_ANTI_RANGE)
+ return constant_p () ? 2 : 1;
else
- return legacy_num_pairs ();
+ return m_num_ranges;
}
inline tree
--
2.30.2
