]>
git.ipfire.org Git - thirdparty/gcc.git/blob - gcc/value-range.cc
1 /* Support routines for value ranges.
2 Copyright (C) 2019-2023 Free Software Foundation, Inc.
3 Major hacks by Aldy Hernandez <aldyh@redhat.com> and
4 Andrew MacLeod <amacleod@redhat.com>.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
29 #include "tree-pretty-print.h"
30 #include "value-range-pretty-print.h"
31 #include "fold-const.h"
32 #include "gimple-range.h"
35 irange::accept (const vrange_visitor
&v
) const
41 unsupported_range::accept (const vrange_visitor
&v
) const
46 // Convenience function only available for integers and pointers.
49 Value_Range::lower_bound () const
51 if (is_a
<irange
> (*m_vrange
))
52 return as_a
<irange
> (*m_vrange
).lower_bound ();
56 // Convenience function only available for integers and pointers.
59 Value_Range::upper_bound () const
61 if (is_a
<irange
> (*m_vrange
))
62 return as_a
<irange
> (*m_vrange
).upper_bound ();
67 Value_Range::dump (FILE *out
) const
72 fprintf (out
, "NULL");
76 debug (const Value_Range
&r
)
79 fprintf (stderr
, "\n");
82 // Default vrange definitions.
85 vrange::contains_p (tree
) const
91 vrange::singleton_p (tree
*) const
97 vrange::set (tree min
, tree
, value_range_kind
)
99 set_varying (TREE_TYPE (min
));
103 vrange::type () const
105 return void_type_node
;
109 vrange::supports_type_p (const_tree
) const
115 vrange::set_undefined ()
117 m_kind
= VR_UNDEFINED
;
121 vrange::set_varying (tree
)
127 vrange::union_ (const vrange
&r
)
129 if (r
.undefined_p () || varying_p ())
131 if (undefined_p () || r
.varying_p ())
141 vrange::intersect (const vrange
&r
)
143 if (undefined_p () || r
.varying_p ())
145 if (r
.undefined_p ())
160 vrange::zero_p () const
166 vrange::nonzero_p () const
172 vrange::set_nonzero (tree type
)
178 vrange::set_zero (tree type
)
184 vrange::set_nonnegative (tree type
)
190 vrange::fits_p (const vrange
&) const
195 // Assignment operator for generic ranges. Copying incompatible types
199 vrange::operator= (const vrange
&src
)
201 if (is_a
<irange
> (src
))
202 as_a
<irange
> (*this) = as_a
<irange
> (src
);
203 else if (is_a
<frange
> (src
))
204 as_a
<frange
> (*this) = as_a
<frange
> (src
);
210 // Equality operator for generic ranges.
213 vrange::operator== (const vrange
&src
) const
215 if (is_a
<irange
> (src
))
216 return as_a
<irange
> (*this) == as_a
<irange
> (src
);
217 if (is_a
<frange
> (src
))
218 return as_a
<frange
> (*this) == as_a
<frange
> (src
);
222 // Wrapper for vrange_printer to dump a range to a file.
225 vrange::dump (FILE *file
) const
227 pretty_printer buffer
;
228 pp_needs_newline (&buffer
) = true;
229 buffer
.buffer
->stream
= file
;
230 vrange_printer
vrange_pp (&buffer
);
231 this->accept (vrange_pp
);
239 add_vrange (const vrange
&v
, inchash::hash
&hstate
,
242 if (v
.undefined_p ())
244 hstate
.add_int (VR_UNDEFINED
);
247 // Types are ignored throughout to inhibit two ranges being equal
248 // but having different hash values. This can happen when two
249 // ranges are equal and their types are different (but
250 // types_compatible_p is true).
251 if (is_a
<irange
> (v
))
253 const irange
&r
= as_a
<irange
> (v
);
255 hstate
.add_int (VR_VARYING
);
257 hstate
.add_int (VR_RANGE
);
258 for (unsigned i
= 0; i
< r
.num_pairs (); ++i
)
260 hstate
.add_wide_int (r
.lower_bound (i
));
261 hstate
.add_wide_int (r
.upper_bound (i
));
263 hstate
.add_wide_int (r
.get_nonzero_bits ());
266 if (is_a
<frange
> (v
))
268 const frange
&r
= as_a
<frange
> (v
);
270 hstate
.add_int (VR_VARYING
);
272 hstate
.add_int (VR_RANGE
);
274 hstate
.add_real_value (r
.lower_bound ());
275 hstate
.add_real_value (r
.upper_bound ());
277 nan_state nan
= r
.get_nan_state ();
278 hstate
.add_int (nan
.pos_p ());
279 hstate
.add_int (nan
.neg_p ());
285 } //namespace inchash
288 irange::supports_type_p (const_tree type
) const
290 return supports_p (type
);
293 // Return TRUE if R fits in THIS.
296 irange::fits_p (const vrange
&r
) const
298 return m_max_ranges
>= as_a
<irange
> (r
).num_pairs ();
302 irange::set_nonnegative (tree type
)
305 wi::zero (TYPE_PRECISION (type
)),
306 wi::to_wide (TYPE_MAX_VALUE (type
)));
310 frange::accept (const vrange_visitor
&v
) const
315 // Flush denormal endpoints to the appropriate 0.0.
318 frange::flush_denormals_to_zero ()
320 if (undefined_p () || known_isnan ())
323 machine_mode mode
= TYPE_MODE (type ());
324 // Flush [x, -DENORMAL] to [x, -0.0].
325 if (real_isdenormal (&m_max
, mode
) && real_isneg (&m_max
))
327 if (HONOR_SIGNED_ZEROS (m_type
))
332 // Flush [+DENORMAL, x] to [+0.0, x].
333 if (real_isdenormal (&m_min
, mode
) && !real_isneg (&m_min
))
337 // Setter for franges.
340 frange::set (tree type
,
341 const REAL_VALUE_TYPE
&min
, const REAL_VALUE_TYPE
&max
,
342 const nan_state
&nan
, value_range_kind kind
)
360 if (real_isnan (&min
) || real_isnan (&max
))
362 gcc_checking_assert (real_identical (&min
, &max
));
363 bool sign
= real_isneg (&min
);
364 set_nan (type
, sign
);
372 if (HONOR_NANS (m_type
))
374 m_pos_nan
= nan
.pos_p ();
375 m_neg_nan
= nan
.neg_p ();
383 if (!MODE_HAS_SIGNED_ZEROS (TYPE_MODE (m_type
)))
385 if (real_iszero (&m_min
, 1))
387 if (real_iszero (&m_max
, 1))
390 else if (!HONOR_SIGNED_ZEROS (m_type
))
392 if (real_iszero (&m_max
, 1))
394 if (real_iszero (&m_min
, 0))
398 // For -ffinite-math-only we can drop ranges outside the
399 // representable numbers to min/max for the type.
400 if (!HONOR_INFINITIES (m_type
))
402 REAL_VALUE_TYPE min_repr
= frange_val_min (m_type
);
403 REAL_VALUE_TYPE max_repr
= frange_val_max (m_type
);
404 if (real_less (&m_min
, &min_repr
))
406 else if (real_less (&max_repr
, &m_min
))
408 if (real_less (&max_repr
, &m_max
))
410 else if (real_less (&m_max
, &min_repr
))
414 // Check for swapped ranges.
415 gcc_checking_assert (real_compare (LE_EXPR
, &min
, &max
));
423 // Setter for an frange defaulting the NAN possibility to +-NAN when
427 frange::set (tree type
,
428 const REAL_VALUE_TYPE
&min
, const REAL_VALUE_TYPE
&max
,
429 value_range_kind kind
)
431 set (type
, min
, max
, nan_state (true), kind
);
435 frange::set (tree min
, tree max
, value_range_kind kind
)
437 set (TREE_TYPE (min
),
438 *TREE_REAL_CST_PTR (min
), *TREE_REAL_CST_PTR (max
), kind
);
441 // Normalize range to VARYING or UNDEFINED, or vice versa. Return
442 // TRUE if anything changed.
444 // A range with no known properties can be dropped to VARYING.
445 // Similarly, a VARYING with any properties should be dropped to a
446 // VR_RANGE. Normalizing ranges upon changing them ensures there is
447 // only one representation for a given range.
450 frange::normalize_kind ()
452 if (m_kind
== VR_RANGE
453 && frange_val_is_min (m_min
, m_type
)
454 && frange_val_is_max (m_max
, m_type
))
456 if (!HONOR_NANS (m_type
) || (m_pos_nan
&& m_neg_nan
))
458 set_varying (m_type
);
462 else if (m_kind
== VR_VARYING
)
464 if (HONOR_NANS (m_type
) && (!m_pos_nan
|| !m_neg_nan
))
467 m_min
= frange_val_min (m_type
);
468 m_max
= frange_val_max (m_type
);
472 else if (m_kind
== VR_NAN
&& !m_pos_nan
&& !m_neg_nan
)
477 // Union or intersect the zero endpoints of two ranges. For example:
478 // [-0, x] U [+0, x] => [-0, x]
479 // [ x, -0] U [ x, +0] => [ x, +0]
480 // [-0, x] ^ [+0, x] => [+0, x]
481 // [ x, -0] ^ [ x, +0] => [ x, -0]
483 // UNION_P is true when performing a union, or false when intersecting.
486 frange::combine_zeros (const frange
&r
, bool union_p
)
488 gcc_checking_assert (!undefined_p () && !known_isnan ());
490 bool changed
= false;
491 if (real_iszero (&m_min
) && real_iszero (&r
.m_min
)
492 && real_isneg (&m_min
) != real_isneg (&r
.m_min
))
494 m_min
.sign
= union_p
;
497 if (real_iszero (&m_max
) && real_iszero (&r
.m_max
)
498 && real_isneg (&m_max
) != real_isneg (&r
.m_max
))
500 m_max
.sign
= !union_p
;
503 // If the signs are swapped, the resulting range is empty.
504 if (m_min
.sign
== 0 && m_max
.sign
== 1)
515 // Union two ranges when one is known to be a NAN.
518 frange::union_nans (const frange
&r
)
520 gcc_checking_assert (known_isnan () || r
.known_isnan ());
528 m_pos_nan
|= r
.m_pos_nan
;
529 m_neg_nan
|= r
.m_neg_nan
;
537 frange::union_ (const vrange
&v
)
539 const frange
&r
= as_a
<frange
> (v
);
541 if (r
.undefined_p () || varying_p ())
543 if (undefined_p () || r
.varying_p ())
550 if (known_isnan () || r
.known_isnan ())
551 return union_nans (r
);
552 bool changed
= false;
553 if (m_pos_nan
!= r
.m_pos_nan
|| m_neg_nan
!= r
.m_neg_nan
)
555 m_pos_nan
|= r
.m_pos_nan
;
556 m_neg_nan
|= r
.m_neg_nan
;
560 // Combine endpoints.
561 if (real_less (&r
.m_min
, &m_min
))
566 if (real_less (&m_max
, &r
.m_max
))
572 if (HONOR_SIGNED_ZEROS (m_type
))
573 changed
|= combine_zeros (r
, true);
575 changed
|= normalize_kind ();
581 // Intersect two ranges when one is known to be a NAN.
584 frange::intersect_nans (const frange
&r
)
586 gcc_checking_assert (known_isnan () || r
.known_isnan ());
588 m_pos_nan
&= r
.m_pos_nan
;
589 m_neg_nan
&= r
.m_neg_nan
;
600 frange::intersect (const vrange
&v
)
602 const frange
&r
= as_a
<frange
> (v
);
604 if (undefined_p () || r
.varying_p ())
606 if (r
.undefined_p ())
618 if (known_isnan () || r
.known_isnan ())
619 return intersect_nans (r
);
620 bool changed
= false;
621 if (m_pos_nan
!= r
.m_pos_nan
|| m_neg_nan
!= r
.m_neg_nan
)
623 m_pos_nan
&= r
.m_pos_nan
;
624 m_neg_nan
&= r
.m_neg_nan
;
628 // Combine endpoints.
629 if (real_less (&m_min
, &r
.m_min
))
634 if (real_less (&r
.m_max
, &m_max
))
639 // If the endpoints are swapped, the resulting range is empty.
640 if (real_less (&m_max
, &m_min
))
651 if (HONOR_SIGNED_ZEROS (m_type
))
652 changed
|= combine_zeros (r
, false);
654 changed
|= normalize_kind ();
661 frange::operator= (const frange
&src
)
667 m_pos_nan
= src
.m_pos_nan
;
668 m_neg_nan
= src
.m_neg_nan
;
676 frange::operator== (const frange
&src
) const
678 if (m_kind
== src
.m_kind
)
684 return types_compatible_p (m_type
, src
.m_type
);
686 bool nan1
= known_isnan ();
687 bool nan2
= src
.known_isnan ();
691 return (m_pos_nan
== src
.m_pos_nan
692 && m_neg_nan
== src
.m_neg_nan
);
696 return (real_identical (&m_min
, &src
.m_min
)
697 && real_identical (&m_max
, &src
.m_max
)
698 && m_pos_nan
== src
.m_pos_nan
699 && m_neg_nan
== src
.m_neg_nan
700 && types_compatible_p (m_type
, src
.m_type
));
705 // Return TRUE if range contains R.
708 frange::contains_p (const REAL_VALUE_TYPE
&r
) const
710 gcc_checking_assert (m_kind
!= VR_ANTI_RANGE
);
721 if (!m_pos_nan
&& !m_neg_nan
)
723 // Both +NAN and -NAN are present.
724 if (m_pos_nan
&& m_neg_nan
)
726 return m_neg_nan
== r
.sign
;
731 if (real_compare (GE_EXPR
, &r
, &m_min
) && real_compare (LE_EXPR
, &r
, &m_max
))
733 // Make sure the signs are equal for signed zeros.
734 if (HONOR_SIGNED_ZEROS (m_type
) && real_iszero (&r
))
735 return r
.sign
== m_min
.sign
|| r
.sign
== m_max
.sign
;
741 // If range is a singleton, place it in RESULT and return TRUE. If
742 // RESULT is NULL, just return TRUE.
744 // A NAN can never be a singleton.
747 frange::internal_singleton_p (REAL_VALUE_TYPE
*result
) const
749 if (m_kind
== VR_RANGE
&& real_identical (&m_min
, &m_max
))
751 // Return false for any singleton that may be a NAN.
752 if (HONOR_NANS (m_type
) && maybe_isnan ())
755 if (MODE_COMPOSITE_P (TYPE_MODE (m_type
)))
757 // For IBM long doubles, if the value is +-Inf or is exactly
758 // representable in double, the other double could be +0.0
759 // or -0.0. Since this means there is more than one way to
760 // represent a value, return false to avoid propagating it.
761 // See libgcc/config/rs6000/ibm-ldouble-format for details.
762 if (real_isinf (&m_min
))
765 real_convert (&r
, DFmode
, &m_min
);
766 if (real_identical (&r
, &m_min
))
778 frange::singleton_p (tree
*result
) const
780 if (internal_singleton_p ())
783 *result
= build_real (m_type
, m_min
);
790 frange::singleton_p (REAL_VALUE_TYPE
&r
) const
792 return internal_singleton_p (&r
);
796 frange::supports_type_p (const_tree type
) const
798 return supports_p (type
);
802 frange::verify_range ()
805 gcc_checking_assert (HONOR_NANS (m_type
) || !maybe_isnan ());
809 gcc_checking_assert (!m_type
);
812 gcc_checking_assert (m_type
);
813 gcc_checking_assert (frange_val_is_min (m_min
, m_type
));
814 gcc_checking_assert (frange_val_is_max (m_max
, m_type
));
815 if (HONOR_NANS (m_type
))
816 gcc_checking_assert (m_pos_nan
&& m_neg_nan
);
818 gcc_checking_assert (!m_pos_nan
&& !m_neg_nan
);
821 gcc_checking_assert (m_type
);
824 gcc_checking_assert (m_type
);
825 gcc_checking_assert (m_pos_nan
|| m_neg_nan
);
831 // NANs cannot appear in the endpoints of a range.
832 gcc_checking_assert (!real_isnan (&m_min
) && !real_isnan (&m_max
));
834 // Make sure we don't have swapped ranges.
835 gcc_checking_assert (!real_less (&m_max
, &m_min
));
837 // [ +0.0, -0.0 ] is nonsensical.
838 gcc_checking_assert (!(real_iszero (&m_min
, 0) && real_iszero (&m_max
, 1)));
840 // If all the properties are clear, we better not span the entire
841 // domain, because that would make us varying.
842 if (m_pos_nan
&& m_neg_nan
)
843 gcc_checking_assert (!frange_val_is_min (m_min
, m_type
)
844 || !frange_val_is_max (m_max
, m_type
));
847 // We can't do much with nonzeros yet.
849 frange::set_nonzero (tree type
)
854 // We can't do much with nonzeros yet.
856 frange::nonzero_p () const
861 // Set range to [+0.0, +0.0] if honoring signed zeros, or [0.0, 0.0]
865 frange::set_zero (tree type
)
867 if (HONOR_SIGNED_ZEROS (type
))
869 set (type
, dconstm0
, dconst0
);
873 set (type
, dconst0
, dconst0
);
876 // Return TRUE for any zero regardless of sign.
879 frange::zero_p () const
881 return (m_kind
== VR_RANGE
882 && real_iszero (&m_min
)
883 && real_iszero (&m_max
));
886 // Set the range to non-negative numbers, that is [+0.0, +INF].
888 // The NAN in the resulting range (if HONOR_NANS) has a varying sign
889 // as there are no guarantees in IEEE 754 wrt to the sign of a NAN,
890 // except for copy, abs, and copysign. It is the responsibility of
891 // the caller to set the NAN's sign if desired.
894 frange::set_nonnegative (tree type
)
896 set (type
, dconst0
, frange_val_max (type
));
899 // Here we copy between any two irange's.
902 irange::operator= (const irange
&src
)
905 unsigned lim
= src
.m_num_ranges
;
906 if (lim
> m_max_ranges
)
909 for (x
= 0; x
< lim
* 2; ++x
)
910 m_base
[x
] = src
.m_base
[x
];
912 // If the range didn't fit, the last range should cover the rest.
913 if (lim
!= src
.m_num_ranges
)
914 m_base
[x
- 1] = src
.m_base
[src
.m_num_ranges
* 2 - 1];
919 m_nonzero_mask
= src
.m_nonzero_mask
;
920 if (m_max_ranges
== 1)
928 get_legacy_range (const irange
&r
, tree
&min
, tree
&max
)
930 if (r
.undefined_p ())
937 tree type
= r
.type ();
940 min
= wide_int_to_tree (type
, r
.lower_bound ());
941 max
= wide_int_to_tree (type
, r
.upper_bound ());
945 unsigned int precision
= TYPE_PRECISION (type
);
946 signop sign
= TYPE_SIGN (type
);
947 if (r
.num_pairs () > 1
949 && r
.lower_bound () == wi::min_value (precision
, sign
)
950 && r
.upper_bound () == wi::max_value (precision
, sign
))
952 int_range
<3> inv (r
);
954 min
= wide_int_to_tree (type
, inv
.lower_bound (0));
955 max
= wide_int_to_tree (type
, inv
.upper_bound (0));
956 return VR_ANTI_RANGE
;
959 min
= wide_int_to_tree (type
, r
.lower_bound ());
960 max
= wide_int_to_tree (type
, r
.upper_bound ());
964 /* Set value range to the canonical form of {VRTYPE, MIN, MAX, EQUIV}.
965 This means adjusting VRTYPE, MIN and MAX representing the case of a
966 wrapping range with MAX < MIN covering [MIN, type_max] U [type_min, MAX]
967 as anti-rage ~[MAX+1, MIN-1]. Likewise for wrapping anti-ranges.
968 In corner cases where MAX+1 or MIN-1 wraps this will fall back
970 This routine exists to ease canonicalization in the case where we
971 extract ranges from var + CST op limit. */
974 irange::set (tree type
, const wide_int
&min
, const wide_int
&max
,
975 value_range_kind kind
)
977 unsigned prec
= TYPE_PRECISION (type
);
978 signop sign
= TYPE_SIGN (type
);
979 wide_int min_value
= wi::min_value (prec
, sign
);
980 wide_int max_value
= wi::max_value (prec
, sign
);
983 m_nonzero_mask
= wi::minus_one (prec
);
985 if (kind
== VR_RANGE
)
990 if (min
== min_value
&& max
== max_value
)
997 gcc_checking_assert (kind
== VR_ANTI_RANGE
);
998 gcc_checking_assert (m_max_ranges
> 1);
1000 m_kind
= VR_UNDEFINED
;
1002 wi::overflow_type ovf
;
1005 lim
= wi::add (min
, -1, sign
, &ovf
);
1007 lim
= wi::sub (min
, 1, sign
, &ovf
);
1012 m_base
[0] = min_value
;
1017 lim
= wi::sub (max
, -1, sign
, &ovf
);
1019 lim
= wi::add (max
, 1, sign
, &ovf
);
1023 m_base
[m_num_ranges
* 2] = lim
;
1024 m_base
[m_num_ranges
* 2 + 1] = max_value
;
1034 irange::set (tree min
, tree max
, value_range_kind kind
)
1036 if (POLY_INT_CST_P (min
) || POLY_INT_CST_P (max
))
1038 set_varying (TREE_TYPE (min
));
1042 gcc_checking_assert (TREE_CODE (min
) == INTEGER_CST
);
1043 gcc_checking_assert (TREE_CODE (max
) == INTEGER_CST
);
1045 return set (TREE_TYPE (min
), wi::to_wide (min
), wi::to_wide (max
), kind
);
1048 // Check the validity of the range.
1051 irange::verify_range ()
1053 gcc_checking_assert (m_discriminator
== VR_IRANGE
);
1054 if (m_kind
== VR_UNDEFINED
)
1056 gcc_checking_assert (m_num_ranges
== 0);
1059 gcc_checking_assert (m_num_ranges
<= m_max_ranges
);
1061 // Legacy allowed these to represent VARYING for unknown types.
1062 // Leave this in for now, until all users are converted. Eventually
1063 // we should abort in set_varying.
1064 if (m_kind
== VR_VARYING
&& m_type
== error_mark_node
)
1067 unsigned prec
= TYPE_PRECISION (m_type
);
1068 if (m_kind
== VR_VARYING
)
1070 gcc_checking_assert (m_nonzero_mask
== -1);
1071 gcc_checking_assert (m_num_ranges
== 1);
1072 gcc_checking_assert (varying_compatible_p ());
1073 gcc_checking_assert (lower_bound ().get_precision () == prec
);
1074 gcc_checking_assert (upper_bound ().get_precision () == prec
);
1077 gcc_checking_assert (m_num_ranges
!= 0);
1078 gcc_checking_assert (!varying_compatible_p ());
1079 for (unsigned i
= 0; i
< m_num_ranges
; ++i
)
1081 wide_int lb
= lower_bound (i
);
1082 wide_int ub
= upper_bound (i
);
1083 gcc_checking_assert (lb
.get_precision () == prec
);
1084 gcc_checking_assert (ub
.get_precision () == prec
);
1085 int c
= wi::cmp (lb
, ub
, TYPE_SIGN (m_type
));
1086 gcc_checking_assert (c
== 0 || c
== -1);
1088 gcc_checking_assert (m_nonzero_mask
.get_precision () == prec
);
1092 irange::operator== (const irange
&other
) const
1094 if (m_num_ranges
!= other
.m_num_ranges
)
1097 if (m_num_ranges
== 0)
1100 signop sign1
= TYPE_SIGN (type ());
1101 signop sign2
= TYPE_SIGN (other
.type ());
1103 for (unsigned i
= 0; i
< m_num_ranges
; ++i
)
1105 widest_int lb
= widest_int::from (lower_bound (i
), sign1
);
1106 widest_int ub
= widest_int::from (upper_bound (i
), sign1
);
1107 widest_int lb_other
= widest_int::from (other
.lower_bound (i
), sign2
);
1108 widest_int ub_other
= widest_int::from (other
.upper_bound (i
), sign2
);
1109 if (lb
!= lb_other
|| ub
!= ub_other
)
1112 widest_int nz1
= widest_int::from (get_nonzero_bits (), sign1
);
1113 widest_int nz2
= widest_int::from (other
.get_nonzero_bits (), sign2
);
1117 /* If range is a singleton, place it in RESULT and return TRUE. */
1120 irange::singleton_p (tree
*result
) const
1122 if (num_pairs () == 1 && lower_bound () == upper_bound ())
1125 *result
= wide_int_to_tree (type (), lower_bound ());
1132 irange::singleton_p (wide_int
&w
) const
1134 if (num_pairs () == 1 && lower_bound () == upper_bound ())
1142 /* Return 1 if CST is inside value range.
1143 0 if CST is not inside value range.
1145 Benchmark compile/20001226-1.c compilation time after changing this
1149 irange::contains_p (const wide_int
&cst
) const
1154 // See if we can exclude CST based on the nonzero bits.
1155 if (m_nonzero_mask
!= -1
1157 && wi::bit_and (m_nonzero_mask
, cst
) == 0)
1160 signop sign
= TYPE_SIGN (type ());
1161 for (unsigned r
= 0; r
< m_num_ranges
; ++r
)
1163 if (wi::lt_p (cst
, lower_bound (r
), sign
))
1165 if (wi::le_p (cst
, upper_bound (r
), sign
))
1172 // Perform an efficient union with R when both ranges have only a single pair.
1173 // Excluded are VARYING and UNDEFINED ranges.
1176 irange::irange_single_pair_union (const irange
&r
)
1178 gcc_checking_assert (!undefined_p () && !varying_p ());
1179 gcc_checking_assert (!r
.undefined_p () && !varying_p ());
1181 signop sign
= TYPE_SIGN (m_type
);
1182 // Check if current lower bound is also the new lower bound.
1183 if (wi::le_p (m_base
[0], r
.m_base
[0], sign
))
1185 // If current upper bound is new upper bound, we're done.
1186 if (wi::le_p (r
.m_base
[1], m_base
[1], sign
))
1187 return union_nonzero_bits (r
);
1188 // Otherwise R has the new upper bound.
1189 // Check for overlap/touching ranges, or single target range.
1190 if (m_max_ranges
== 1
1191 || (widest_int::from (m_base
[1], sign
) + 1
1192 >= widest_int::from (r
.m_base
[0], TYPE_SIGN (r
.m_type
))))
1193 m_base
[1] = r
.m_base
[1];
1196 // This is a dual range result.
1197 m_base
[2] = r
.m_base
[0];
1198 m_base
[3] = r
.m_base
[1];
1201 union_nonzero_bits (r
);
1205 // Set the new lower bound to R's lower bound.
1206 wide_int lb
= m_base
[0];
1207 m_base
[0] = r
.m_base
[0];
1209 // If R fully contains THIS range, just set the upper bound.
1210 if (wi::ge_p (r
.m_base
[1], m_base
[1], sign
))
1211 m_base
[1] = r
.m_base
[1];
1212 // Check for overlapping ranges, or target limited to a single range.
1213 else if (m_max_ranges
== 1
1214 || (widest_int::from (r
.m_base
[1], TYPE_SIGN (r
.m_type
)) + 1
1215 >= widest_int::from (lb
, sign
)))
1219 // Left with 2 pairs.
1222 m_base
[3] = m_base
[1];
1223 m_base
[1] = r
.m_base
[1];
1225 union_nonzero_bits (r
);
1229 // Return TRUE if anything changes.
1232 irange::union_ (const vrange
&v
)
1234 const irange
&r
= as_a
<irange
> (v
);
1236 if (r
.undefined_p ())
1252 set_varying (type ());
1256 // Special case one range union one range.
1257 if (m_num_ranges
== 1 && r
.m_num_ranges
== 1)
1258 return irange_single_pair_union (r
);
1260 // If this ranges fully contains R, then we need do nothing.
1261 if (irange_contains_p (r
))
1262 return union_nonzero_bits (r
);
1264 // Do not worry about merging and such by reserving twice as many
1265 // pairs as needed, and then simply sort the 2 ranges into this
1266 // intermediate form.
1268 // The intermediate result will have the property that the beginning
1269 // of each range is <= the beginning of the next range. There may
1270 // be overlapping ranges at this point. I.e. this would be valid
1271 // [-20, 10], [-10, 0], [0, 20], [40, 90] as it satisfies this
1272 // constraint : -20 < -10 < 0 < 40. When the range is rebuilt into r,
1273 // the merge is performed.
1275 // [Xi,Yi]..[Xn,Yn] U [Xj,Yj]..[Xm,Ym] --> [Xk,Yk]..[Xp,Yp]
1276 auto_vec
<wide_int
, 20> res (m_num_ranges
* 2 + r
.m_num_ranges
* 2);
1277 unsigned i
= 0, j
= 0, k
= 0;
1278 signop sign
= TYPE_SIGN (m_type
);
1280 while (i
< m_num_ranges
* 2 && j
< r
.m_num_ranges
* 2)
1282 // lower of Xi and Xj is the lowest point.
1283 if (widest_int::from (m_base
[i
], sign
)
1284 <= widest_int::from (r
.m_base
[j
], sign
))
1286 res
.quick_push (m_base
[i
]);
1287 res
.quick_push (m_base
[i
+ 1]);
1293 res
.quick_push (r
.m_base
[j
]);
1294 res
.quick_push (r
.m_base
[j
+ 1]);
1299 for ( ; i
< m_num_ranges
* 2; i
+= 2)
1301 res
.quick_push (m_base
[i
]);
1302 res
.quick_push (m_base
[i
+ 1]);
1305 for ( ; j
< r
.m_num_ranges
* 2; j
+= 2)
1307 res
.quick_push (r
.m_base
[j
]);
1308 res
.quick_push (r
.m_base
[j
+ 1]);
1312 // Now normalize the vector removing any overlaps.
1314 for (j
= 2; j
< k
; j
+= 2)
1316 // Current upper+1 is >= lower bound next pair, then we merge ranges.
1317 if (widest_int::from (res
[i
- 1], sign
) + 1
1318 >= widest_int::from (res
[j
], sign
))
1320 // New upper bounds is greater of current or the next one.
1321 if (widest_int::from (res
[j
+ 1], sign
)
1322 > widest_int::from (res
[i
- 1], sign
))
1323 res
[i
- 1] = res
[j
+ 1];
1327 // This is a new distinct range, but no point in copying it
1328 // if it is already in the right place.
1332 res
[i
++] = res
[j
+ 1];
1339 // At this point, the vector should have i ranges, none overlapping.
1340 // Now it simply needs to be copied, and if there are too many
1341 // ranges, merge some. We wont do any analysis as to what the
1342 // "best" merges are, simply combine the final ranges into one.
1343 if (i
> m_max_ranges
* 2)
1345 res
[m_max_ranges
* 2 - 1] = res
[i
- 1];
1346 i
= m_max_ranges
* 2;
1349 for (j
= 0; j
< i
; j
++)
1350 m_base
[j
] = res
[j
];
1351 m_num_ranges
= i
/ 2;
1354 union_nonzero_bits (r
);
1358 // Return TRUE if THIS fully contains R. No undefined or varying cases.
1361 irange::irange_contains_p (const irange
&r
) const
1363 gcc_checking_assert (!undefined_p () && !varying_p ());
1364 gcc_checking_assert (!r
.undefined_p () && !varying_p ());
1366 // In order for THIS to fully contain R, all of the pairs within R must
1367 // be fully contained by the pairs in this object.
1368 signop sign
= TYPE_SIGN (m_type
);
1371 wide_int rl
= r
.m_base
[0];
1372 wide_int ru
= r
.m_base
[1];
1373 wide_int l
= m_base
[0];
1374 wide_int u
= m_base
[1];
1377 // If r is contained within this range, move to the next R
1378 if (wi::ge_p (rl
, l
, sign
)
1379 && wi::le_p (ru
, u
, sign
))
1381 // This pair is OK, Either done, or bump to the next.
1382 if (++ri
>= r
.num_pairs ())
1384 rl
= r
.m_base
[ri
* 2];
1385 ru
= r
.m_base
[ri
* 2 + 1];
1388 // Otherwise, check if this's pair occurs before R's.
1389 if (wi::lt_p (u
, rl
, sign
))
1391 // There's still at least one pair of R left.
1392 if (++i
>= num_pairs ())
1395 u
= m_base
[i
* 2 + 1];
1404 // Return TRUE if anything changes.
1407 irange::intersect (const vrange
&v
)
1409 const irange
&r
= as_a
<irange
> (v
);
1410 gcc_checking_assert (undefined_p () || r
.undefined_p ()
1411 || range_compatible_p (type (), r
.type ()));
1415 if (r
.undefined_p ())
1428 if (r
.num_pairs () == 1)
1430 bool res
= intersect (r
.lower_bound (), r
.upper_bound ());
1434 res
|= intersect_nonzero_bits (r
);
1438 // If R fully contains this, then intersection will change nothing.
1439 if (r
.irange_contains_p (*this))
1440 return intersect_nonzero_bits (r
);
1442 signop sign
= TYPE_SIGN (m_type
);
1443 unsigned bld_pair
= 0;
1444 unsigned bld_lim
= m_max_ranges
;
1445 int_range_max
r2 (*this);
1446 unsigned r2_lim
= r2
.num_pairs ();
1448 for (unsigned i
= 0; i
< r
.num_pairs (); )
1450 // If r1's upper is < r2's lower, we can skip r1's pair.
1451 wide_int ru
= r
.m_base
[i
* 2 + 1];
1452 wide_int r2l
= r2
.m_base
[i2
* 2];
1453 if (wi::lt_p (ru
, r2l
, sign
))
1458 // Likewise, skip r2's pair if its excluded.
1459 wide_int r2u
= r2
.m_base
[i2
* 2 + 1];
1460 wide_int rl
= r
.m_base
[i
* 2];
1461 if (wi::lt_p (r2u
, rl
, sign
))
1466 // No more r2, break.
1470 // Must be some overlap. Find the highest of the lower bounds,
1471 // and set it, unless the build limits lower bounds is already
1473 if (bld_pair
< bld_lim
)
1475 if (wi::ge_p (rl
, r2l
, sign
))
1476 m_base
[bld_pair
* 2] = rl
;
1478 m_base
[bld_pair
* 2] = r2l
;
1481 // Decrease and set a new upper.
1484 // ...and choose the lower of the upper bounds.
1485 if (wi::le_p (ru
, r2u
, sign
))
1487 m_base
[bld_pair
* 2 + 1] = ru
;
1489 // Move past the r1 pair and keep trying.
1495 m_base
[bld_pair
* 2 + 1] = r2u
;
1500 // No more r2, break.
1503 // r2 has the higher lower bound.
1506 // At the exit of this loop, it is one of 2 things:
1507 // ran out of r1, or r2, but either means we are done.
1508 m_num_ranges
= bld_pair
;
1509 if (m_num_ranges
== 0)
1516 intersect_nonzero_bits (r
);
1521 // Multirange intersect for a specified wide_int [lb, ub] range.
1522 // Return TRUE if intersect changed anything.
1524 // NOTE: It is the caller's responsibility to intersect the nonzero masks.
1527 irange::intersect (const wide_int
& lb
, const wide_int
& ub
)
1529 // Undefined remains undefined.
1533 tree range_type
= type();
1534 signop sign
= TYPE_SIGN (range_type
);
1536 gcc_checking_assert (TYPE_PRECISION (range_type
) == wi::get_precision (lb
));
1537 gcc_checking_assert (TYPE_PRECISION (range_type
) == wi::get_precision (ub
));
1539 // If this range is fully contained, then intersection will do nothing.
1540 if (wi::ge_p (lower_bound (), lb
, sign
)
1541 && wi::le_p (upper_bound (), ub
, sign
))
1544 unsigned bld_index
= 0;
1545 unsigned pair_lim
= num_pairs ();
1546 for (unsigned i
= 0; i
< pair_lim
; i
++)
1548 wide_int pairl
= m_base
[i
* 2];
1549 wide_int pairu
= m_base
[i
* 2 + 1];
1550 // Once UB is less than a pairs lower bound, we're done.
1551 if (wi::lt_p (ub
, pairl
, sign
))
1553 // if LB is greater than this pairs upper, this pair is excluded.
1554 if (wi::lt_p (pairu
, lb
, sign
))
1557 // Must be some overlap. Find the highest of the lower bounds,
1559 if (wi::gt_p (lb
, pairl
, sign
))
1560 m_base
[bld_index
* 2] = lb
;
1562 m_base
[bld_index
* 2] = pairl
;
1564 // ...and choose the lower of the upper bounds and if the base pair
1565 // has the lower upper bound, need to check next pair too.
1566 if (wi::lt_p (ub
, pairu
, sign
))
1568 m_base
[bld_index
++ * 2 + 1] = ub
;
1572 m_base
[bld_index
++ * 2 + 1] = pairu
;
1575 m_num_ranges
= bld_index
;
1576 if (m_num_ranges
== 0)
1583 // No need to call normalize_kind(), as the caller will do this
1584 // while intersecting the nonzero mask.
1591 // Signed 1-bits are strange. You can't subtract 1, because you can't
1592 // represent the number 1. This works around that for the invert routine.
1594 static wide_int
inline
1595 subtract_one (const wide_int
&x
, tree type
, wi::overflow_type
&overflow
)
1597 if (TYPE_SIGN (type
) == SIGNED
)
1598 return wi::add (x
, -1, SIGNED
, &overflow
);
1600 return wi::sub (x
, 1, UNSIGNED
, &overflow
);
1603 // The analogous function for adding 1.
1605 static wide_int
inline
1606 add_one (const wide_int
&x
, tree type
, wi::overflow_type
&overflow
)
1608 if (TYPE_SIGN (type
) == SIGNED
)
1609 return wi::sub (x
, -1, SIGNED
, &overflow
);
1611 return wi::add (x
, 1, UNSIGNED
, &overflow
);
1614 // Return the inverse of a range.
1619 gcc_checking_assert (!undefined_p () && !varying_p ());
1621 // We always need one more set of bounds to represent an inverse, so
1622 // if we're at the limit, we can't properly represent things.
1624 // For instance, to represent the inverse of a 2 sub-range set
1625 // [5, 10][20, 30], we would need a 3 sub-range set
1626 // [-MIN, 4][11, 19][31, MAX].
1628 // In this case, return the most conservative thing.
1630 // However, if any of the extremes of the range are -MIN/+MAX, we
1631 // know we will not need an extra bound. For example:
1633 // INVERT([-MIN,20][30,40]) => [21,29][41,+MAX]
1634 // INVERT([-MIN,20][30,MAX]) => [21,29]
1635 tree ttype
= type ();
1636 unsigned prec
= TYPE_PRECISION (ttype
);
1637 signop sign
= TYPE_SIGN (ttype
);
1638 wide_int type_min
= wi::min_value (prec
, sign
);
1639 wide_int type_max
= wi::max_value (prec
, sign
);
1640 m_nonzero_mask
= wi::minus_one (prec
);
1641 if (m_num_ranges
== m_max_ranges
1642 && lower_bound () != type_min
1643 && upper_bound () != type_max
)
1645 m_base
[1] = type_max
;
1649 // The algorithm is as follows. To calculate INVERT ([a,b][c,d]), we
1650 // generate [-MIN, a-1][b+1, c-1][d+1, MAX].
1652 // If there is an over/underflow in the calculation for any
1653 // sub-range, we eliminate that subrange. This allows us to easily
1654 // calculate INVERT([-MIN, 5]) with: [-MIN, -MIN-1][6, MAX]. And since
1655 // we eliminate the underflow, only [6, MAX] remains.
1657 wi::overflow_type ovf
;
1658 // Construct leftmost range.
1659 int_range_max
orig_range (*this);
1660 unsigned nitems
= 0;
1662 // If this is going to underflow on the MINUS 1, don't even bother
1663 // checking. This also handles subtracting one from an unsigned 0,
1664 // which doesn't set the underflow bit.
1665 if (type_min
!= orig_range
.lower_bound ())
1667 m_base
[nitems
++] = type_min
;
1668 tmp
= subtract_one (orig_range
.lower_bound (), ttype
, ovf
);
1669 m_base
[nitems
++] = tmp
;
1674 // Construct middle ranges if applicable.
1675 if (orig_range
.num_pairs () > 1)
1678 for (; j
< (orig_range
.num_pairs () * 2) - 1; j
+= 2)
1680 // The middle ranges cannot have MAX/MIN, so there's no need
1681 // to check for unsigned overflow on the +1 and -1 here.
1682 tmp
= wi::add (orig_range
.m_base
[j
], 1, sign
, &ovf
);
1683 m_base
[nitems
++] = tmp
;
1684 tmp
= subtract_one (orig_range
.m_base
[j
+ 1], ttype
, ovf
);
1685 m_base
[nitems
++] = tmp
;
1691 // Construct rightmost range.
1693 // However, if this will overflow on the PLUS 1, don't even bother.
1694 // This also handles adding one to an unsigned MAX, which doesn't
1695 // set the overflow bit.
1696 if (type_max
!= orig_range
.m_base
[i
])
1698 tmp
= add_one (orig_range
.m_base
[i
], ttype
, ovf
);
1699 m_base
[nitems
++] = tmp
;
1700 m_base
[nitems
++] = type_max
;
1704 m_num_ranges
= nitems
/ 2;
1706 // We disallow undefined or varying coming in, so the result can
1707 // only be a VR_RANGE.
1708 gcc_checking_assert (m_kind
== VR_RANGE
);
1714 // Return the nonzero bits inherent in the range.
1717 irange::get_nonzero_bits_from_range () const
1719 wide_int min
= lower_bound ();
1720 wide_int max
= upper_bound ();
1721 wide_int xorv
= min
^ max
;
1724 unsigned prec
= TYPE_PRECISION (type ());
1725 xorv
= wi::mask (prec
- wi::clz (xorv
), false, prec
);
1730 // If the the nonzero mask can be trivially converted to a range, do
1731 // so and return TRUE.
1734 irange::set_range_from_nonzero_bits ()
1736 gcc_checking_assert (!undefined_p ());
1737 if (m_nonzero_mask
== -1)
1739 unsigned popcount
= wi::popcount (m_nonzero_mask
);
1741 // If we have only one bit set in the mask, we can figure out the
1742 // range immediately.
1745 // Make sure we don't pessimize the range.
1746 if (!contains_p (m_nonzero_mask
))
1749 bool has_zero
= contains_zero_p (*this);
1750 wide_int nz
= m_nonzero_mask
;
1751 set (m_type
, nz
, nz
);
1752 m_nonzero_mask
= nz
;
1756 zero
.set_zero (type ());
1761 else if (popcount
== 0)
1770 irange::set_nonzero_bits (const wide_int
&bits
)
1772 gcc_checking_assert (!undefined_p ());
1774 // Drop VARYINGs with a nonzero mask to a plain range.
1775 if (m_kind
== VR_VARYING
&& bits
!= -1)
1778 m_nonzero_mask
= bits
;
1779 if (set_range_from_nonzero_bits ())
1787 // Return the nonzero bitmask. This will return the nonzero bits plus
1788 // the nonzero bits inherent in the range.
1791 irange::get_nonzero_bits () const
1793 gcc_checking_assert (!undefined_p ());
1794 // The nonzero mask inherent in the range is calculated on-demand.
1795 // For example, [0,255] does not have a 0xff nonzero mask by default
1796 // (unless manually set). This saves us considerable time, because
1797 // setting it at creation incurs a large penalty for irange::set.
1798 // At the time of writing there was a 5% slowdown in VRP if we kept
1799 // the mask precisely up to date at all times. Instead, we default
1800 // to -1 and set it when explicitly requested. However, this
1801 // function will always return the correct mask.
1802 if (m_nonzero_mask
== -1)
1803 return get_nonzero_bits_from_range ();
1805 return m_nonzero_mask
& get_nonzero_bits_from_range ();
1808 // Intersect the nonzero bits in R into THIS and normalize the range.
1809 // Return TRUE if the intersection changed anything.
1812 irange::intersect_nonzero_bits (const irange
&r
)
1814 gcc_checking_assert (!undefined_p () && !r
.undefined_p ());
1816 if (m_nonzero_mask
== -1 && r
.m_nonzero_mask
== -1)
1824 bool changed
= false;
1825 if (m_nonzero_mask
!= r
.m_nonzero_mask
)
1827 wide_int nz
= get_nonzero_bits () & r
.get_nonzero_bits ();
1828 // If the nonzero bits did not change, return false.
1829 if (nz
== get_nonzero_bits ())
1832 m_nonzero_mask
= nz
;
1833 if (set_range_from_nonzero_bits ())
1843 // Union the nonzero bits in R into THIS and normalize the range.
1844 // Return TRUE if the union changed anything.
1847 irange::union_nonzero_bits (const irange
&r
)
1849 gcc_checking_assert (!undefined_p () && !r
.undefined_p ());
1851 if (m_nonzero_mask
== -1 && r
.m_nonzero_mask
== -1)
1859 bool changed
= false;
1860 if (m_nonzero_mask
!= r
.m_nonzero_mask
)
1862 m_nonzero_mask
= get_nonzero_bits () | r
.get_nonzero_bits ();
1863 // No need to call set_range_from_nonzero_bits, because we'll
1864 // never narrow the range. Besides, it would cause endless
1865 // recursion because of the union_ in
1866 // set_range_from_nonzero_bits.
1876 dump_value_range (FILE *file
, const vrange
*vr
)
1882 debug (const vrange
*vr
)
1884 dump_value_range (stderr
, vr
);
1885 fprintf (stderr
, "\n");
1889 debug (const vrange
&vr
)
1895 debug (const value_range
*vr
)
1897 dump_value_range (stderr
, vr
);
1898 fprintf (stderr
, "\n");
1902 debug (const value_range
&vr
)
1904 dump_value_range (stderr
, &vr
);
1905 fprintf (stderr
, "\n");
1908 /* Return true, if VAL1 and VAL2 are equal values for VRP purposes. */
1911 vrp_operand_equal_p (const_tree val1
, const_tree val2
)
1915 if (!val1
|| !val2
|| !operand_equal_p (val1
, val2
, 0))
1921 gt_ggc_mx (irange
*x
)
1923 if (!x
->undefined_p ())
1924 gt_ggc_mx (x
->m_type
);
1928 gt_pch_nx (irange
*x
)
1930 if (!x
->undefined_p ())
1931 gt_pch_nx (x
->m_type
);
1935 gt_pch_nx (irange
*x
, gt_pointer_operator op
, void *cookie
)
1937 for (unsigned i
= 0; i
< x
->m_num_ranges
; ++i
)
1939 op (&x
->m_base
[i
* 2], NULL
, cookie
);
1940 op (&x
->m_base
[i
* 2 + 1], NULL
, cookie
);
1945 gt_ggc_mx (frange
*x
)
1947 gt_ggc_mx (x
->m_type
);
1951 gt_pch_nx (frange
*x
)
1953 gt_pch_nx (x
->m_type
);
1957 gt_pch_nx (frange
*x
, gt_pointer_operator op
, void *cookie
)
1959 op (&x
->m_type
, NULL
, cookie
);
1963 gt_ggc_mx (vrange
*x
)
1965 if (is_a
<irange
> (*x
))
1966 return gt_ggc_mx ((irange
*) x
);
1967 if (is_a
<frange
> (*x
))
1968 return gt_ggc_mx ((frange
*) x
);
1973 gt_pch_nx (vrange
*x
)
1975 if (is_a
<irange
> (*x
))
1976 return gt_pch_nx ((irange
*) x
);
1977 if (is_a
<frange
> (*x
))
1978 return gt_pch_nx ((frange
*) x
);
1983 gt_pch_nx (vrange
*x
, gt_pointer_operator op
, void *cookie
)
1985 if (is_a
<irange
> (*x
))
1986 gt_pch_nx ((irange
*) x
, op
, cookie
);
1987 else if (is_a
<frange
> (*x
))
1988 gt_pch_nx ((frange
*) x
, op
, cookie
);
1993 // ?? These stubs are for ipa-prop.cc which use a value_range in a
1994 // hash_traits. hash-traits.h defines an extern of gt_ggc_mx (T &)
1995 // instead of picking up the gt_ggc_mx (T *) version.
1997 gt_pch_nx (int_range
<2> *&x
)
1999 return gt_pch_nx ((irange
*) x
);
2003 gt_ggc_mx (int_range
<2> *&x
)
2005 return gt_ggc_mx ((irange
*) x
);
2008 #define DEFINE_INT_RANGE_INSTANCE(N) \
2009 template int_range<N>::int_range(tree_node *, \
2012 value_range_kind); \
2013 template int_range<N>::int_range(tree); \
2014 template int_range<N>::int_range(const irange &); \
2015 template int_range<N>::int_range(const int_range &); \
2016 template int_range<N>& int_range<N>::operator= (const int_range &);
2018 DEFINE_INT_RANGE_INSTANCE(1)
2019 DEFINE_INT_RANGE_INSTANCE(2)
2020 DEFINE_INT_RANGE_INSTANCE(3)
2021 DEFINE_INT_RANGE_INSTANCE(255)
2024 #include "selftest.h"
2026 #define INT(x) wi::shwi ((x), TYPE_PRECISION (integer_type_node))
2027 #define UINT(x) wi::uhwi ((x), TYPE_PRECISION (unsigned_type_node))
2028 #define SCHAR(x) wi::shwi ((x), TYPE_PRECISION (signed_char_type_node))
2034 range (tree type
, int a
, int b
, value_range_kind kind
= VR_RANGE
)
2037 if (TYPE_UNSIGNED (type
))
2039 w1
= wi::uhwi (a
, TYPE_PRECISION (type
));
2040 w2
= wi::uhwi (b
, TYPE_PRECISION (type
));
2044 w1
= wi::shwi (a
, TYPE_PRECISION (type
));
2045 w2
= wi::shwi (b
, TYPE_PRECISION (type
));
2047 return int_range
<2> (type
, w1
, w2
, kind
);
2051 range_int (int a
, int b
, value_range_kind kind
= VR_RANGE
)
2053 return range (integer_type_node
, a
, b
, kind
);
2057 range_uint (int a
, int b
, value_range_kind kind
= VR_RANGE
)
2059 return range (unsigned_type_node
, a
, b
, kind
);
2063 range_uint128 (int a
, int b
, value_range_kind kind
= VR_RANGE
)
2065 tree u128_type_node
= build_nonstandard_integer_type (128, 1);
2066 return range (u128_type_node
, a
, b
, kind
);
2070 range_uchar (int a
, int b
, value_range_kind kind
= VR_RANGE
)
2072 return range (unsigned_char_type_node
, a
, b
, kind
);
2076 range_char (int a
, int b
, value_range_kind kind
= VR_RANGE
)
2078 return range (signed_char_type_node
, a
, b
, kind
);
2082 build_range3 (int a
, int b
, int c
, int d
, int e
, int f
)
2084 int_range
<3> i1
= range_int (a
, b
);
2085 int_range
<3> i2
= range_int (c
, d
);
2086 int_range
<3> i3
= range_int (e
, f
);
2093 range_tests_irange3 ()
2095 int_range
<3> r0
, r1
, r2
;
2096 int_range
<3> i1
, i2
, i3
;
2098 // ([10,20] U [5,8]) U [1,3] ==> [1,3][5,8][10,20].
2099 r0
= range_int (10, 20);
2100 r1
= range_int (5, 8);
2102 r1
= range_int (1, 3);
2104 ASSERT_TRUE (r0
== build_range3 (1, 3, 5, 8, 10, 20));
2106 // [1,3][5,8][10,20] U [-5,0] => [-5,3][5,8][10,20].
2107 r1
= range_int (-5, 0);
2109 ASSERT_TRUE (r0
== build_range3 (-5, 3, 5, 8, 10, 20));
2111 // [10,20][30,40] U [50,60] ==> [10,20][30,40][50,60].
2112 r1
= range_int (50, 60);
2113 r0
= range_int (10, 20);
2114 r0
.union_ (range_int (30, 40));
2116 ASSERT_TRUE (r0
== build_range3 (10, 20, 30, 40, 50, 60));
2117 // [10,20][30,40][50,60] U [70, 80] ==> [10,20][30,40][50,60][70,80].
2118 r1
= range_int (70, 80);
2121 r2
= build_range3 (10, 20, 30, 40, 50, 60);
2122 r2
.union_ (range_int (70, 80));
2123 ASSERT_TRUE (r0
== r2
);
2125 // [10,20][30,40][50,60] U [6,35] => [6,40][50,60].
2126 r0
= build_range3 (10, 20, 30, 40, 50, 60);
2127 r1
= range_int (6, 35);
2129 r1
= range_int (6, 40);
2130 r1
.union_ (range_int (50, 60));
2131 ASSERT_TRUE (r0
== r1
);
2133 // [10,20][30,40][50,60] U [6,60] => [6,60].
2134 r0
= build_range3 (10, 20, 30, 40, 50, 60);
2135 r1
= range_int (6, 60);
2137 ASSERT_TRUE (r0
== range_int (6, 60));
2139 // [10,20][30,40][50,60] U [6,70] => [6,70].
2140 r0
= build_range3 (10, 20, 30, 40, 50, 60);
2141 r1
= range_int (6, 70);
2143 ASSERT_TRUE (r0
== range_int (6, 70));
2145 // [10,20][30,40][50,60] U [35,70] => [10,20][30,70].
2146 r0
= build_range3 (10, 20, 30, 40, 50, 60);
2147 r1
= range_int (35, 70);
2149 r1
= range_int (10, 20);
2150 r1
.union_ (range_int (30, 70));
2151 ASSERT_TRUE (r0
== r1
);
2153 // [10,20][30,40][50,60] U [15,35] => [10,40][50,60].
2154 r0
= build_range3 (10, 20, 30, 40, 50, 60);
2155 r1
= range_int (15, 35);
2157 r1
= range_int (10, 40);
2158 r1
.union_ (range_int (50, 60));
2159 ASSERT_TRUE (r0
== r1
);
2161 // [10,20][30,40][50,60] U [35,35] => [10,20][30,40][50,60].
2162 r0
= build_range3 (10, 20, 30, 40, 50, 60);
2163 r1
= range_int (35, 35);
2165 ASSERT_TRUE (r0
== build_range3 (10, 20, 30, 40, 50, 60));
2169 range_tests_int_range_max ()
2172 unsigned int nrange
;
2174 // Build a huge multi-range range.
2175 for (nrange
= 0; nrange
< 50; ++nrange
)
2177 int_range
<1> tmp
= range_int (nrange
*10, nrange
*10 + 5);
2180 ASSERT_TRUE (big
.num_pairs () == nrange
);
2182 // Verify that we can copy it without loosing precision.
2183 int_range_max
copy (big
);
2184 ASSERT_TRUE (copy
.num_pairs () == nrange
);
2186 // Inverting it should produce one more sub-range.
2188 ASSERT_TRUE (big
.num_pairs () == nrange
+ 1);
2190 int_range
<1> tmp
= range_int (5, 37);
2191 big
.intersect (tmp
);
2192 ASSERT_TRUE (big
.num_pairs () == 4);
2194 // Test that [10,10][20,20] does NOT contain 15.
2196 int_range_max i1
= range_int (10, 10);
2197 int_range_max i2
= range_int (20, 20);
2199 ASSERT_FALSE (i1
.contains_p (INT (15)));
2203 // Simulate -fstrict-enums where the domain of a type is less than the
2207 range_tests_strict_enum ()
2209 // The enum can only hold [0, 3].
2210 tree rtype
= copy_node (unsigned_type_node
);
2211 TYPE_MIN_VALUE (rtype
) = build_int_cstu (rtype
, 0);
2212 TYPE_MAX_VALUE (rtype
) = build_int_cstu (rtype
, 3);
2214 // Test that even though vr1 covers the strict enum domain ([0, 3]),
2215 // it does not cover the domain of the underlying type.
2216 int_range
<1> vr1
= range (rtype
, 0, 1);
2217 int_range
<1> vr2
= range (rtype
, 2, 3);
2219 ASSERT_TRUE (vr1
== range (rtype
, 0, 3));
2220 ASSERT_FALSE (vr1
.varying_p ());
2222 // Test that copying to a multi-range does not change things.
2223 int_range
<2> ir1 (vr1
);
2224 ASSERT_TRUE (ir1
== vr1
);
2225 ASSERT_FALSE (ir1
.varying_p ());
2227 // The same test as above, but using TYPE_{MIN,MAX}_VALUE instead of [0,3].
2228 vr1
= int_range
<2> (rtype
,
2229 wi::to_wide (TYPE_MIN_VALUE (rtype
)),
2230 wi::to_wide (TYPE_MAX_VALUE (rtype
)));
2232 ASSERT_TRUE (ir1
== vr1
);
2233 ASSERT_FALSE (ir1
.varying_p ());
2239 tree u128_type
= build_nonstandard_integer_type (128, /*unsigned=*/1);
2240 int_range
<2> i1
, i2
, i3
;
2241 int_range
<2> r0
, r1
, rold
;
2243 // Test 1-bit signed integer union.
2244 // [-1,-1] U [0,0] = VARYING.
2245 tree one_bit_type
= build_nonstandard_integer_type (1, 0);
2246 wide_int one_bit_min
= irange_val_min (one_bit_type
);
2247 wide_int one_bit_max
= irange_val_max (one_bit_type
);
2249 int_range
<2> min
= int_range
<2> (one_bit_type
, one_bit_min
, one_bit_min
);
2250 int_range
<2> max
= int_range
<2> (one_bit_type
, one_bit_max
, one_bit_max
);
2252 ASSERT_TRUE (max
.varying_p ());
2254 // Test that we can set a range of true+false for a 1-bit signed int.
2255 r0
= range_true_and_false (one_bit_type
);
2257 // Test inversion of 1-bit signed integers.
2259 int_range
<2> min
= int_range
<2> (one_bit_type
, one_bit_min
, one_bit_min
);
2260 int_range
<2> max
= int_range
<2> (one_bit_type
, one_bit_max
, one_bit_max
);
2264 ASSERT_TRUE (t
== max
);
2267 ASSERT_TRUE (t
== min
);
2270 // Test that NOT(255) is [0..254] in 8-bit land.
2271 int_range
<1> not_255
= range_uchar (255, 255, VR_ANTI_RANGE
);
2272 ASSERT_TRUE (not_255
== range_uchar (0, 254));
2274 // Test that NOT(0) is [1..255] in 8-bit land.
2275 int_range
<2> not_zero
= range_nonzero (unsigned_char_type_node
);
2276 ASSERT_TRUE (not_zero
== range_uchar (1, 255));
2278 // Check that [0,127][0x..ffffff80,0x..ffffff]
2279 // => ~[128, 0x..ffffff7f].
2280 r0
= range_uint128 (0, 127);
2281 wide_int high
= wi::minus_one (128);
2282 // low = -1 - 127 => 0x..ffffff80.
2283 wide_int low
= wi::sub (high
, wi::uhwi (127, 128));
2284 r1
= int_range
<1> (u128_type
, low
, high
); // [0x..ffffff80, 0x..ffffffff]
2285 // r0 = [0,127][0x..ffffff80,0x..fffffff].
2287 // r1 = [128, 0x..ffffff7f].
2288 r1
= int_range
<1> (u128_type
,
2289 wi::uhwi (128, 128),
2290 wi::sub (wi::minus_one (128), wi::uhwi (128, 128)));
2292 ASSERT_TRUE (r0
== r1
);
2294 r0
.set_varying (integer_type_node
);
2295 wide_int minint
= r0
.lower_bound ();
2296 wide_int maxint
= r0
.upper_bound ();
2298 r0
.set_varying (short_integer_type_node
);
2300 r0
.set_varying (unsigned_type_node
);
2301 wide_int maxuint
= r0
.upper_bound ();
2303 // Check that ~[0,5] => [6,MAX] for unsigned int.
2304 r0
= range_uint (0, 5);
2306 ASSERT_TRUE (r0
== int_range
<1> (unsigned_type_node
,
2307 wi::uhwi (6, TYPE_PRECISION (unsigned_type_node
)),
2310 // Check that ~[10,MAX] => [0,9] for unsigned int.
2311 r0
= int_range
<1> (unsigned_type_node
,
2312 wi::uhwi (10, TYPE_PRECISION (unsigned_type_node
)),
2315 ASSERT_TRUE (r0
== range_uint (0, 9));
2317 // Check that ~[0,5] => [6,MAX] for unsigned 128-bit numbers.
2318 r0
= range_uint128 (0, 5, VR_ANTI_RANGE
);
2319 r1
= int_range
<1> (u128_type
, wi::uhwi (6, 128), wi::minus_one (128));
2320 ASSERT_TRUE (r0
== r1
);
2322 // Check that [~5] is really [-MIN,4][6,MAX].
2323 r0
= range_int (5, 5, VR_ANTI_RANGE
);
2324 r1
= int_range
<1> (integer_type_node
, minint
, INT (4));
2325 r1
.union_ (int_range
<1> (integer_type_node
, INT (6), maxint
));
2326 ASSERT_FALSE (r1
.undefined_p ());
2327 ASSERT_TRUE (r0
== r1
);
2329 r1
= range_int (5, 5);
2330 int_range
<2> r2 (r1
);
2331 ASSERT_TRUE (r1
== r2
);
2333 r1
= range_int (5, 10);
2335 r1
= range_int (5, 10);
2336 ASSERT_TRUE (r1
.contains_p (INT (7)));
2338 r1
= range_char (0, 20);
2339 ASSERT_TRUE (r1
.contains_p (SCHAR(15)));
2340 ASSERT_FALSE (r1
.contains_p (SCHAR(300)));
2342 // NOT([10,20]) ==> [-MIN,9][21,MAX].
2343 r0
= r1
= range_int (10, 20);
2344 r2
= int_range
<1> (integer_type_node
, minint
, INT(9));
2345 r2
.union_ (int_range
<1> (integer_type_node
, INT(21), maxint
));
2346 ASSERT_FALSE (r2
.undefined_p ());
2348 ASSERT_TRUE (r1
== r2
);
2349 // Test that NOT(NOT(x)) == x.
2351 ASSERT_TRUE (r0
== r2
);
2353 // Test that booleans and their inverse work as expected.
2354 r0
= range_zero (boolean_type_node
);
2355 ASSERT_TRUE (r0
== range_false ());
2357 ASSERT_TRUE (r0
== range_true ());
2359 // Make sure NULL and non-NULL of pointer types work, and that
2360 // inverses of them are consistent.
2361 tree voidp
= build_pointer_type (void_type_node
);
2362 r0
= range_zero (voidp
);
2366 ASSERT_TRUE (r0
== r1
);
2368 // [10,20] U [15, 30] => [10, 30].
2369 r0
= range_int (10, 20);
2370 r1
= range_int (15, 30);
2372 ASSERT_TRUE (r0
== range_int (10, 30));
2374 // [15,40] U [] => [15,40].
2375 r0
= range_int (15, 40);
2376 r1
.set_undefined ();
2378 ASSERT_TRUE (r0
== range_int (15, 40));
2380 // [10,20] U [10,10] => [10,20].
2381 r0
= range_int (10, 20);
2382 r1
= range_int (10, 10);
2384 ASSERT_TRUE (r0
== range_int (10, 20));
2386 // [10,20] U [9,9] => [9,20].
2387 r0
= range_int (10, 20);
2388 r1
= range_int (9, 9);
2390 ASSERT_TRUE (r0
== range_int (9, 20));
2392 // [10,20] ^ [15,30] => [15,20].
2393 r0
= range_int (10, 20);
2394 r1
= range_int (15, 30);
2396 ASSERT_TRUE (r0
== range_int (15, 20));
2398 // Test the internal sanity of wide_int's wrt HWIs.
2399 ASSERT_TRUE (wi::max_value (TYPE_PRECISION (boolean_type_node
),
2400 TYPE_SIGN (boolean_type_node
))
2401 == wi::uhwi (1, TYPE_PRECISION (boolean_type_node
)));
2404 r0
= range_int (0, 0);
2405 ASSERT_TRUE (r0
.zero_p ());
2407 // Test nonzero_p().
2408 r0
= range_int (0, 0);
2410 ASSERT_TRUE (r0
.nonzero_p ());
2413 r0
= range_int (1, 1, VR_ANTI_RANGE
);
2415 r1
= range_int (3, 3, VR_ANTI_RANGE
);
2417 // vv = [0,0][2,2][4, MAX]
2418 int_range
<3> vv
= r0
;
2421 ASSERT_TRUE (vv
.contains_p (UINT (2)));
2422 ASSERT_TRUE (vv
.num_pairs () == 3);
2424 r0
= range_int (1, 1);
2425 // And union it with [0,0][2,2][4,MAX] multi range
2427 // The result should be [0,2][4,MAX], or ~[3,3] but it must contain 2
2428 ASSERT_TRUE (r0
.contains_p (INT (2)));
2432 range_tests_nonzero_bits ()
2434 int_range
<2> r0
, r1
;
2436 // Adding nonzero bits to a varying drops the varying.
2437 r0
.set_varying (integer_type_node
);
2438 r0
.set_nonzero_bits (INT (255));
2439 ASSERT_TRUE (!r0
.varying_p ());
2440 // Dropping the nonzero bits brings us back to varying.
2441 r0
.set_nonzero_bits (INT (-1));
2442 ASSERT_TRUE (r0
.varying_p ());
2444 // Test contains_p with nonzero bits.
2445 r0
.set_zero (integer_type_node
);
2446 ASSERT_TRUE (r0
.contains_p (INT (0)));
2447 ASSERT_FALSE (r0
.contains_p (INT (1)));
2448 r0
.set_nonzero_bits (INT (0xfe));
2449 ASSERT_FALSE (r0
.contains_p (INT (0x100)));
2450 ASSERT_FALSE (r0
.contains_p (INT (0x3)));
2452 // Union of nonzero bits.
2453 r0
.set_varying (integer_type_node
);
2454 r0
.set_nonzero_bits (INT (0xf0));
2455 r1
.set_varying (integer_type_node
);
2456 r1
.set_nonzero_bits (INT (0xf));
2458 ASSERT_TRUE (r0
.get_nonzero_bits () == 0xff);
2460 // Intersect of nonzero bits.
2461 r0
= range_int (0, 255);
2462 r0
.set_nonzero_bits (INT (0xfe));
2463 r1
.set_varying (integer_type_node
);
2464 r1
.set_nonzero_bits (INT (0xf0));
2466 ASSERT_TRUE (r0
.get_nonzero_bits () == 0xf0);
2468 // Intersect where the mask of nonzero bits is implicit from the range.
2469 r0
.set_varying (integer_type_node
);
2470 r1
= range_int (0, 255);
2472 ASSERT_TRUE (r0
.get_nonzero_bits () == 0xff);
2474 // The union of a mask of 0xff..ffff00 with a mask of 0xff spans the
2475 // entire domain, and makes the range a varying.
2476 r0
.set_varying (integer_type_node
);
2477 wide_int x
= wi::shwi (0xff, TYPE_PRECISION (integer_type_node
));
2478 x
= wi::bit_not (x
);
2479 r0
.set_nonzero_bits (x
); // 0xff..ff00
2480 r1
.set_varying (integer_type_node
);
2481 r1
.set_nonzero_bits (INT (0xff));
2483 ASSERT_TRUE (r0
.varying_p ());
2485 // Test that setting a nonzero bit of 1 does not pessimize the range.
2486 r0
.set_zero (integer_type_node
);
2487 r0
.set_nonzero_bits (INT (1));
2488 ASSERT_TRUE (r0
.zero_p ());
2491 // Build an frange from string endpoints.
2493 static inline frange
2494 frange_float (const char *lb
, const char *ub
, tree type
= float_type_node
)
2496 REAL_VALUE_TYPE min
, max
;
2497 gcc_assert (real_from_string (&min
, lb
) == 0);
2498 gcc_assert (real_from_string (&max
, ub
) == 0);
2499 return frange (type
, min
, max
);
2506 REAL_VALUE_TYPE q
, r
;
2509 // Equal ranges but with differing NAN bits are not equal.
2510 if (HONOR_NANS (float_type_node
))
2512 r1
= frange_float ("10", "12");
2520 // [10, 20] NAN ^ [30, 40] NAN = NAN.
2521 r0
= frange_float ("10", "20");
2522 r1
= frange_float ("30", "40");
2524 ASSERT_TRUE (r0
.known_isnan ());
2526 // [3,5] U [5,10] NAN = ... NAN
2527 r0
= frange_float ("3", "5");
2529 r1
= frange_float ("5", "10");
2531 ASSERT_TRUE (r0
.maybe_isnan ());
2534 // [5,6] U NAN = [5,6] NAN.
2535 r0
= frange_float ("5", "6");
2537 r1
.set_nan (float_type_node
);
2539 real_from_string (&q
, "5");
2540 real_from_string (&r
, "6");
2541 ASSERT_TRUE (real_identical (&q
, &r0
.lower_bound ()));
2542 ASSERT_TRUE (real_identical (&r
, &r0
.upper_bound ()));
2543 ASSERT_TRUE (r0
.maybe_isnan ());
2546 r0
.set_nan (float_type_node
);
2547 r1
.set_nan (float_type_node
);
2549 ASSERT_TRUE (r0
.known_isnan ());
2551 // [INF, INF] NAN ^ NAN = NAN
2552 r0
.set_nan (float_type_node
);
2553 r1
= frange_float ("+Inf", "+Inf");
2554 if (!HONOR_NANS (float_type_node
))
2557 ASSERT_TRUE (r0
.known_isnan ());
2560 r0
.set_nan (float_type_node
);
2561 r1
.set_nan (float_type_node
);
2563 ASSERT_TRUE (r0
.known_isnan ());
2565 // +NAN ^ -NAN = UNDEFINED
2566 r0
.set_nan (float_type_node
, false);
2567 r1
.set_nan (float_type_node
, true);
2569 ASSERT_TRUE (r0
.undefined_p ());
2571 // VARYING ^ NAN = NAN.
2572 r0
.set_nan (float_type_node
);
2573 r1
.set_varying (float_type_node
);
2575 ASSERT_TRUE (r0
.known_isnan ());
2577 // [3,4] ^ NAN = UNDEFINED.
2578 r0
= frange_float ("3", "4");
2580 r1
.set_nan (float_type_node
);
2582 ASSERT_TRUE (r0
.undefined_p ());
2584 // [-3, 5] ^ NAN = UNDEFINED
2585 r0
= frange_float ("-3", "5");
2587 r1
.set_nan (float_type_node
);
2589 ASSERT_TRUE (r0
.undefined_p ());
2591 // Setting the NAN bit to yes does not make us a known NAN.
2592 r0
.set_varying (float_type_node
);
2594 ASSERT_FALSE (r0
.known_isnan ());
2596 // NAN is in a VARYING.
2597 r0
.set_varying (float_type_node
);
2598 real_nan (&r
, "", 1, TYPE_MODE (float_type_node
));
2599 REAL_VALUE_TYPE nan
= r
;
2600 ASSERT_TRUE (r0
.contains_p (nan
));
2602 // -NAN is in a VARYING.
2603 r0
.set_varying (float_type_node
);
2604 q
= real_value_negate (&r
);
2605 REAL_VALUE_TYPE neg_nan
= q
;
2606 ASSERT_TRUE (r0
.contains_p (neg_nan
));
2608 // Clearing the NAN on a [] NAN is the empty set.
2609 r0
.set_nan (float_type_node
);
2611 ASSERT_TRUE (r0
.undefined_p ());
2613 // [10,20] NAN ^ [21,25] NAN = [NAN]
2614 r0
= frange_float ("10", "20");
2616 r1
= frange_float ("21", "25");
2619 ASSERT_TRUE (r0
.known_isnan ());
2621 // NAN U [5,6] should be [5,6] +-NAN.
2622 r0
.set_nan (float_type_node
);
2623 r1
= frange_float ("5", "6");
2626 real_from_string (&q
, "5");
2627 real_from_string (&r
, "6");
2628 ASSERT_TRUE (real_identical (&q
, &r0
.lower_bound ()));
2629 ASSERT_TRUE (real_identical (&r
, &r0
.upper_bound ()));
2630 ASSERT_TRUE (!r0
.signbit_p (signbit
));
2631 ASSERT_TRUE (r0
.maybe_isnan ());
2635 range_tests_signed_zeros ()
2637 REAL_VALUE_TYPE zero
= dconst0
;
2638 REAL_VALUE_TYPE neg_zero
= zero
;
2643 // [0,0] contains [0,0] but not [-0,-0] and vice versa.
2644 r0
= frange_float ("0.0", "0.0");
2645 r1
= frange_float ("-0.0", "-0.0");
2646 ASSERT_TRUE (r0
.contains_p (zero
));
2647 ASSERT_TRUE (!r0
.contains_p (neg_zero
));
2648 ASSERT_TRUE (r1
.contains_p (neg_zero
));
2649 ASSERT_TRUE (!r1
.contains_p (zero
));
2651 // Test contains_p() when we know the sign of the zero.
2652 r0
= frange_float ("0.0", "0.0");
2653 ASSERT_TRUE (r0
.contains_p (zero
));
2654 ASSERT_FALSE (r0
.contains_p (neg_zero
));
2655 r0
= frange_float ("-0.0", "-0.0");
2656 ASSERT_TRUE (r0
.contains_p (neg_zero
));
2657 ASSERT_FALSE (r0
.contains_p (zero
));
2659 r0
= frange_float ("-0.0", "0.0");
2660 ASSERT_TRUE (r0
.contains_p (neg_zero
));
2661 ASSERT_TRUE (r0
.contains_p (zero
));
2663 r0
= frange_float ("-3", "5");
2664 ASSERT_TRUE (r0
.contains_p (neg_zero
));
2665 ASSERT_TRUE (r0
.contains_p (zero
));
2667 // The intersection of zeros that differ in sign is a NAN (or
2668 // undefined if not honoring NANs).
2669 r0
= frange_float ("-0.0", "-0.0");
2670 r1
= frange_float ("0.0", "0.0");
2672 if (HONOR_NANS (float_type_node
))
2673 ASSERT_TRUE (r0
.known_isnan ());
2675 ASSERT_TRUE (r0
.undefined_p ());
2677 // The union of zeros that differ in sign is a zero with unknown sign.
2678 r0
= frange_float ("0.0", "0.0");
2679 r1
= frange_float ("-0.0", "-0.0");
2681 ASSERT_TRUE (r0
.zero_p () && !r0
.signbit_p (signbit
));
2683 // [-0, +0] has an unknown sign.
2684 r0
= frange_float ("-0.0", "0.0");
2685 ASSERT_TRUE (r0
.zero_p () && !r0
.signbit_p (signbit
));
2687 // [-0, +0] ^ [0, 0] is [0, 0]
2688 r0
= frange_float ("-0.0", "0.0");
2689 r1
= frange_float ("0.0", "0.0");
2691 ASSERT_TRUE (r0
.zero_p ());
2693 r0
= frange_float ("+0", "5");
2695 ASSERT_TRUE (r0
.signbit_p (signbit
) && !signbit
);
2697 r0
= frange_float ("-0", "5");
2699 ASSERT_TRUE (!r0
.signbit_p (signbit
));
2701 r0
= frange_float ("-0", "10");
2702 r1
= frange_float ("0", "5");
2704 ASSERT_TRUE (real_iszero (&r0
.lower_bound (), false));
2706 r0
= frange_float ("-0", "5");
2707 r1
= frange_float ("0", "5");
2709 ASSERT_TRUE (real_iszero (&r0
.lower_bound (), true));
2711 r0
= frange_float ("-5", "-0");
2713 r1
= frange_float ("0", "0");
2716 if (HONOR_NANS (float_type_node
))
2717 ASSERT_TRUE (r0
.known_isnan ());
2719 ASSERT_TRUE (r0
.undefined_p ());
2721 r0
.set_nonnegative (float_type_node
);
2722 if (HONOR_NANS (float_type_node
))
2723 ASSERT_TRUE (r0
.maybe_isnan ());
2725 // Numbers containing zero should have an unknown SIGNBIT.
2726 r0
= frange_float ("0", "10");
2728 ASSERT_TRUE (r0
.signbit_p (signbit
) && !signbit
);
2732 range_tests_signbit ()
2737 // Negative numbers should have the SIGNBIT set.
2738 r0
= frange_float ("-5", "-1");
2740 ASSERT_TRUE (r0
.signbit_p (signbit
) && signbit
);
2741 // Positive numbers should have the SIGNBIT clear.
2742 r0
= frange_float ("1", "10");
2744 ASSERT_TRUE (r0
.signbit_p (signbit
) && !signbit
);
2745 // Numbers spanning both positive and negative should have an
2747 r0
= frange_float ("-10", "10");
2749 ASSERT_TRUE (!r0
.signbit_p (signbit
));
2750 r0
.set_varying (float_type_node
);
2751 ASSERT_TRUE (!r0
.signbit_p (signbit
));
2755 range_tests_floats ()
2759 if (HONOR_NANS (float_type_node
))
2761 range_tests_signbit ();
2763 if (HONOR_SIGNED_ZEROS (float_type_node
))
2764 range_tests_signed_zeros ();
2766 // A range of [-INF,+INF] is actually VARYING if no other properties
2768 r0
= frange_float ("-Inf", "+Inf");
2769 ASSERT_TRUE (r0
.varying_p ());
2770 // ...unless it has some special property...
2771 if (HONOR_NANS (r0
.type ()))
2774 ASSERT_FALSE (r0
.varying_p ());
2777 // For most architectures, where float and double are different
2778 // sizes, having the same endpoints does not necessarily mean the
2779 // ranges are equal.
2780 if (!types_compatible_p (float_type_node
, double_type_node
))
2782 r0
= frange_float ("3.0", "3.0", float_type_node
);
2783 r1
= frange_float ("3.0", "3.0", double_type_node
);
2787 // [3,5] U [10,12] = [3,12].
2788 r0
= frange_float ("3", "5");
2789 r1
= frange_float ("10", "12");
2791 ASSERT_EQ (r0
, frange_float ("3", "12"));
2793 // [5,10] U [4,8] = [4,10]
2794 r0
= frange_float ("5", "10");
2795 r1
= frange_float ("4", "8");
2797 ASSERT_EQ (r0
, frange_float ("4", "10"));
2799 // [3,5] U [4,10] = [3,10]
2800 r0
= frange_float ("3", "5");
2801 r1
= frange_float ("4", "10");
2803 ASSERT_EQ (r0
, frange_float ("3", "10"));
2805 // [4,10] U [5,11] = [4,11]
2806 r0
= frange_float ("4", "10");
2807 r1
= frange_float ("5", "11");
2809 ASSERT_EQ (r0
, frange_float ("4", "11"));
2811 // [3,12] ^ [10,12] = [10,12].
2812 r0
= frange_float ("3", "12");
2813 r1
= frange_float ("10", "12");
2815 ASSERT_EQ (r0
, frange_float ("10", "12"));
2817 // [10,12] ^ [11,11] = [11,11]
2818 r0
= frange_float ("10", "12");
2819 r1
= frange_float ("11", "11");
2821 ASSERT_EQ (r0
, frange_float ("11", "11"));
2823 // [10,20] ^ [5,15] = [10,15]
2824 r0
= frange_float ("10", "20");
2825 r1
= frange_float ("5", "15");
2827 ASSERT_EQ (r0
, frange_float ("10", "15"));
2829 // [10,20] ^ [15,25] = [15,20]
2830 r0
= frange_float ("10", "20");
2831 r1
= frange_float ("15", "25");
2833 ASSERT_EQ (r0
, frange_float ("15", "20"));
2835 // [10,20] ^ [21,25] = []
2836 r0
= frange_float ("10", "20");
2838 r1
= frange_float ("21", "25");
2841 ASSERT_TRUE (r0
.undefined_p ());
2843 if (HONOR_INFINITIES (float_type_node
))
2845 // Make sure [-Inf, -Inf] doesn't get normalized.
2846 r0
= frange_float ("-Inf", "-Inf");
2847 ASSERT_TRUE (real_isinf (&r0
.lower_bound (), true));
2848 ASSERT_TRUE (real_isinf (&r0
.upper_bound (), true));
2851 // Test that reading back a global range yields the same result as
2852 // what we wrote into it.
2853 tree ssa
= make_temp_ssa_name (float_type_node
, NULL
, "blah");
2854 r0
.set_varying (float_type_node
);
2856 set_range_info (ssa
, r0
);
2857 get_global_range_query ()->range_of_expr (r1
, ssa
);
2861 // Run floating range tests for various combinations of NAN and INF
2865 range_tests_floats_various ()
2867 int save_finite_math_only
= flag_finite_math_only
;
2869 // Test -ffinite-math-only.
2870 flag_finite_math_only
= 1;
2871 range_tests_floats ();
2872 // Test -fno-finite-math-only.
2873 flag_finite_math_only
= 0;
2874 range_tests_floats ();
2876 flag_finite_math_only
= save_finite_math_only
;
2882 range_tests_irange3 ();
2883 range_tests_int_range_max ();
2884 range_tests_strict_enum ();
2885 range_tests_nonzero_bits ();
2886 range_tests_floats_various ();
2887 range_tests_misc ();
2890 } // namespace selftest
2892 #endif // CHECKING_P