gcc/value-range.h

   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>.
   5
   6 This file is part of GCC.
   7
   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)
  11 any later version.
  12
  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.
  17
  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/>.  */
  21
  22 #ifndef GCC_VALUE_RANGE_H
  23 #define GCC_VALUE_RANGE_H
  24
  25 class irange;
  26
  27 // Types of value ranges.
  28 enum value_range_kind
  29 {
  30   /* Empty range.  */
  31   VR_UNDEFINED,
  32   /* Range spans the entire domain.  */
  33   VR_VARYING,
  34   /* Range is [MIN, MAX].  */
  35   VR_RANGE,
  36   /* Range is ~[MIN, MAX].  */
  37   VR_ANTI_RANGE,
  38   /* Range is a NAN.  */
  39   VR_NAN,
  40   /* Range is a nice guy.  */
  41   VR_LAST
  42 };
  43
  44 // Discriminator between different vrange types.
  45
  46 enum value_range_discriminator
  47 {
  48   // Range holds an integer or pointer.
  49   VR_IRANGE,
  50   // Floating point range.
  51   VR_FRANGE,
  52   // Range holds an unsupported type.
  53   VR_UNKNOWN
  54 };
  55
  56 // Abstract class for ranges of any of the supported types.
  57 //
  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.
  61 //
  62 // To query what a given vrange variant can support, use:
  63 //    irange::supports_p ()
  64 //    frange::supports_p ()
  65 //    etc
  66 //
  67 // To query what a range object can support, use:
  68 //    void foo (vrange &v, irange &i, frange &f)
  69 //    {
  70 //      if (v.supports_type_p (type)) ...
  71 //      if (i.supports_type_p (type)) ...
  72 //      if (f.supports_type_p (type)) ...
  73 //    }
  74
  75 class GTY((user)) vrange
  76 {
  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;
  81 public:
  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;
  98
  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;
 105 protected:
 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;
 109 };
 110
 111 namespace inchash
 112 {
 113   extern void add_vrange (const vrange &, hash &, unsigned flags = 0);
 114 }
 115
 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.
 119 //
 120 // Set bits in MASK (no meaningful information) must have their
 121 // corresponding bits in VALUE cleared, as this speeds up union and
 122 // intersect.
 123
 124 class irange_bitmask
 125 {
 126 public:
 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;
 141
 142   // Convenience functions for nonzero bitmask compatibility.
 143   wide_int get_nonzero_bits () const;
 144   void set_nonzero_bits (const wide_int &bits);
 145 private:
 146   wide_int m_value;
 147   wide_int m_mask;
 148 };
 149
 150 inline void
 151 irange_bitmask::set_unknown (unsigned prec)
 152 {
 153   m_value = wi::zero (prec);
 154   m_mask = wi::minus_one (prec);
 155   if (flag_checking)
 156     verify_mask ();
 157 }
 158
 159 // Return TRUE if THIS does not have any meaningful information.
 160
 161 inline bool
 162 irange_bitmask::unknown_p () const
 163 {
 164   return m_mask == -1;
 165 }
 166
 167 inline
 168 irange_bitmask::irange_bitmask (const wide_int &value, const wide_int &mask)
 169 {
 170   m_value = value;
 171   m_mask = mask;
 172   if (flag_checking)
 173     verify_mask ();
 174 }
 175
 176 inline unsigned
 177 irange_bitmask::get_precision () const
 178 {
 179   return m_mask.get_precision ();
 180 }
 181
 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.
 185
 186 // Return the nonzero bits.
 187 inline wide_int
 188 irange_bitmask::get_nonzero_bits () const
 189 {
 190   return m_value | m_mask;
 191 }
 192
 193 // Set the bitmask to the nonzero bits in BITS.
 194 inline void
 195 irange_bitmask::set_nonzero_bits (const wide_int &bits)
 196 {
 197   m_value = wi::zero (bits.get_precision ());
 198   m_mask = bits;
 199   if (flag_checking)
 200     verify_mask ();
 201 }
 202
 203 inline bool
 204 irange_bitmask::operator== (const irange_bitmask &src) const
 205 {
 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;
 211 }
 212
 213 inline bool
 214 irange_bitmask::union_ (const irange_bitmask &orig_src)
 215 {
 216   // Normalize mask.
 217   irange_bitmask src (orig_src.m_value & ~orig_src.m_mask, orig_src.m_mask);
 218   m_value &= ~m_mask;
 219
 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;
 223   if (flag_checking)
 224     verify_mask ();
 225   return *this != save;
 226 }
 227
 228 inline bool
 229 irange_bitmask::intersect (const irange_bitmask &orig_src)
 230 {
 231   // Normalize mask.
 232   irange_bitmask src (orig_src.m_value & ~orig_src.m_mask, orig_src.m_mask);
 233   m_value &= ~m_mask;
 234
 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)
 242     {
 243       unsigned prec = m_mask.get_precision ();
 244       m_mask = wi::minus_one (prec);
 245       m_value = wi::zero (prec);
 246     }
 247   else
 248     {
 249       m_mask = m_mask & src.m_mask;
 250       m_value = m_value | src.m_value;
 251     }
 252   if (flag_checking)
 253     verify_mask ();
 254   return *this != save;
 255 }
 256
 257 // An integer range without any storage.
 258
 259 class GTY((user)) irange : public vrange
 260 {
 261   friend value_range_kind get_legacy_range (const irange &, tree &, tree &);
 262   friend class irange_storage;
 263   friend class vrange_printer;
 264 public:
 265   // In-place setters.
 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;
 273
 274   // Range types.
 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;
 278
 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;
 284
 285   // Predicates.
 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;
 293
 294   // In-place operators.
 295   virtual bool union_ (const vrange &) override;
 296   virtual bool intersect (const vrange &) override;
 297   void invert ();
 298
 299   // Operator overloads.
 300   irange& operator= (const irange &);
 301   bool operator== (const irange &) const;
 302   bool operator!= (const irange &r) const { return !(*this == r); }
 303
 304   // Misc methods.
 305   virtual bool fits_p (const vrange &r) const override;
 306   virtual void accept (const vrange_visitor &v) const override;
 307
 308   void update_bitmask (const irange_bitmask &);
 309   irange_bitmask get_bitmask () const;
 310   // Nonzero masks.
 311   wide_int get_nonzero_bits () const;
 312   void set_nonzero_bits (const wide_int &bits);
 313
 314 protected:
 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);
 319
 320    // In-place operators.
 321   bool irange_contains_p (const irange &) const;
 322   bool irange_single_pair_union (const irange &r);
 323
 324   void normalize_kind ();
 325
 326   void verify_range ();
 327
 328   // Hard limit on max ranges allowed.
 329   static const int HARD_MAX_RANGES = 255;
 330 private:
 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 *);
 334
 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 ();
 340
 341   bool intersect (const wide_int& lb, const wide_int& ub);
 342   unsigned char m_num_ranges;
 343   bool m_resizable;
 344   unsigned char m_max_ranges;
 345   tree m_type;
 346   irange_bitmask m_bitmask;
 347 protected:
 348   wide_int *m_base;
 349 };
 350
 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.
 353 //
 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.
 357
 358 template<unsigned N, bool RESIZABLE = false>
 359 class GTY((user)) int_range : public irange
 360 {
 361 public:
 362   int_range ();
 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 &);
 370 protected:
 371   int_range (tree, tree, value_range_kind = VR_RANGE);
 372 private:
 373   wide_int m_ranges[N*2];
 374 };
 375
 376 // Unsupported temporaries may be created by ranger before it's known
 377 // they're unsupported, or by vr_values::get_value_range.
 378
 379 class unsupported_range : public vrange
 380 {
 381 public:
 382   unsupported_range ()
 383     : vrange (VR_UNKNOWN)
 384   {
 385     set_undefined ();
 386   }
 387   virtual void set_undefined () final override
 388   {
 389     m_kind = VR_UNDEFINED;
 390   }
 391   virtual void accept (const vrange_visitor &v) const override;
 392 };
 393
 394 // The NAN state as an opaque object.
 395
 396 class nan_state
 397 {
 398 public:
 399   nan_state (bool);
 400   nan_state (bool pos_nan, bool neg_nan);
 401   bool neg_p () const;
 402   bool pos_p () const;
 403 private:
 404   bool m_pos_nan;
 405   bool m_neg_nan;
 406 };
 407
 408 // Set NAN state to +-NAN if NAN_P is true.  Otherwise set NAN state
 409 // to false.
 410
 411 inline
 412 nan_state::nan_state (bool nan_p)
 413 {
 414   m_pos_nan = nan_p;
 415   m_neg_nan = nan_p;
 416 }
 417
 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.
 421
 422 inline
 423 nan_state::nan_state (bool pos_nan, bool neg_nan)
 424 {
 425   m_pos_nan = pos_nan;
 426   m_neg_nan = neg_nan;
 427 }
 428
 429 // Return if +NAN is possible.
 430
 431 inline bool
 432 nan_state::pos_p () const
 433 {
 434   return m_pos_nan;
 435 }
 436
 437 // Return if -NAN is possible.
 438
 439 inline bool
 440 nan_state::neg_p () const
 441 {
 442   return m_neg_nan;
 443 }
 444
 445 // A floating point range.
 446 //
 447 // The representation is a type with a couple of endpoints, unioned
 448 // with the set of { -NAN, +Nan }.
 449
 450 class GTY((user)) frange : public vrange
 451 {
 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 *);
 457 public:
 458   frange ();
 459   frange (const frange &);
 460   frange (tree, tree, value_range_kind = VR_RANGE);
 461   frange (tree type);
 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)
 465   {
 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);
 470   }
 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;
 499   void update_nan ();
 500   void update_nan (bool sign);
 501   void update_nan (tree) = delete; // Disallow silent conversion to bool.
 502   void update_nan (const nan_state &);
 503   void clear_nan ();
 504   void flush_denormals_to_zero ();
 505
 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;
 515
 516 protected:
 517   virtual bool contains_p (tree cst) const override;
 518   virtual void set (tree, tree, value_range_kind = VR_RANGE) override;
 519
 520 private:
 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);
 527
 528   tree m_type;
 529   REAL_VALUE_TYPE m_min;
 530   REAL_VALUE_TYPE m_max;
 531   bool m_pos_nan;
 532   bool m_neg_nan;
 533 };
 534
 535 inline const REAL_VALUE_TYPE &
 536 frange::lower_bound () const
 537 {
 538   gcc_checking_assert (!undefined_p () && !known_isnan ());
 539   return m_min;
 540 }
 541
 542 inline const REAL_VALUE_TYPE &
 543 frange::upper_bound () const
 544 {
 545   gcc_checking_assert (!undefined_p () && !known_isnan ());
 546   return m_max;
 547 }
 548
 549 // Return the NAN state.
 550
 551 inline nan_state
 552 frange::get_nan_state () const
 553 {
 554   return nan_state (m_pos_nan, m_neg_nan);
 555 }
 556
 557 // is_a<> and as_a<> implementation for vrange.
 558
 559 // Anything we haven't specialized is a hard fail.
 560 template <typename T>
 561 inline bool
 562 is_a (vrange &)
 563 {
 564   gcc_unreachable ();
 565   return false;
 566 }
 567
 568 template <typename T>
 569 inline bool
 570 is_a (const vrange &v)
 571 {
 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));
 575 }
 576
 577 template <typename T>
 578 inline T &
 579 as_a (vrange &v)
 580 {
 581   gcc_checking_assert (is_a <T> (v));
 582   return static_cast <T &> (v);
 583 }
 584
 585 template <typename T>
 586 inline const T &
 587 as_a (const vrange &v)
 588 {
 589   gcc_checking_assert (is_a <T> (v));
 590   return static_cast <const T &> (v);
 591 }
 592
 593 // Specializations for the different range types.
 594
 595 template <>
 596 inline bool
 597 is_a <irange> (vrange &v)
 598 {
 599   return v.m_discriminator == VR_IRANGE;
 600 }
 601
 602 template <>
 603 inline bool
 604 is_a <frange> (vrange &v)
 605 {
 606   return v.m_discriminator == VR_FRANGE;
 607 }
 608
 609 template <>
 610 inline bool
 611 is_a <unsupported_range> (vrange &v)
 612 {
 613   return v.m_discriminator == VR_UNKNOWN;
 614 }
 615
 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.
 618
 619 inline void
 620 irange::maybe_resize (int needed)
 621 {
 622   if (!m_resizable || m_max_ranges == HARD_MAX_RANGES)
 623     return;
 624
 625   if (needed > m_max_ranges)
 626     {
 627       m_max_ranges = HARD_MAX_RANGES;
 628       wide_int *newmem = new wide_int[m_max_ranges * 2];
 629       unsigned n = num_pairs () * 2;
 630       for (unsigned i = 0; i < n; ++i)
 631         newmem[i] = m_base[i];
 632       m_base = newmem;
 633     }
 634 }
 635
 636 template<unsigned N, bool RESIZABLE>
 637 inline
 638 int_range<N, RESIZABLE>::~int_range ()
 639 {
 640   if (RESIZABLE && m_base != m_ranges)
 641     delete[] m_base;
 642 }
 643
 644 // This is an "infinite" precision irange for use in temporary
 645 // calculations.  It starts with a sensible default covering 99% of
 646 // uses, and goes up to HARD_MAX_RANGES when needed.  Any allocated
 647 // storage is freed upon destruction.
 648 typedef int_range<3, /*RESIZABLE=*/true> int_range_max;
 649
 650 class vrange_visitor
 651 {
 652 public:
 653   virtual void visit (const irange &) const { }
 654   virtual void visit (const frange &) const { }
 655   virtual void visit (const unsupported_range &) const { }
 656 };
 657
 658 typedef int_range<2> value_range;
 659
 660 // This is an "infinite" precision range object for use in temporary
 661 // calculations for any of the handled types.  The object can be
 662 // transparently used as a vrange.
 663
 664 class Value_Range
 665 {
 666 public:
 667   Value_Range ();
 668   Value_Range (const vrange &r);
 669   Value_Range (tree type);
 670   Value_Range (tree, tree, value_range_kind kind = VR_RANGE);
 671   Value_Range (const Value_Range &);
 672   void set_type (tree type);
 673   vrange& operator= (const vrange &);
 674   Value_Range& operator= (const Value_Range &);
 675   bool operator== (const Value_Range &r) const;
 676   bool operator!= (const Value_Range &r) const;
 677   operator vrange &();
 678   operator const vrange &() const;
 679   void dump (FILE *) const;
 680   static bool supports_type_p (const_tree type);
 681
 682   // Convenience methods for vrange compatibility.
 683   tree type () { return m_vrange->type (); }
 684   bool varying_p () const { return m_vrange->varying_p (); }
 685   bool undefined_p () const { return m_vrange->undefined_p (); }
 686   void set_varying (tree type) { init (type); m_vrange->set_varying (type); }
 687   void set_undefined () { m_vrange->set_undefined (); }
 688   bool union_ (const vrange &r) { return m_vrange->union_ (r); }
 689   bool intersect (const vrange &r) { return m_vrange->intersect (r); }
 690   bool contains_p (tree cst) const { return m_vrange->contains_p (cst); }
 691   bool singleton_p (tree *result = NULL) const
 692     { return m_vrange->singleton_p (result); }
 693   void set_zero (tree type) { init (type); return m_vrange->set_zero (type); }
 694   void set_nonzero (tree type)
 695     { init (type); return m_vrange->set_nonzero (type); }
 696   bool nonzero_p () const { return m_vrange->nonzero_p (); }
 697   bool zero_p () const { return m_vrange->zero_p (); }
 698   wide_int lower_bound () const; // For irange/prange comparability.
 699   wide_int upper_bound () const; // For irange/prange comparability.
 700   void accept (const vrange_visitor &v) const { m_vrange->accept (v); }
 701 private:
 702   void init (tree type);
 703   unsupported_range m_unsupported;
 704   vrange *m_vrange;
 705   int_range_max m_irange;
 706   frange m_frange;
 707 };
 708
 709 inline
 710 Value_Range::Value_Range ()
 711 {
 712   m_vrange = &m_unsupported;
 713 }
 714
 715 // Copy constructor from a vrange.
 716
 717 inline
 718 Value_Range::Value_Range (const vrange &r)
 719 {
 720   *this = r;
 721 }
 722
 723 // Copy constructor from a TYPE.  The range of the temporary is set to
 724 // UNDEFINED.
 725
 726 inline
 727 Value_Range::Value_Range (tree type)
 728 {
 729   init (type);
 730 }
 731
 732 inline
 733 Value_Range::Value_Range (tree min, tree max, value_range_kind kind)
 734 {
 735   init (TREE_TYPE (min));
 736   m_vrange->set (min, max, kind);
 737 }
 738
 739 inline
 740 Value_Range::Value_Range (const Value_Range &r)
 741 {
 742   *this = *r.m_vrange;
 743 }
 744
 745 // Initialize object so it is possible to store temporaries of TYPE
 746 // into it.
 747
 748 inline void
 749 Value_Range::init (tree type)
 750 {
 751   gcc_checking_assert (TYPE_P (type));
 752
 753   if (irange::supports_p (type))
 754     m_vrange = &m_irange;
 755   else if (frange::supports_p (type))
 756     m_vrange = &m_frange;
 757   else
 758     m_vrange = &m_unsupported;
 759 }
 760
 761 // Set the temporary to allow storing temporaries of TYPE.  The range
 762 // of the temporary is set to UNDEFINED.
 763
 764 inline void
 765 Value_Range::set_type (tree type)
 766 {
 767   init (type);
 768   m_vrange->set_undefined ();
 769 }
 770
 771 // Assignment operator for temporaries.  Copying incompatible types is
 772 // allowed.
 773
 774 inline vrange &
 775 Value_Range::operator= (const vrange &r)
 776 {
 777   if (is_a <irange> (r))
 778     {
 779       m_irange = as_a <irange> (r);
 780       m_vrange = &m_irange;
 781     }
 782   else if (is_a <frange> (r))
 783     {
 784       m_frange = as_a <frange> (r);
 785       m_vrange = &m_frange;
 786     }
 787   else if (is_a <unsupported_range> (r))
 788     {
 789       m_unsupported = as_a <unsupported_range> (r);
 790       m_vrange = &m_unsupported;
 791     }
 792   else
 793     gcc_unreachable ();
 794
 795   return *m_vrange;
 796 }
 797
 798 inline Value_Range &
 799 Value_Range::operator= (const Value_Range &r)
 800 {
 801   if (r.m_vrange == &r.m_irange)
 802     {
 803       m_irange = r.m_irange;
 804       m_vrange = &m_irange;
 805     }
 806   else if (r.m_vrange == &r.m_frange)
 807     {
 808       m_frange = r.m_frange;
 809       m_vrange = &m_frange;
 810     }
 811   else if (r.m_vrange == &r.m_unsupported)
 812     {
 813       m_unsupported = r.m_unsupported;
 814       m_vrange = &m_unsupported;
 815     }
 816   else
 817     gcc_unreachable ();
 818
 819   return *this;
 820 }
 821
 822 inline bool
 823 Value_Range::operator== (const Value_Range &r) const
 824 {
 825   return *m_vrange == *r.m_vrange;
 826 }
 827
 828 inline bool
 829 Value_Range::operator!= (const Value_Range &r) const
 830 {
 831   return *m_vrange != *r.m_vrange;
 832 }
 833
 834 inline
 835 Value_Range::operator vrange &()
 836 {
 837   return *m_vrange;
 838 }
 839
 840 inline
 841 Value_Range::operator const vrange &() const
 842 {
 843   return *m_vrange;
 844 }
 845
 846 // Return TRUE if TYPE is supported by the vrange infrastructure.
 847
 848 inline bool
 849 Value_Range::supports_type_p (const_tree type)
 850 {
 851   return irange::supports_p (type) || frange::supports_p (type);
 852 }
 853
 854 extern value_range_kind get_legacy_range (const irange &, tree &min, tree &max);
 855 extern void dump_value_range (FILE *, const vrange *);
 856 extern bool vrp_operand_equal_p (const_tree, const_tree);
 857 inline REAL_VALUE_TYPE frange_val_min (const_tree type);
 858 inline REAL_VALUE_TYPE frange_val_max (const_tree type);
 859
 860 // Number of sub-ranges in a range.
 861
 862 inline unsigned
 863 irange::num_pairs () const
 864 {
 865   return m_num_ranges;
 866 }
 867
 868 inline tree
 869 irange::type () const
 870 {
 871   gcc_checking_assert (m_num_ranges > 0);
 872   return m_type;
 873 }
 874
 875 inline bool
 876 irange::varying_compatible_p () const
 877 {
 878   if (m_num_ranges != 1)
 879     return false;
 880
 881   const wide_int &l = m_base[0];
 882   const wide_int &u = m_base[1];
 883   tree t = m_type;
 884
 885   if (m_kind == VR_VARYING && t == error_mark_node)
 886     return true;
 887
 888   unsigned prec = TYPE_PRECISION (t);
 889   signop sign = TYPE_SIGN (t);
 890   if (INTEGRAL_TYPE_P (t) || POINTER_TYPE_P (t))
 891     return (l == wi::min_value (prec, sign)
 892             && u == wi::max_value (prec, sign)
 893             && m_bitmask.unknown_p ());
 894   return true;
 895 }
 896
 897 inline bool
 898 vrange::varying_p () const
 899 {
 900   return m_kind == VR_VARYING;
 901 }
 902
 903 inline bool
 904 vrange::undefined_p () const
 905 {
 906   return m_kind == VR_UNDEFINED;
 907 }
 908
 909 inline bool
 910 irange::zero_p () const
 911 {
 912   return (m_kind == VR_RANGE && m_num_ranges == 1
 913           && lower_bound (0) == 0
 914           && upper_bound (0) == 0);
 915 }
 916
 917 inline bool
 918 irange::nonzero_p () const
 919 {
 920   if (undefined_p ())
 921     return false;
 922
 923   wide_int zero = wi::zero (TYPE_PRECISION (type ()));
 924   return *this == int_range<2> (type (), zero, zero, VR_ANTI_RANGE);
 925 }
 926
 927 inline bool
 928 irange::supports_p (const_tree type)
 929 {
 930   return INTEGRAL_TYPE_P (type) || POINTER_TYPE_P (type);
 931 }
 932
 933 inline bool
 934 irange::contains_p (tree cst) const
 935 {
 936   return contains_p (wi::to_wide (cst));
 937 }
 938
 939 inline bool
 940 range_includes_zero_p (const irange *vr)
 941 {
 942   if (vr->undefined_p ())
 943     return false;
 944
 945   if (vr->varying_p ())
 946     return true;
 947
 948   wide_int zero = wi::zero (TYPE_PRECISION (vr->type ()));
 949   return vr->contains_p (zero);
 950 }
 951
 952 extern void gt_ggc_mx (vrange *);
 953 extern void gt_pch_nx (vrange *);
 954 extern void gt_pch_nx (vrange *, gt_pointer_operator, void *);
 955 extern void gt_ggc_mx (irange *);
 956 extern void gt_pch_nx (irange *);
 957 extern void gt_pch_nx (irange *, gt_pointer_operator, void *);
 958 extern void gt_ggc_mx (frange *);
 959 extern void gt_pch_nx (frange *);
 960 extern void gt_pch_nx (frange *, gt_pointer_operator, void *);
 961
 962 template<unsigned N>
 963 inline void
 964 gt_ggc_mx (int_range<N> *x)
 965 {
 966   gt_ggc_mx ((irange *) x);
 967 }
 968
 969 template<unsigned N>
 970 inline void
 971 gt_pch_nx (int_range<N> *x)
 972 {
 973   gt_pch_nx ((irange *) x);
 974 }
 975
 976 template<unsigned N>
 977 inline void
 978 gt_pch_nx (int_range<N> *x, gt_pointer_operator op, void *cookie)
 979 {
 980   gt_pch_nx ((irange *) x, op, cookie);
 981 }
 982
 983 // Constructors for irange
 984
 985 inline
 986 irange::irange (wide_int *base, unsigned nranges, bool resizable)
 987   : vrange (VR_IRANGE),
 988     m_resizable (resizable),
 989     m_max_ranges (nranges)
 990 {
 991   m_base = base;
 992   set_undefined ();
 993 }
 994
 995 // Constructors for int_range<>.
 996
 997 template<unsigned N, bool RESIZABLE>
 998 inline
 999 int_range<N, RESIZABLE>::int_range ()
