The -fstrict-enums comment in the VR_ANTI_RANGE handling code is out
of date, as out-of-range ranges have already been handled by this
time. I've removed it.
Furthermore, optimizing ~[MIN,MAX] as VARYING instead of UNDEFINED is
an old idiom. I've been wanting to change it for a while, but have
only remembered late in the release cycle when it was too risky.
What I've chosen to do in this case is fall through to the code that
normalizes the range. This will correctly turn ~[MIN,MAX] into
UNDEFINED, yet leaving things alone in the case of -fstrict-enums
where [MIN,MAX] may not necessarily include the entire range of the
underlying precision. For example, if the domain of a strict enum is
[3,5] setting a VR_ANTI_RANGE of ~[3,5] should not cause neither
VR_UNDEFINED nor VR_VARYING, but just plain ~[3,5].
This is similar to what we do for -fstrict-enums when we set a range
of [3,5]. We leave it as a VR_RANGE, instead of upgrading it to
VR_VARYING.
Oh...I think it's time we started handling 1-bit anti-ranges uniformly,
hence the change to call irange_set_1bit_anti_range for both legacy and
multi-range.
Tested on x86-64 Linux.
OK?
gcc/ChangeLog:
* value-range.cc (irange::irange_set_1bit_anti_range): Add assert.
(irange::set): Call irange_set_1bit_anti_range for handling all
1-bit ranges. Fall through on ~[MIN,MAX].
---
gcc/value-range.cc | 26 ++++++++++----------------
1 file changed, 10 insertions(+), 16 deletions(-)
diff --git a/gcc/value-range.cc b/gcc/value-range.cc
index 467707b25ad..865344fcc3e 100644
--- a/gcc/value-range.cc
+++ b/gcc/value-range.cc
@@ -203,6 +203,8 @@ irange::irange_set_1bit_anti_range (tree min, tree max)
else
{
// The only alternative is [MIN,MAX], which is the empty range.
+ gcc_checking_assert (vrp_val_is_min (min));
+ gcc_checking_assert (vrp_val_is_max (max));
set_undefined ();
}
if (flag_checking)
@@ -313,29 +315,21 @@ irange::set (tree min, tree max, value_range_kind kind)
// Anti-ranges that can be represented as ranges should be so.
if (kind == VR_ANTI_RANGE)
{
- /* For -fstrict-enums we may receive out-of-range ranges so consider
- values < -INF and values > INF as -INF/INF as well. */
bool is_min = vrp_val_is_min (min);
bool is_max = vrp_val_is_max (max);
- tree type = TREE_TYPE (min);
if (is_min && is_max)
{
- /* We cannot deal with empty ranges, drop to varying.
- ??? This could be VR_UNDEFINED instead. */
- set_varying (type);
- return;
+ // Fall through. This will either be normalized as
+ // VR_UNDEFINED if the anti-range spans the entire
+ // precision, or it will remain an VR_ANTI_RANGE in the case
+ // of an -fstrict-enum where [MIN,MAX] is less than the span
+ // of underlying precision.
}
- else if (TYPE_PRECISION (TREE_TYPE (min)) == 1
- && (is_min || is_max))
+ else if (TYPE_PRECISION (TREE_TYPE (min)) == 1)
{
- /* Non-empty boolean ranges can always be represented
- as a singleton range. */
- if (is_min)
- min = max = vrp_val_max (TREE_TYPE (min));
- else
- min = max = vrp_val_min (TREE_TYPE (min));
- kind = VR_RANGE;
+ irange_set_1bit_anti_range (min, max);
+ return;
}
else if (is_min)
{
--
2.30.2
