[COMMITTED] Add an frange::set_nan() variant that takes a nan_state.

[COMMITTED] Add an frange::set_nan() variant that takes a nan_state.

[Aldy Hernandez]

Generalize frange::set_nan() to take a nan_state and make current
set_nan() methods syntactic sugar.

This is in preparation for better streaming of NANs for LTO/IPA.

gcc/ChangeLog:

	* value-range.h (frange::set_nan): New.
---
 gcc/value-range.h | 32 +++++++++++++++++---------------
 1 file changed, 17 insertions(+), 15 deletions(-)

diff --git a/gcc/value-range.h b/gcc/value-range.h
index b8cc2a0e76a..39023e7b5eb 100644
--- a/gcc/value-range.h
+++ b/gcc/value-range.h
@@ -327,6 +327,7 @@ public:
 	    const nan_state &, value_range_kind = VR_RANGE);
   void set_nan (tree type);
   void set_nan (tree type, bool sign);
+  void set_nan (tree type, const nan_state &);
   virtual void set_varying (tree type) override;
   virtual void set_undefined () override;
   virtual bool union_ (const vrange &) override;
@@ -1219,17 +1220,18 @@ frange_val_is_max (const REAL_VALUE_TYPE &r, const_tree type)
   return real_identical (&max, &r);
 }
 
-// Build a signless NAN of type TYPE.
+// Build a NAN with a state of NAN.
 
 inline void
-frange::set_nan (tree type)
+frange::set_nan (tree type, const nan_state &nan)
 {
+  gcc_checking_assert (nan.pos_p () || nan.neg_p ());
   if (HONOR_NANS (type))
     {
       m_kind = VR_NAN;
       m_type = type;
-      m_pos_nan = true;
-      m_neg_nan = true;
+      m_neg_nan = nan.neg_p ();
+      m_pos_nan = nan.pos_p ();
       if (flag_checking)
 	verify_range ();
     }
@@ -1237,22 +1239,22 @@ frange::set_nan (tree type)
     set_undefined ();
 }
 
+// Build a signless NAN of type TYPE.
+
+inline void
+frange::set_nan (tree type)
+{
+  nan_state nan (true);
+  set_nan (type, nan);
+}
+
 // Build a NAN of type TYPE with SIGN.
 
 inline void
 frange::set_nan (tree type, bool sign)
 {
-  if (HONOR_NANS (type))
-    {
-      m_kind = VR_NAN;
-      m_type = type;
-      m_neg_nan = sign;
-      m_pos_nan = !sign;
-      if (flag_checking)
-	verify_range ();
-    }
-  else
-    set_undefined ();
+  nan_state nan (/*pos=*/!sign, /*neg=*/sign);
+  set_nan (type, nan);
 }
 
 // Return TRUE if range is known to be finite.
-- 
2.40.1

[COMMITTED] Hash known NANs correctly for franges.

[Aldy Hernandez]

We're ICEing when trying to hash a known NAN.  This is unnoticeable
because the only user would be IPA, and even so, it currently doesn't
handle floats.  However, handling floats is a flip of a switch, so
it's best to handle them already.

gcc/ChangeLog:

	* value-range.cc (add_vrange): Handle known NANs.
---
 gcc/value-range.cc | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/gcc/value-range.cc b/gcc/value-range.cc
