1 /* Support routines for value ranges.
2 Copyright (C) 2019-2023 Free Software Foundation, Inc.
3 Contributed 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/>. */
22 #ifndef GCC_VALUE_RANGE_H
23 #define GCC_VALUE_RANGE_H
27 // Types of value ranges.
32 /* Range spans the entire domain. */
34 /* Range is [MIN, MAX]. */
36 /* Range is ~[MIN, MAX]. */
40 /* Range is a nice guy. */
44 // Discriminator between different vrange types.
46 enum value_range_discriminator
48 // Range holds an integer or pointer.
50 // Floating point range.
52 // Range holds an unsupported type.
56 // Abstract class for ranges of any of the supported types.
58 // To query what types ranger and the entire ecosystem can support,
59 // use Value_Range::supports_type_p(tree type). This is a static
60 // method available independently of any vrange object.
62 // To query what a given vrange variant can support, use:
63 // irange::supports_p ()
64 // frange::supports_p ()
67 // To query what a range object can support, use:
68 // void foo (vrange &v, irange &i, frange &f)
70 // if (v.supports_type_p (type)) ...
71 // if (i.supports_type_p (type)) ...
72 // if (f.supports_type_p (type)) ...
75 class GTY((user
)) vrange
77 template <typename T
> friend bool is_a (vrange
&);
78 friend class Value_Range
;
79 friend void streamer_write_vrange (struct output_block
*, const vrange
&);
80 friend class range_op_handler
;
82 virtual void accept (const class vrange_visitor
&v
) const = 0;
83 virtual void set (tree
, tree
, value_range_kind
= VR_RANGE
);
84 virtual tree
type () const;
85 virtual bool supports_type_p (const_tree type
) const;
86 virtual void set_varying (tree type
);
87 virtual void set_undefined ();
88 virtual bool union_ (const vrange
&);
89 virtual bool intersect (const vrange
&);
90 virtual bool singleton_p (tree
*result
= NULL
) const;
91 virtual bool contains_p (tree cst
) const;
92 virtual bool zero_p () const;
93 virtual bool nonzero_p () const;
94 virtual void set_nonzero (tree type
);
95 virtual void set_zero (tree type
);
96 virtual void set_nonnegative (tree type
);
97 virtual bool fits_p (const vrange
&r
) const;
99 bool varying_p () const;
100 bool undefined_p () const;
101 vrange
& operator= (const vrange
&);
102 bool operator== (const vrange
&) const;
103 bool operator!= (const vrange
&r
) const { return !(*this == r
); }
104 void dump (FILE *) const;
106 vrange (enum value_range_discriminator d
) : m_discriminator (d
) { }
107 ENUM_BITFIELD(value_range_kind
) m_kind
: 8;
108 const ENUM_BITFIELD(value_range_discriminator
) m_discriminator
: 4;
113 extern void add_vrange (const vrange
&, hash
&, unsigned flags
= 0);
116 // A pair of values representing the known bits in a range. Zero bits
117 // in MASK cover constant values. Set bits in MASK cover unknown
118 // values. VALUE are the known bits.
120 // Set bits in MASK (no meaningful information) must have their
121 // corresponding bits in VALUE cleared, as this speeds up union and
127 irange_bitmask () { /* uninitialized */ }
128 irange_bitmask (unsigned prec
) { set_unknown (prec
); }
129 irange_bitmask (const wide_int
&value
, const wide_int
&mask
);
130 wide_int
value () const { return m_value
; }
131 wide_int
mask () const { return m_mask
; }
132 void set_unknown (unsigned prec
);
133 bool unknown_p () const;
134 unsigned get_precision () const;
135 bool union_ (const irange_bitmask
&src
);
136 bool intersect (const irange_bitmask
&src
);
137 bool operator== (const irange_bitmask
&src
) const;
138 bool operator!= (const irange_bitmask
&src
) const { return !(*this == src
); }
139 void verify_mask () const;
140 void dump (FILE *) const;
142 // Convenience functions for nonzero bitmask compatibility.
143 wide_int
get_nonzero_bits () const;
144 void set_nonzero_bits (const wide_int
&bits
);
151 irange_bitmask::set_unknown (unsigned prec
)
153 m_value
= wi::zero (prec
);
154 m_mask
= wi::minus_one (prec
);
159 // Return TRUE if THIS does not have any meaningful information.
162 irange_bitmask::unknown_p () const
168 irange_bitmask::irange_bitmask (const wide_int
&value
, const wide_int
&mask
)
177 irange_bitmask::get_precision () const
179 return m_mask
.get_precision ();
182 // The following two functions are meant for backwards compatability
183 // with the nonzero bitmask. A cleared bit means the value must be 0.
184 // A set bit means we have no information for the bit.
186 // Return the nonzero bits.
188 irange_bitmask::get_nonzero_bits () const
190 return m_value
| m_mask
;
193 // Set the bitmask to the nonzero bits in BITS.
195 irange_bitmask::set_nonzero_bits (const wide_int
&bits
)
197 m_value
= wi::zero (bits
.get_precision ());
204 irange_bitmask::operator== (const irange_bitmask
&src
) const
206 bool unknown1
= unknown_p ();
207 bool unknown2
= src
.unknown_p ();
208 if (unknown1
|| unknown2
)
209 return unknown1
== unknown2
;
210 return m_value
== src
.m_value
&& m_mask
== src
.m_mask
;
214 irange_bitmask::union_ (const irange_bitmask
&orig_src
)
217 irange_bitmask
src (orig_src
.m_value
& ~orig_src
.m_mask
, orig_src
.m_mask
);
220 irange_bitmask
save (*this);
221 m_mask
= (m_mask
| src
.m_mask
) | (m_value
^ src
.m_value
);
222 m_value
= m_value
& src
.m_value
;
225 return *this != save
;
229 irange_bitmask::intersect (const irange_bitmask
&orig_src
)
232 irange_bitmask
src (orig_src
.m_value
& ~orig_src
.m_mask
, orig_src
.m_mask
);
235 irange_bitmask
save (*this);
236 // If we have two known bits that are incompatible, the resulting
237 // bit is undefined. It is unclear whether we should set the entire
238 // range to UNDEFINED, or just a subset of it. For now, set the
239 // entire bitmask to unknown (VARYING).
240 if (wi::bit_and (~(m_mask
| src
.m_mask
),
241 m_value
^ src
.m_value
) != 0)
243 unsigned prec
= m_mask
.get_precision ();
244 m_mask
= wi::minus_one (prec
);
245 m_value
= wi::zero (prec
);
249 m_mask
= m_mask
& src
.m_mask
;
250 m_value
= m_value
| src
.m_value
;
254 return *this != save
;
257 // An integer range without any storage.
259 class GTY((user
)) irange
: public vrange
261 friend value_range_kind
get_legacy_range (const irange
&, tree
&, tree
&);
262 friend class irange_storage
;
263 friend class vrange_printer
;
266 void set (tree type
, const wide_int
&, const wide_int
&,
267 value_range_kind
= VR_RANGE
);
268 virtual void set_nonzero (tree type
) override
;
269 virtual void set_zero (tree type
) override
;
270 virtual void set_nonnegative (tree type
) override
;
271 virtual void set_varying (tree type
) override
;
272 virtual void set_undefined () override
;
275 static bool supports_p (const_tree type
);
276 virtual bool supports_type_p (const_tree type
) const override
;
277 virtual tree
type () const override
;
279 // Iteration over sub-ranges.
280 unsigned num_pairs () const;
281 wide_int
lower_bound (unsigned = 0) const;
282 wide_int
upper_bound (unsigned) const;
283 wide_int
upper_bound () const;
286 virtual bool zero_p () const override
;
287 virtual bool nonzero_p () const override
;
288 virtual bool singleton_p (tree
*result
= NULL
) const override
;
289 bool singleton_p (wide_int
&) const;
290 bool contains_p (const wide_int
&) const;
291 bool nonnegative_p () const;
292 bool nonpositive_p () const;
294 // In-place operators.
295 virtual bool union_ (const vrange
&) override
;
296 virtual bool intersect (const vrange
&) override
;
299 // Operator overloads.
300 irange
& operator= (const irange
&);
301 bool operator== (const irange
&) const;
302 bool operator!= (const irange
&r
) const { return !(*this == r
); }
305 virtual bool fits_p (const vrange
&r
) const override
;
306 virtual void accept (const vrange_visitor
&v
) const override
;
308 void update_bitmask (const irange_bitmask
&);
309 irange_bitmask
get_bitmask () const;
311 wide_int
get_nonzero_bits () const;
312 void set_nonzero_bits (const wide_int
&bits
);
315 void maybe_resize (int needed
);
316 virtual void set (tree
, tree
, value_range_kind
= VR_RANGE
) override
;
317 virtual bool contains_p (tree cst
) const override
;
318 irange (wide_int
*, unsigned nranges
, bool resizable
);
320 // In-place operators.
321 bool irange_contains_p (const irange
&) const;
322 bool irange_single_pair_union (const irange
&r
);
324 void normalize_kind ();
326 void verify_range ();
328 // Hard limit on max ranges allowed.
329 static const int HARD_MAX_RANGES
= 255;
331 friend void gt_ggc_mx (irange
*);
332 friend void gt_pch_nx (irange
*);
333 friend void gt_pch_nx (irange
*, gt_pointer_operator
, void *);
335 bool varying_compatible_p () const;
336 bool intersect_bitmask (const irange
&r
);
337 bool union_bitmask (const irange
&r
);
338 irange_bitmask
get_bitmask_from_range () const;
339 bool set_range_from_bitmask ();
341 bool intersect (const wide_int
& lb
, const wide_int
& ub
);
342 unsigned char m_num_ranges
;
344 unsigned char m_max_ranges
;
346 irange_bitmask m_bitmask
;
351 // Here we describe an irange with N pairs of ranges. The storage for
352 // the pairs is embedded in the class as an array.
354 // If RESIZABLE is true, the storage will be resized on the heap when
355 // the number of ranges needed goes past N up to a max of
356 // HARD_MAX_RANGES. This new storage is freed upon destruction.
358 template<unsigned N
, bool RESIZABLE
= false>
359 class GTY((user
)) int_range
: public irange
363 int_range (tree type
, const wide_int
&, const wide_int
&,
364 value_range_kind
= VR_RANGE
);
365 int_range (tree type
);
366 int_range (const int_range
&);
367 int_range (const irange
&);
368 virtual ~int_range ();
369 int_range
& operator= (const int_range
&);
371 int_range (tree
, tree
, value_range_kind
= VR_RANGE
);
373 wide_int m_ranges
[N
*2];
376 // Unsupported temporaries may be created by ranger before it's known
377 // they're unsupported, or by vr_values::get_value_range.
379 class unsupported_range
: public vrange
383 : vrange (VR_UNKNOWN
)
387 virtual void set_undefined () final override
389 m_kind
= VR_UNDEFINED
;
391 virtual void accept (const vrange_visitor
&v
) const override
;
394 // The NAN state as an opaque object.
400 nan_state (bool pos_nan
, bool neg_nan
);
408 // Set NAN state to +-NAN if NAN_P is true. Otherwise set NAN state
412 nan_state::nan_state (bool nan_p
)
418 // Constructor initializing the object to +NAN if POS_NAN is set, -NAN
419 // if NEG_NAN is set, or +-NAN if both are set. Otherwise POS_NAN and
420 // NEG_NAN are clear, and the object cannot be a NAN.
423 nan_state::nan_state (bool pos_nan
, bool neg_nan
)
429 // Return if +NAN is possible.
432 nan_state::pos_p () const
437 // Return if -NAN is possible.
440 nan_state::neg_p () const
445 // A floating point range.
447 // The representation is a type with a couple of endpoints, unioned
448 // with the set of { -NAN, +Nan }.
450 class GTY((user
)) frange
: public vrange
452 friend class frange_storage
;
453 friend class vrange_printer
;
454 friend void gt_ggc_mx (frange
*);
455 friend void gt_pch_nx (frange
*);
456 friend void gt_pch_nx (frange
*, gt_pointer_operator
, void *);
459 frange (const frange
&);
460 frange (tree
, tree
, value_range_kind
= VR_RANGE
);
462 frange (tree type
, const REAL_VALUE_TYPE
&min
, const REAL_VALUE_TYPE
&max
,
463 value_range_kind
= VR_RANGE
);
464 static bool supports_p (const_tree type
)
466 // ?? Decimal floats can have multiple representations for the
467 // same number. Supporting them may be as simple as just
468 // disabling them in singleton_p. No clue.
469 return SCALAR_FLOAT_TYPE_P (type
) && !DECIMAL_FLOAT_TYPE_P (type
);
471 virtual tree
type () const override
;
472 void set (tree type
, const REAL_VALUE_TYPE
&, const REAL_VALUE_TYPE
&,
473 value_range_kind
= VR_RANGE
);
474 void set (tree type
, const REAL_VALUE_TYPE
&, const REAL_VALUE_TYPE
&,
475 const nan_state
&, value_range_kind
= VR_RANGE
);
476 void set_nan (tree type
);
477 void set_nan (tree type
, bool sign
);
478 void set_nan (tree type
, const nan_state
&);
479 virtual void set_varying (tree type
) override
;
480 virtual void set_undefined () override
;
481 virtual bool union_ (const vrange
&) override
;
482 virtual bool intersect (const vrange
&) override
;
483 bool contains_p (const REAL_VALUE_TYPE
&) const;
484 virtual bool singleton_p (tree
*result
= NULL
) const override
;
485 bool singleton_p (REAL_VALUE_TYPE
&r
) const;
486 virtual bool supports_type_p (const_tree type
) const override
;
487 virtual void accept (const vrange_visitor
&v
) const override
;
488 virtual bool zero_p () const override
;
489 virtual bool nonzero_p () const override
;
490 virtual void set_nonzero (tree type
) override
;
491 virtual void set_zero (tree type
) override
;
492 virtual void set_nonnegative (tree type
) override
;
493 frange
& operator= (const frange
&);
494 bool operator== (const frange
&) const;
495 bool operator!= (const frange
&r
) const { return !(*this == r
); }
496 const REAL_VALUE_TYPE
&lower_bound () const;
497 const REAL_VALUE_TYPE
&upper_bound () const;
498 nan_state
get_nan_state () const;
500 void update_nan (bool sign
);
501 void update_nan (tree
) = delete; // Disallow silent conversion to bool.
502 void update_nan (const nan_state
&);
504 void flush_denormals_to_zero ();
506 // fpclassify like API
507 bool known_isfinite () const;
508 bool known_isnan () const;
509 bool known_isinf () const;
510 bool maybe_isnan () const;
511 bool maybe_isnan (bool sign
) const;
512 bool maybe_isinf () const;
513 bool signbit_p (bool &signbit
) const;
514 bool nan_signbit_p (bool &signbit
) const;
517 virtual bool contains_p (tree cst
) const override
;
518 virtual void set (tree
, tree
, value_range_kind
= VR_RANGE
) override
;
521 bool internal_singleton_p (REAL_VALUE_TYPE
* = NULL
) const;
522 void verify_range ();
523 bool normalize_kind ();
524 bool union_nans (const frange
&);
525 bool intersect_nans (const frange
&);
526 bool combine_zeros (const frange
&, bool union_p
);
529 REAL_VALUE_TYPE m_min
;
530 REAL_VALUE_TYPE m_max
;
535 inline const REAL_VALUE_TYPE
&
536 frange::lower_bound () const
538 gcc_checking_assert (!undefined_p () && !known_isnan ());
542 inline const REAL_VALUE_TYPE
&
543 frange::upper_bound () const
545 gcc_checking_assert (!undefined_p () && !known_isnan ());
549 // Return the NAN state.
552 frange::get_nan_state () const
554 return nan_state (m_pos_nan
, m_neg_nan
);
557 // is_a<> and as_a<> implementation for vrange.
559 // Anything we haven't specialized is a hard fail.
560 template <typename T
>
568 template <typename T
>
570 is_a (const vrange
&v
)
572 // Reuse is_a <vrange> to implement the const version.
573 const T
&derived
= static_cast<const T
&> (v
);
574 return is_a
<T
> (const_cast<T
&> (derived
));
577 template <typename T
>
581 gcc_checking_assert (is_a
<T
> (v
));
582 return static_cast <T
&> (v
);
585 template <typename T
>
587 as_a (const vrange
&v
)
589 gcc_checking_assert (is_a
<T
> (v
));
590 return static_cast <const T
&> (v
);
593 // Specializations for the different range types.
597 is_a
<irange
> (vrange
&v
)
599 return v
.m_discriminator
== VR_IRANGE
;
604 is_a
<frange
> (vrange
&v
)
606 return v
.m_discriminator
== VR_FRANGE
;
611 is_a
<unsupported_range
> (vrange
&v
)
613 return v
.m_discriminator
== VR_UNKNOWN
;
616 // For resizable ranges, resize the range up to HARD_MAX_RANGES if the
617 // NEEDED pairs is greater than the current capacity of the range.
620 irange::maybe_resize (int needed
)
622 if (!m_resizable
|| m_max_ranges
== HARD_MAX_RANGES
)
625 if (needed
> m_max_ranges
)
627 m_max_ranges
= HARD_MAX_RANGES
;
628 wide_int
*newmem
= new wide_int
[m_max_ranges
* 2];
629 memcpy (newmem
, m_base
, sizeof (wide_int
) * num_pairs () * 2);
634 template<unsigned N
, bool RESIZABLE
>
636 int_range
<N
, RESIZABLE
>::~int_range ()
638 if (RESIZABLE
&& m_base
!= m_ranges
)
642 // This is an "infinite" precision irange for use in temporary
643 // calculations. It starts with a sensible default covering 99% of
644 // uses, and goes up to HARD_MAX_RANGES when needed. Any allocated
645 // storage is freed upon destruction.
646 typedef int_range
<3, /*RESIZABLE=*/true> int_range_max
;
651 virtual void visit (const irange
&) const { }
652 virtual void visit (const frange
&) const { }
653 virtual void visit (const unsupported_range
&) const { }
656 typedef int_range
<2> value_range
;
658 // This is an "infinite" precision range object for use in temporary
659 // calculations for any of the handled types. The object can be
660 // transparently used as a vrange.
666 Value_Range (const vrange
&r
);
667 Value_Range (tree type
);
668 Value_Range (tree
, tree
, value_range_kind kind
= VR_RANGE
);
669 Value_Range (const Value_Range
&);
670 void set_type (tree type
);
671 vrange
& operator= (const vrange
&);
672 Value_Range
& operator= (const Value_Range
&);
673 bool operator== (const Value_Range
&r
) const;
674 bool operator!= (const Value_Range
&r
) const;
676 operator const vrange
&() const;
677 void dump (FILE *) const;
678 static bool supports_type_p (const_tree type
);
680 // Convenience methods for vrange compatibility.
681 tree
type () { return m_vrange
->type (); }
682 bool varying_p () const { return m_vrange
->varying_p (); }
683 bool undefined_p () const { return m_vrange
->undefined_p (); }
684 void set_varying (tree type
) { init (type
); m_vrange
->set_varying (type
); }
685 void set_undefined () { m_vrange
->set_undefined (); }
686 bool union_ (const vrange
&r
) { return m_vrange
->union_ (r
); }
687 bool intersect (const vrange
&r
) { return m_vrange
->intersect (r
); }
688 bool contains_p (tree cst
) const { return m_vrange
->contains_p (cst
); }
689 bool singleton_p (tree
*result
= NULL
) const
690 { return m_vrange
->singleton_p (result
); }
691 void set_zero (tree type
) { init (type
); return m_vrange
->set_zero (type
); }
692 void set_nonzero (tree type
)
693 { init (type
); return m_vrange
->set_nonzero (type
); }
694 bool nonzero_p () const { return m_vrange
->nonzero_p (); }
695 bool zero_p () const { return m_vrange
->zero_p (); }
696 wide_int
lower_bound () const; // For irange/prange comparability.
697 wide_int
upper_bound () const; // For irange/prange comparability.
698 void accept (const vrange_visitor
&v
) const { m_vrange
->accept (v
); }
700 void init (tree type
);
701 unsupported_range m_unsupported
;
703 int_range_max m_irange
;
708 Value_Range::Value_Range ()
710 m_vrange
= &m_unsupported
;
713 // Copy constructor from a vrange.
716 Value_Range::Value_Range (const vrange
&r
)
721 // Copy constructor from a TYPE. The range of the temporary is set to
725 Value_Range::Value_Range (tree type
)
731 Value_Range::Value_Range (tree min
, tree max
, value_range_kind kind
)
733 init (TREE_TYPE (min
));
734 m_vrange
->set (min
, max
, kind
);
738 Value_Range::Value_Range (const Value_Range
&r
)
743 // Initialize object so it is possible to store temporaries of TYPE
747 Value_Range::init (tree type
)
749 gcc_checking_assert (TYPE_P (type
));
751 if (irange::supports_p (type
))
752 m_vrange
= &m_irange
;
753 else if (frange::supports_p (type
))
754 m_vrange
= &m_frange
;
756 m_vrange
= &m_unsupported
;
759 // Set the temporary to allow storing temporaries of TYPE. The range
760 // of the temporary is set to UNDEFINED.
763 Value_Range::set_type (tree type
)
766 m_vrange
->set_undefined ();
769 // Assignment operator for temporaries. Copying incompatible types is
773 Value_Range::operator= (const vrange
&r
)
775 if (is_a
<irange
> (r
))
777 m_irange
= as_a
<irange
> (r
);
778 m_vrange
= &m_irange
;
780 else if (is_a
<frange
> (r
))
782 m_frange
= as_a
<frange
> (r
);
783 m_vrange
= &m_frange
;
785 else if (is_a
<unsupported_range
> (r
))
787 m_unsupported
= as_a
<unsupported_range
> (r
);
788 m_vrange
= &m_unsupported
;
797 Value_Range::operator= (const Value_Range
&r
)
799 if (r
.m_vrange
== &r
.m_irange
)
801 m_irange
= r
.m_irange
;
802 m_vrange
= &m_irange
;
804 else if (r
.m_vrange
== &r
.m_frange
)
806 m_frange
= r
.m_frange
;
807 m_vrange
= &m_frange
;
809 else if (r
.m_vrange
== &r
.m_unsupported
)
811 m_unsupported
= r
.m_unsupported
;
812 m_vrange
= &m_unsupported
;
821 Value_Range::operator== (const Value_Range
&r
) const
823 return *m_vrange
== *r
.m_vrange
;
827 Value_Range::operator!= (const Value_Range
&r
) const
829 return *m_vrange
!= *r
.m_vrange
;
833 Value_Range::operator vrange
&()
839 Value_Range::operator const vrange
&() const
844 // Return TRUE if TYPE is supported by the vrange infrastructure.
847 Value_Range::supports_type_p (const_tree type
)
849 return irange::supports_p (type
) || frange::supports_p (type
);
852 extern value_range_kind
get_legacy_range (const irange
&, tree
&min
, tree
&max
);
853 extern void dump_value_range (FILE *, const vrange
*);
854 extern bool vrp_operand_equal_p (const_tree
, const_tree
);
855 inline REAL_VALUE_TYPE
frange_val_min (const_tree type
);
856 inline REAL_VALUE_TYPE
frange_val_max (const_tree type
);
858 // Number of sub-ranges in a range.
861 irange::num_pairs () const
867 irange::type () const
869 gcc_checking_assert (m_num_ranges
> 0);
874 irange::varying_compatible_p () const
876 if (m_num_ranges
!= 1)
879 const wide_int
&l
= m_base
[0];
880 const wide_int
&u
= m_base
[1];
883 if (m_kind
== VR_VARYING
&& t
== error_mark_node
)
886 unsigned prec
= TYPE_PRECISION (t
);
887 signop sign
= TYPE_SIGN (t
);
888 if (INTEGRAL_TYPE_P (t
) || POINTER_TYPE_P (t
))
889 return (l
== wi::min_value (prec
, sign
)
890 && u
== wi::max_value (prec
, sign
)
891 && m_bitmask
.unknown_p ());
896 vrange::varying_p () const
898 return m_kind
== VR_VARYING
;
902 vrange::undefined_p () const
904 return m_kind
== VR_UNDEFINED
;
908 irange::zero_p () const
910 return (m_kind
== VR_RANGE
&& m_num_ranges
== 1
911 && lower_bound (0) == 0
912 && upper_bound (0) == 0);
916 irange::nonzero_p () const
921 wide_int zero
= wi::zero (TYPE_PRECISION (type ()));
922 return *this == int_range
<2> (type (), zero
, zero
, VR_ANTI_RANGE
);
926 irange::supports_p (const_tree type
)
928 return INTEGRAL_TYPE_P (type
) || POINTER_TYPE_P (type
);
932 irange::contains_p (tree cst
) const
934 return contains_p (wi::to_wide (cst
));
938 range_includes_zero_p (const irange
*vr
)
940 if (vr
->undefined_p ())
943 if (vr
->varying_p ())
946 wide_int zero
= wi::zero (TYPE_PRECISION (vr
->type ()));
947 return vr
->contains_p (zero
);
950 extern void gt_ggc_mx (vrange
*);
951 extern void gt_pch_nx (vrange
*);
952 extern void gt_pch_nx (vrange
*, gt_pointer_operator
, void *);
953 extern void gt_ggc_mx (irange
*);
954 extern void gt_pch_nx (irange
*);
955 extern void gt_pch_nx (irange
*, gt_pointer_operator
, void *);
956 extern void gt_ggc_mx (frange
*);
957 extern void gt_pch_nx (frange
*);
958 extern void gt_pch_nx (frange
*, gt_pointer_operator
, void *);
962 gt_ggc_mx (int_range
<N
> *x
)
964 gt_ggc_mx ((irange
*) x
);
969 gt_pch_nx (int_range
<N
> *x
)
971 gt_pch_nx ((irange
*) x
);
976 gt_pch_nx (int_range
<N
> *x
, gt_pointer_operator op
, void *cookie
)
978 gt_pch_nx ((irange
*) x
, op
, cookie
);
981 // Constructors for irange
984 irange::irange (wide_int
*base
, unsigned nranges
, bool resizable
)
985 : vrange (VR_IRANGE
),
986 m_resizable (resizable
),
987 m_max_ranges (nranges
)
993 // Constructors for int_range<>.
995 template<unsigned N
, bool RESIZABLE
>
997 int_range
<N
, RESIZABLE
>::int_range ()
998 : irange (m_ranges
, N
, RESIZABLE
)
1002 template<unsigned N
, bool RESIZABLE
>
1003 int_range
<N
, RESIZABLE
>::int_range (const int_range
&other
)
1004 : irange (m_ranges
, N
, RESIZABLE
)
1006 irange::operator= (other
);
1009 template<unsigned N
, bool RESIZABLE
>
1010 int_range
<N
, RESIZABLE
>::int_range (tree min
, tree max
, value_range_kind kind
)
1011 : irange (m_ranges
, N
, RESIZABLE
)
1013 irange::set (min
, max
, kind
);
1016 template<unsigned N
, bool RESIZABLE
>
1017 int_range
<N
, RESIZABLE
>::int_range (tree type
)
1018 : irange (m_ranges
, N
, RESIZABLE
)
1023 template<unsigned N
, bool RESIZABLE
>
1024 int_range
<N
, RESIZABLE
>::int_range (tree type
, const wide_int
&wmin
, const wide_int
&wmax
,
1025 value_range_kind kind
)
1026 : irange (m_ranges
, N
, RESIZABLE
)
1028 set (type
, wmin
, wmax
, kind
);
1031 template<unsigned N
, bool RESIZABLE
>
1032 int_range
<N
, RESIZABLE
>::int_range (const irange
&other
)
1033 : irange (m_ranges
, N
, RESIZABLE
)
1035 irange::operator= (other
);
1038 template<unsigned N
, bool RESIZABLE
>
1039 int_range
<N
, RESIZABLE
>&
1040 int_range
<N
, RESIZABLE
>::operator= (const int_range
&src
)
1042 irange::operator= (src
);
1047 irange::set_undefined ()
1049 m_kind
= VR_UNDEFINED
;
1054 irange::set_varying (tree type
)
1056 m_kind
= VR_VARYING
;
1058 m_bitmask
.set_unknown (TYPE_PRECISION (type
));
1060 if (INTEGRAL_TYPE_P (type
) || POINTER_TYPE_P (type
))
1063 // Strict enum's require varying to be not TYPE_MIN/MAX, but rather
1064 // min_value and max_value.
1065 m_base
[0] = wi::min_value (TYPE_PRECISION (type
), TYPE_SIGN (type
));
1066 m_base
[1] = wi::max_value (TYPE_PRECISION (type
), TYPE_SIGN (type
));
1069 m_type
= error_mark_node
;
1072 // Return the lower bound of a sub-range. PAIR is the sub-range in
1076 irange::lower_bound (unsigned pair
) const
1078 gcc_checking_assert (m_num_ranges
> 0);
1079 gcc_checking_assert (pair
+ 1 <= num_pairs ());
1080 return m_base
[pair
* 2];
1083 // Return the upper bound of a sub-range. PAIR is the sub-range in
1087 irange::upper_bound (unsigned pair
) const
1089 gcc_checking_assert (m_num_ranges
> 0);
1090 gcc_checking_assert (pair
+ 1 <= num_pairs ());
1091 return m_base
[pair
* 2 + 1];
1094 // Return the highest bound of a range.
1097 irange::upper_bound () const
1099 unsigned pairs
= num_pairs ();
1100 gcc_checking_assert (pairs
> 0);
1101 return upper_bound (pairs
- 1);
1104 // Set value range VR to a nonzero range of type TYPE.
1107 irange::set_nonzero (tree type
)
1109 unsigned prec
= TYPE_PRECISION (type
);
1111 if (TYPE_UNSIGNED (type
))
1115 m_base
[0] = wi::one (prec
);
1116 m_base
[1] = wi::minus_one (prec
);
1117 m_bitmask
.set_unknown (prec
);
1125 wide_int zero
= wi::zero (prec
);
1126 set (type
, zero
, zero
, VR_ANTI_RANGE
);
1130 // Set value range VR to a ZERO range of type TYPE.
1133 irange::set_zero (tree type
)
1135 wide_int zero
= wi::zero (TYPE_PRECISION (type
));
1136 set (type
, zero
, zero
);
1139 // Normalize a range to VARYING or UNDEFINED if possible.
1142 irange::normalize_kind ()
1144 if (m_num_ranges
== 0)
1146 else if (varying_compatible_p ())
1148 if (m_kind
== VR_RANGE
)
1149 m_kind
= VR_VARYING
;
1150 else if (m_kind
== VR_ANTI_RANGE
)
1158 contains_zero_p (const irange
&r
)
1160 if (r
.undefined_p ())
1163 wide_int zero
= wi::zero (TYPE_PRECISION (r
.type ()));
1164 return r
.contains_p (zero
);
1168 irange_val_min (const_tree type
)
1170 gcc_checking_assert (irange::supports_p (type
));
1171 return wi::min_value (TYPE_PRECISION (type
), TYPE_SIGN (type
));
1175 irange_val_max (const_tree type
)
1177 gcc_checking_assert (irange::supports_p (type
));
1178 return wi::max_value (TYPE_PRECISION (type
), TYPE_SIGN (type
));
1183 : vrange (VR_FRANGE
)
1189 frange::frange (const frange
&src
)
1190 : vrange (VR_FRANGE
)
1196 frange::frange (tree type
)
1197 : vrange (VR_FRANGE
)
1202 // frange constructor from REAL_VALUE_TYPE endpoints.
1205 frange::frange (tree type
,
1206 const REAL_VALUE_TYPE
&min
, const REAL_VALUE_TYPE
&max
,
1207 value_range_kind kind
)
1208 : vrange (VR_FRANGE
)
1210 set (type
, min
, max
, kind
);
1213 // frange constructor from trees.
1216 frange::frange (tree min
, tree max
, value_range_kind kind
)
1217 : vrange (VR_FRANGE
)
1219 set (min
, max
, kind
);
1223 frange::type () const
1225 gcc_checking_assert (!undefined_p ());
1230 frange::set_varying (tree type
)
1232 m_kind
= VR_VARYING
;
1234 m_min
= frange_val_min (type
);
1235 m_max
= frange_val_max (type
);
1236 if (HONOR_NANS (m_type
))
1249 frange::set_undefined ()
1251 m_kind
= VR_UNDEFINED
;
1255 // m_min and m_min are uninitialized as they are REAL_VALUE_TYPE ??.
1260 // Set the NAN bits to NAN and adjust the range.
1263 frange::update_nan (const nan_state
&nan
)
1265 gcc_checking_assert (!undefined_p ());
1266 if (HONOR_NANS (m_type
))
1268 m_pos_nan
= nan
.pos_p ();
1269 m_neg_nan
= nan
.neg_p ();
1276 // Set the NAN bit to +-NAN.
1279 frange::update_nan ()
1281 gcc_checking_assert (!undefined_p ());
1282 nan_state
nan (true);
1286 // Like above, but set the sign of the NAN.
1289 frange::update_nan (bool sign
)
1291 gcc_checking_assert (!undefined_p ());
1292 nan_state
nan (/*pos=*/!sign
, /*neg=*/sign
);
1297 frange::contains_p (tree cst
) const
1299 return contains_p (*TREE_REAL_CST_PTR (cst
));
1302 // Clear the NAN bit and adjust the range.
1305 frange::clear_nan ()
1307 gcc_checking_assert (!undefined_p ());
1315 // Set R to maximum representable value for TYPE.
1317 inline REAL_VALUE_TYPE
1318 real_max_representable (const_tree type
)
1322 get_max_float (REAL_MODE_FORMAT (TYPE_MODE (type
)),
1323 buf
, sizeof (buf
), false);
1324 int res
= real_from_string (&r
, buf
);
1325 gcc_checking_assert (!res
);
1329 // Return the minimum representable value for TYPE.
1331 inline REAL_VALUE_TYPE
1332 real_min_representable (const_tree type
)
1334 REAL_VALUE_TYPE r
= real_max_representable (type
);
1335 r
= real_value_negate (&r
);
1339 // Return the minimum value for TYPE.
1341 inline REAL_VALUE_TYPE
1342 frange_val_min (const_tree type
)
1344 if (HONOR_INFINITIES (type
))
1347 return real_min_representable (type
);
1350 // Return the maximum value for TYPE.
1352 inline REAL_VALUE_TYPE
1353 frange_val_max (const_tree type
)
1355 if (HONOR_INFINITIES (type
))
1358 return real_max_representable (type
);
1361 // Return TRUE if R is the minimum value for TYPE.
1364 frange_val_is_min (const REAL_VALUE_TYPE
&r
, const_tree type
)
1366 REAL_VALUE_TYPE min
= frange_val_min (type
);
1367 return real_identical (&min
, &r
);
1370 // Return TRUE if R is the max value for TYPE.
1373 frange_val_is_max (const REAL_VALUE_TYPE
&r
, const_tree type
)
1375 REAL_VALUE_TYPE max
= frange_val_max (type
);
1376 return real_identical (&max
, &r
);
1379 // Build a NAN with a state of NAN.
1382 frange::set_nan (tree type
, const nan_state
&nan
)
1384 gcc_checking_assert (nan
.pos_p () || nan
.neg_p ());
1385 if (HONOR_NANS (type
))
1389 m_neg_nan
= nan
.neg_p ();
1390 m_pos_nan
= nan
.pos_p ();
1398 // Build a signless NAN of type TYPE.
1401 frange::set_nan (tree type
)
1403 nan_state
nan (true);
1404 set_nan (type
, nan
);
1407 // Build a NAN of type TYPE with SIGN.
1410 frange::set_nan (tree type
, bool sign
)
1412 nan_state
nan (/*pos=*/!sign
, /*neg=*/sign
);
1413 set_nan (type
, nan
);
1416 // Return TRUE if range is known to be finite.
1419 frange::known_isfinite () const
1421 if (undefined_p () || varying_p () || m_kind
== VR_ANTI_RANGE
)
1423 return (!maybe_isnan () && !real_isinf (&m_min
) && !real_isinf (&m_max
));
1426 // Return TRUE if range may be infinite.
1429 frange::maybe_isinf () const
1431 if (undefined_p () || m_kind
== VR_ANTI_RANGE
|| m_kind
== VR_NAN
)
1435 return real_isinf (&m_min
) || real_isinf (&m_max
);
1438 // Return TRUE if range is known to be the [-INF,-INF] or [+INF,+INF].
1441 frange::known_isinf () const
1443 return (m_kind
== VR_RANGE
1445 && real_identical (&m_min
, &m_max
)
1446 && real_isinf (&m_min
));
1449 // Return TRUE if range is possibly a NAN.
1452 frange::maybe_isnan () const
1456 return m_pos_nan
|| m_neg_nan
;
1459 // Return TRUE if range is possibly a NAN with SIGN.
1462 frange::maybe_isnan (bool sign
) const
1471 // Return TRUE if range is a +NAN or -NAN.
1474 frange::known_isnan () const
1476 return m_kind
== VR_NAN
;
1479 // If the signbit for the range is known, set it in SIGNBIT and return
1483 frange::signbit_p (bool &signbit
) const
1488 // NAN with unknown sign.
1489 if (m_pos_nan
&& m_neg_nan
)
1492 if (!m_pos_nan
&& !m_neg_nan
)
1494 if (m_min
.sign
== m_max
.sign
)
1496 signbit
= m_min
.sign
;
1501 // NAN with known sign.
1502 bool nan_sign
= m_neg_nan
;
1504 || (nan_sign
== m_min
.sign
&& nan_sign
== m_max
.sign
))
1512 // If range has a NAN with a known sign, set it in SIGNBIT and return
1516 frange::nan_signbit_p (bool &signbit
) const
1521 if (m_pos_nan
== m_neg_nan
)
1524 signbit
= m_neg_nan
;
1528 void frange_nextafter (enum machine_mode
, REAL_VALUE_TYPE
&,
1529 const REAL_VALUE_TYPE
&);
1530 void frange_arithmetic (enum tree_code
, tree
, REAL_VALUE_TYPE
&,
1531 const REAL_VALUE_TYPE
&, const REAL_VALUE_TYPE
&,
1532 const REAL_VALUE_TYPE
&);
1534 #endif // GCC_VALUE_RANGE_H