1000   : irange (m_ranges, N, RESIZABLE)
1001 {
1002 }
1003
1004 template<unsigned N, bool RESIZABLE>
1005 int_range<N, RESIZABLE>::int_range (const int_range &other)
1006   : irange (m_ranges, N, RESIZABLE)
1007 {
1008   irange::operator= (other);
1009 }
1010
1011 template<unsigned N, bool RESIZABLE>
1012 int_range<N, RESIZABLE>::int_range (tree min, tree max, value_range_kind kind)
1013   : irange (m_ranges, N, RESIZABLE)
1014 {
1015   irange::set (min, max, kind);
1016 }
1017
1018 template<unsigned N, bool RESIZABLE>
1019 int_range<N, RESIZABLE>::int_range (tree type)
1020   : irange (m_ranges, N, RESIZABLE)
1021 {
1022   set_varying (type);
1023 }
1024
1025 template<unsigned N, bool RESIZABLE>
1026 int_range<N, RESIZABLE>::int_range (tree type, const wide_int &wmin, const wide_int &wmax,
1027                          value_range_kind kind)
1028   : irange (m_ranges, N, RESIZABLE)
1029 {
1030   set (type, wmin, wmax, kind);
1031 }
1032
1033 template<unsigned N, bool RESIZABLE>
1034 int_range<N, RESIZABLE>::int_range (const irange &other)
1035   : irange (m_ranges, N, RESIZABLE)
1036 {
1037   irange::operator= (other);
1038 }
1039
1040 template<unsigned N, bool RESIZABLE>
1041 int_range<N, RESIZABLE>&
1042 int_range<N, RESIZABLE>::operator= (const int_range &src)
1043 {
1044   irange::operator= (src);
1045   return *this;
1046 }
1047
1048 inline void
1049 irange::set_undefined ()
1050 {
1051   m_kind = VR_UNDEFINED;
1052   m_num_ranges = 0;
1053 }
1054
1055 inline void
1056 irange::set_varying (tree type)
1057 {
1058   m_kind = VR_VARYING;
1059   m_num_ranges = 1;
1060   m_bitmask.set_unknown (TYPE_PRECISION (type));
1061
1062   if (INTEGRAL_TYPE_P (type) || POINTER_TYPE_P (type))
1063     {
1064       m_type = type;
1065       // Strict enum's require varying to be not TYPE_MIN/MAX, but rather
1066       // min_value and max_value.
1067       m_base[0] = wi::min_value (TYPE_PRECISION (type), TYPE_SIGN (type));
1068       m_base[1] = wi::max_value (TYPE_PRECISION (type), TYPE_SIGN (type));
1069     }
1070   else
1071     m_type = error_mark_node;
1072 }
1073
1074 // Return the lower bound of a sub-range.  PAIR is the sub-range in
1075 // question.
1076
1077 inline wide_int
1078 irange::lower_bound (unsigned pair) const
1079 {
1080   gcc_checking_assert (m_num_ranges > 0);
1081   gcc_checking_assert (pair + 1 <= num_pairs ());
1082   return m_base[pair * 2];
1083 }
1084
1085 // Return the upper bound of a sub-range.  PAIR is the sub-range in
1086 // question.
1087
1088 inline wide_int
1089 irange::upper_bound (unsigned pair) const
1090 {
1091   gcc_checking_assert (m_num_ranges > 0);
1092   gcc_checking_assert (pair + 1 <= num_pairs ());
1093   return m_base[pair * 2 + 1];
1094 }
1095
1096 // Return the highest bound of a range.
1097
1098 inline wide_int
1099 irange::upper_bound () const
1100 {
1101   unsigned pairs = num_pairs ();
1102   gcc_checking_assert (pairs > 0);
1103   return upper_bound (pairs - 1);
1104 }
1105
1106 // Set value range VR to a nonzero range of type TYPE.
1107
1108 inline void
1109 irange::set_nonzero (tree type)
1110 {
1111   unsigned prec = TYPE_PRECISION (type);
1112
1113   if (TYPE_UNSIGNED (type))
1114     {
1115       m_type = type;
1116       m_kind = VR_RANGE;
1117       m_base[0] = wi::one (prec);
1118       m_base[1] = wi::minus_one (prec);
1119       m_bitmask.set_unknown (prec);
1120       m_num_ranges = 1;
1121
1122       if (flag_checking)
1123         verify_range ();
1124     }
1125   else
1126     {
1127       wide_int zero = wi::zero (prec);
1128       set (type, zero, zero, VR_ANTI_RANGE);
1129     }
1130 }
1131
1132 // Set value range VR to a ZERO range of type TYPE.
1133
1134 inline void
1135 irange::set_zero (tree type)
1136 {
1137   wide_int zero = wi::zero (TYPE_PRECISION (type));
1138   set (type, zero, zero);
1139 }
1140
1141 // Normalize a range to VARYING or UNDEFINED if possible.
1142
1143 inline void
1144 irange::normalize_kind ()
1145 {
1146   if (m_num_ranges == 0)
1147     set_undefined ();
1148   else if (varying_compatible_p ())
1149     {
1150       if (m_kind == VR_RANGE)
1151         m_kind = VR_VARYING;
1152       else if (m_kind == VR_ANTI_RANGE)
1153         set_undefined ();
1154     }
1155   if (flag_checking)
1156     verify_range ();
1157 }
1158
1159 inline bool
1160 contains_zero_p (const irange &r)
1161 {
1162   if (r.undefined_p ())
1163     return false;
1164
1165   wide_int zero = wi::zero (TYPE_PRECISION (r.type ()));
1166   return r.contains_p (zero);
1167 }
1168
1169 inline wide_int
1170 irange_val_min (const_tree type)
1171 {
1172   gcc_checking_assert (irange::supports_p (type));
1173   return wi::min_value (TYPE_PRECISION (type), TYPE_SIGN (type));
1174 }
1175
1176 inline wide_int
1177 irange_val_max (const_tree type)
1178 {
1179   gcc_checking_assert (irange::supports_p (type));
1180   return wi::max_value (TYPE_PRECISION (type), TYPE_SIGN (type));
1181 }
1182
1183 inline
1184 frange::frange ()
1185   : vrange (VR_FRANGE)
1186 {
1187   set_undefined ();
1188 }
1189
1190 inline
1191 frange::frange (const frange &src)
1192   : vrange (VR_FRANGE)
1193 {
1194   *this = src;
1195 }
1196
1197 inline
1198 frange::frange (tree type)
1199   : vrange (VR_FRANGE)
1200 {
1201   set_varying (type);
1202 }
1203
1204 // frange constructor from REAL_VALUE_TYPE endpoints.
1205
1206 inline
1207 frange::frange (tree type,
1208                 const REAL_VALUE_TYPE &min, const REAL_VALUE_TYPE &max,
1209                 value_range_kind kind)
1210   : vrange (VR_FRANGE)
1211 {
1212   set (type, min, max, kind);
1213 }
1214
1215 // frange constructor from trees.
1216
1217 inline
1218 frange::frange (tree min, tree max, value_range_kind kind)
1219   : vrange (VR_FRANGE)
1220 {
1221   set (min, max, kind);
1222 }
1223
1224 inline tree
1225 frange::type () const
1226 {
1227   gcc_checking_assert (!undefined_p ());
1228   return m_type;
1229 }
1230
1231 inline void
1232 frange::set_varying (tree type)
1233 {
1234   m_kind = VR_VARYING;
1235   m_type = type;
1236   m_min = frange_val_min (type);
1237   m_max = frange_val_max (type);
1238   if (HONOR_NANS (m_type))
1239     {
1240       m_pos_nan = true;
1241       m_neg_nan = true;
1242     }
1243   else
1244     {
1245       m_pos_nan = false;
1246       m_neg_nan = false;
1247     }
1248 }
1249
1250 inline void
1251 frange::set_undefined ()
1252 {
1253   m_kind = VR_UNDEFINED;
1254   m_type = NULL;
1255   m_pos_nan = false;
1256   m_neg_nan = false;
1257   // m_min and m_min are uninitialized as they are REAL_VALUE_TYPE ??.
1258   if (flag_checking)
1259     verify_range ();
1260 }
1261
1262 // Set the NAN bits to NAN and adjust the range.
1263
1264 inline void
1265 frange::update_nan (const nan_state &nan)
1266 {
1267   gcc_checking_assert (!undefined_p ());
1268   if (HONOR_NANS (m_type))
1269     {
1270       m_pos_nan = nan.pos_p ();
1271       m_neg_nan = nan.neg_p ();
1272       normalize_kind ();
1273       if (flag_checking)
1274         verify_range ();
1275     }
1276 }
1277
1278 // Set the NAN bit to +-NAN.
1279
1280 inline void
1281 frange::update_nan ()
1282 {
1283   gcc_checking_assert (!undefined_p ());
1284   nan_state nan (true);
1285   update_nan (nan);
1286 }
1287
1288 // Like above, but set the sign of the NAN.
1289
1290 inline void
1291 frange::update_nan (bool sign)
1292 {
1293   gcc_checking_assert (!undefined_p ());
1294   nan_state nan (/*pos=*/!sign, /*neg=*/sign);
1295   update_nan (nan);
1296 }
1297
1298 inline bool
1299 frange::contains_p (tree cst) const
1300 {
1301   return contains_p (*TREE_REAL_CST_PTR (cst));
1302 }
1303
1304 // Clear the NAN bit and adjust the range.
1305
1306 inline void
1307 frange::clear_nan ()
1308 {
1309   gcc_checking_assert (!undefined_p ());
1310   m_pos_nan = false;
1311   m_neg_nan = false;
1312   normalize_kind ();
1313   if (flag_checking)
1314     verify_range ();
1315 }
1316
1317 // Set R to maximum representable value for TYPE.
1318
1319 inline REAL_VALUE_TYPE
1320 real_max_representable (const_tree type)
1321 {
1322   REAL_VALUE_TYPE r;
1323   char buf[128];
1324   get_max_float (REAL_MODE_FORMAT (TYPE_MODE (type)),
1325                  buf, sizeof (buf), false);
1326   int res = real_from_string (&r, buf);
1327   gcc_checking_assert (!res);
1328   return r;
1329 }
1330
1331 // Return the minimum representable value for TYPE.
1332
1333 inline REAL_VALUE_TYPE
1334 real_min_representable (const_tree type)
1335 {
1336   REAL_VALUE_TYPE r = real_max_representable (type);
1337   r = real_value_negate (&r);
1338   return r;
1339 }
1340
1341 // Return the minimum value for TYPE.
1342
1343 inline REAL_VALUE_TYPE
1344 frange_val_min (const_tree type)
1345 {
1346   if (HONOR_INFINITIES (type))
1347     return dconstninf;
1348   else
1349     return real_min_representable (type);
1350 }
1351
1352 // Return the maximum value for TYPE.
1353
1354 inline REAL_VALUE_TYPE
1355 frange_val_max (const_tree type)
1356 {
1357   if (HONOR_INFINITIES (type))
1358     return dconstinf;
1359   else
1360     return real_max_representable (type);
1361 }
1362
1363 // Return TRUE if R is the minimum value for TYPE.
1364
1365 inline bool
1366 frange_val_is_min (const REAL_VALUE_TYPE &r, const_tree type)
1367 {
1368   REAL_VALUE_TYPE min = frange_val_min (type);
1369   return real_identical (&min, &r);
1370 }
1371
1372 // Return TRUE if R is the max value for TYPE.
1373
1374 inline bool
1375 frange_val_is_max (const REAL_VALUE_TYPE &r, const_tree type)
1376 {
1377   REAL_VALUE_TYPE max = frange_val_max (type);
1378   return real_identical (&max, &r);
1379 }
1380
1381 // Build a NAN with a state of NAN.
1382
1383 inline void
1384 frange::set_nan (tree type, const nan_state &nan)
1385 {
1386   gcc_checking_assert (nan.pos_p () || nan.neg_p ());
1387   if (HONOR_NANS (type))
1388     {
1389       m_kind = VR_NAN;
1390       m_type = type;
1391       m_neg_nan = nan.neg_p ();
1392       m_pos_nan = nan.pos_p ();
1393       if (flag_checking)
1394         verify_range ();
1395     }
1396   else
1397     set_undefined ();
1398 }
1399
1400 // Build a signless NAN of type TYPE.
1401
1402 inline void
1403 frange::set_nan (tree type)
1404 {
1405   nan_state nan (true);
1406   set_nan (type, nan);
1407 }
1408
1409 // Build a NAN of type TYPE with SIGN.
1410
1411 inline void
1412 frange::set_nan (tree type, bool sign)
1413 {
1414   nan_state nan (/*pos=*/!sign, /*neg=*/sign);
1415   set_nan (type, nan);
1416 }
1417
1418 // Return TRUE if range is known to be finite.
1419
1420 inline bool
1421 frange::known_isfinite () const
1422 {
1423   if (undefined_p () || varying_p () || m_kind == VR_ANTI_RANGE)
1424     return false;
1425   return (!maybe_isnan () && !real_isinf (&m_min) && !real_isinf (&m_max));
1426 }
1427
1428 // Return TRUE if range may be infinite.
1429
1430 inline bool
1431 frange::maybe_isinf () const
1432 {
1433   if (undefined_p () || m_kind == VR_ANTI_RANGE || m_kind == VR_NAN)
1434     return false;
1435   if (varying_p ())
1436     return true;
1437   return real_isinf (&m_min) || real_isinf (&m_max);
1438 }
1439
1440 // Return TRUE if range is known to be the [-INF,-INF] or [+INF,+INF].
1441
1442 inline bool
1443 frange::known_isinf () const
1444 {
1445   return (m_kind == VR_RANGE
1446           && !maybe_isnan ()
1447           && real_identical (&m_min, &m_max)
1448           && real_isinf (&m_min));
1449 }
1450
1451 // Return TRUE if range is possibly a NAN.
1452
1453 inline bool
1454 frange::maybe_isnan () const
1455 {
1456   if (undefined_p ())
1457     return false;
1458   return m_pos_nan || m_neg_nan;
1459 }
1460
1461 // Return TRUE if range is possibly a NAN with SIGN.
1462
1463 inline bool
1464 frange::maybe_isnan (bool sign) const
1465 {
1466   if (undefined_p ())
1467     return false;
1468   if (sign)
1469     return m_neg_nan;
1470   return m_pos_nan;
1471 }
1472
1473 // Return TRUE if range is a +NAN or -NAN.
1474
1475 inline bool
1476 frange::known_isnan () const
1477 {
1478   return m_kind == VR_NAN;
1479 }
1480
1481 // If the signbit for the range is known, set it in SIGNBIT and return
1482 // TRUE.
1483
1484 inline bool
1485 frange::signbit_p (bool &signbit) const
1486 {
1487   if (undefined_p ())
1488     return false;
1489
1490   // NAN with unknown sign.
1491   if (m_pos_nan && m_neg_nan)
1492     return false;
1493   // No NAN.
1494   if (!m_pos_nan && !m_neg_nan)
1495     {
1496       if (m_min.sign == m_max.sign)
1497         {
1498           signbit = m_min.sign;
1499           return true;
1500         }
1501       return false;
1502     }
1503   // NAN with known sign.
1504   bool nan_sign = m_neg_nan;
1505   if (known_isnan ()
1506       || (nan_sign == m_min.sign && nan_sign == m_max.sign))
1507     {
1508       signbit = nan_sign;
1509       return true;
1510     }
1511   return false;
1512 }
1513
1514 // If range has a NAN with a known sign, set it in SIGNBIT and return
1515 // TRUE.
1516
1517 inline bool
1518 frange::nan_signbit_p (bool &signbit) const
1519 {
1520   if (undefined_p ())
1521     return false;
1522
1523   if (m_pos_nan == m_neg_nan)
1524     return false;
1525
1526   signbit = m_neg_nan;
1527   return true;
1528 }
1529
1530 void frange_nextafter (enum machine_mode, REAL_VALUE_TYPE &,
1531                        const REAL_VALUE_TYPE &);
1532 void frange_arithmetic (enum tree_code, tree, REAL_VALUE_TYPE &,
1533                         const REAL_VALUE_TYPE &, const REAL_VALUE_TYPE &,
1534                         const REAL_VALUE_TYPE &);
1535
1536 #endif // GCC_VALUE_RANGE_H