index 874a1843ebf..2f37ff3e58e 100644
--- a/gcc/value-range.cc
+++ b/gcc/value-range.cc
@@ -269,14 +269,14 @@ add_vrange (const vrange &v, inchash::hash &hstate,
   if (is_a <frange> (v))
     {
       const frange &r = as_a <frange> (v);
-      if (r.varying_p ())
-	hstate.add_int (VR_VARYING);
+      if (r.known_isnan ())
+	hstate.add_int (VR_NAN);
       else
-	hstate.add_int (VR_RANGE);
-
-      hstate.add_real_value (r.lower_bound ());
-      hstate.add_real_value (r.upper_bound ());
-
+	{
+	  hstate.add_int (r.varying_p () ? VR_VARYING : VR_RANGE);
+	  hstate.add_real_value (r.lower_bound ());
+	  hstate.add_real_value (r.upper_bound ());
+	}
       nan_state nan = r.get_nan_state ();
       hstate.add_int (nan.pos_p ());
       hstate.add_int (nan.neg_p ());
-- 
2.40.1

[COMMITTED] Disallow setting of NANs in frange setter unless setting trees.

[Aldy Hernandez]

frange::set() is confusing in that we can set a NAN by specifying a
bound of +-NAN, even though we tecnically disallow NANs in the setter
because the kind can never be VR_NAN.  This is a wart for
get_tree_range(), which builds a range out of a tree from the source,
to work correctly.  It's ugly, and it showed its limitation while
implementing LTO streaming of ranges.

This patch disallows passing NAN bounds in frange::set() and fixes
get_tree_range.

gcc/ChangeLog:

	* value-query.cc (range_query::get_tree_range): Set NAN directly
	if necessary.
	* value-range.cc (frange::set): Assert that bounds are not NAN.
---
 gcc/value-query.cc | 13 ++++++++++---
 gcc/value-range.cc |  9 +--------
 2 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/gcc/value-query.cc b/gcc/value-query.cc
index 43297f17c39..a84f164d77b 100644
--- a/gcc/value-query.cc
+++ b/gcc/value-query.cc
@@ -189,9 +189,16 @@ range_query::get_tree_range (vrange &r, tree expr, gimple *stmt)
       {
 	frange &f = as_a <frange> (r);
 	REAL_VALUE_TYPE *rv = TREE_REAL_CST_PTR (expr);
-	f.set (TREE_TYPE (expr), *rv, *rv);
-	if (!real_isnan (rv))
-	  f.clear_nan ();
+	if (real_isnan (rv))
+	  {
+	    bool sign = real_isneg (rv);
+	    f.set_nan (TREE_TYPE (expr), sign);
+	  }
+	else
+	  {
+	    nan_state nan (false);
+	    f.set (TREE_TYPE (expr), *rv, *rv, nan);
+	  }
 	return true;
       }
 
diff --git a/gcc/value-range.cc b/gcc/value-range.cc
index 2f37ff3e58e..707b1f15fd4 100644
--- a/gcc/value-range.cc
+++ b/gcc/value-range.cc
@@ -359,14 +359,7 @@ frange::set (tree type,
       gcc_unreachable ();
     }
 
-  // Handle NANs.
-  if (real_isnan (&min) || real_isnan (&max))
-    {
-      gcc_checking_assert (real_identical (&min, &max));
-      bool sign = real_isneg (&min);
-      set_nan (type, sign);
-      return;
-    }
+  gcc_checking_assert (!real_isnan (&min) && !real_isnan (&max));
 
   m_kind = kind;
   m_type = type;
-- 
2.40.1

[COMMITTED] Stream out NANs correctly.

[Aldy Hernandez]

NANs don't have bounds, so there's no need to stream them out.

gcc/ChangeLog:

	* data-streamer-in.cc (streamer_read_value_range): Handle NANs.
	* data-streamer-out.cc (streamer_write_vrange): Same.
	* value-range.h (class vrange): Make streamer_write_vrange a friend.
---
 gcc/data-streamer-in.cc  | 16 ++++++++++++----
 gcc/data-streamer-out.cc | 17 ++++++++++++-----
 gcc/value-range.h        |  1 +
 3 files changed, 25 insertions(+), 9 deletions(-)

diff --git a/gcc/data-streamer-in.cc b/gcc/data-streamer-in.cc
index 07728bef413..578c328475f 100644
--- a/gcc/data-streamer-in.cc
+++ b/gcc/data-streamer-in.cc
@@ -248,14 +248,22 @@ streamer_read_value_range (class lto_input_block *ib, data_in *data_in,
   if (is_a <frange> (vr))
     {
       frange &r = as_a <frange> (vr);
-      REAL_VALUE_TYPE lb, ub;
-      streamer_read_real_value (ib, &lb);
-      streamer_read_real_value (ib, &ub);
+
+      // Stream in NAN bits.
       struct bitpack_d bp = streamer_read_bitpack (ib);
       bool pos_nan = (bool) bp_unpack_value (&bp, 1);
       bool neg_nan = (bool) bp_unpack_value (&bp, 1);
       nan_state nan (pos_nan, neg_nan);
-      r.set (type, lb, ub, nan);
+
+      if (kind == VR_NAN)
+	r.set_nan (type, nan);
+      else
+	{
+	  REAL_VALUE_TYPE lb, ub;
+	  streamer_read_real_value (ib, &lb);
+	  streamer_read_real_value (ib, &ub);
+	  r.set (type, lb, ub, nan);
+	}
       return;
     }
   gcc_unreachable ();
diff --git a/gcc/data-streamer-out.cc b/gcc/data-streamer-out.cc
index afc9862062b..93dedfcb895 100644
--- a/gcc/data-streamer-out.cc
+++ b/gcc/data-streamer-out.cc
@@ -410,7 +410,7 @@ streamer_write_vrange (struct output_block *ob, const vrange &v)
   gcc_checking_assert (!v.undefined_p ());
 
   // Write the common fields to all vranges.
-  value_range_kind kind = v.varying_p () ? VR_VARYING : VR_RANGE;
+  value_range_kind kind = v.m_kind;
   streamer_write_enum (ob->main_stream, value_range_kind, VR_LAST, kind);
   stream_write_tree (ob, v.type (), true);
 
@@ -429,15 +429,22 @@ streamer_write_vrange (struct output_block *ob, const vrange &v)
   if (is_a <frange> (v))
     {
       const frange &r = as_a <frange> (v);
-      REAL_VALUE_TYPE lb = r.lower_bound ();
-      REAL_VALUE_TYPE ub = r.upper_bound ();
-      streamer_write_real_value (ob, &lb);
-      streamer_write_real_value (ob, &ub);
+
+      // Stream out NAN bits.
       bitpack_d bp = bitpack_create (ob->main_stream);
       nan_state nan = r.get_nan_state ();
       bp_pack_value (&bp, nan.pos_p (), 1);
       bp_pack_value (&bp, nan.neg_p (), 1);
       streamer_write_bitpack (&bp);
+
+      // Stream out bounds.
+      if (kind != VR_NAN)
+	{
+	  REAL_VALUE_TYPE lb = r.lower_bound ();
+	  REAL_VALUE_TYPE ub = r.upper_bound ();
+	  streamer_write_real_value (ob, &lb);
+	  streamer_write_real_value (ob, &ub);
+	}
       return;
     }
   gcc_unreachable ();
diff --git a/gcc/value-range.h b/gcc/value-range.h
index 39023e7b5eb..2b4ebabe7c8 100644
--- a/gcc/value-range.h
+++ b/gcc/value-range.h
@@ -76,6 +76,7 @@ class GTY((user)) vrange
 {
   template <typename T> friend bool is_a (vrange &);
   friend class Value_Range;
+  friend void streamer_write_vrange (struct output_block *, const vrange &);
 public:
   virtual void accept (const class vrange_visitor &v) const = 0;
   virtual void set (tree, tree, value_range_kind = VR_RANGE);
-- 
2.40.1