[COMMITTED] Do not double print INF and NAN in frange pretty printer.

[COMMITTED] Do not double print INF and NAN in frange pretty printer.

[Aldy Hernandez]

gcc/ChangeLog:

	* value-range-pretty-print.cc (vrange_printer::print_real_value):
	Avoid printing INF and NAN twice.
---
 gcc/value-range-pretty-print.cc | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/gcc/value-range-pretty-print.cc b/gcc/value-range-pretty-print.cc
index 8cbe97b76fd..3a3b4b44cbd 100644
--- a/gcc/value-range-pretty-print.cc
+++ b/gcc/value-range-pretty-print.cc
@@ -123,7 +123,11 @@ vrange_printer::print_real_value (tree type, const REAL_VALUE_TYPE &r) const
   char s[100];
   real_to_decimal_for_mode (s, &r, sizeof (s), 0, 1, TYPE_MODE (type));
   pp_string (pp, s);
-  if (!DECIMAL_FLOAT_TYPE_P (type))
+  if (!DECIMAL_FLOAT_TYPE_P (type)
+      // real_to_hexadecimal prints infinities and NAN as text.  No
+      // need to print them twice.
+      && !real_isinf (&r)
+      && !real_isnan (&r))
     {
       real_to_hexadecimal (s, &r, sizeof (s), 0, 1);
       pp_printf (pp, " (%s)", s);
-- 
2.37.1

[COMMITTED] Do not check finite_operands_p twice in range-ops-float.

[Aldy Hernandez]

The uses of finite_operands_p removed are guarded by a call to
finite_operands_p already.

gcc/ChangeLog:

	* range-op-float.cc (foperator_lt::fold_range): Remove extra check
	to finite_operands_p.
	(foperator_le::fold_range): Same.
	(foperator_gt::fold_range): Same.
	(foperator_ge::fold_range): Same.
---
 gcc/range-op-float.cc | 12 ++++--------
 1 file changed, 4 insertions(+), 8 deletions(-)

diff --git a/gcc/range-op-float.cc b/gcc/range-op-float.cc
index 6e9d51d3b4b..68578aa6fe7 100644
--- a/gcc/range-op-float.cc
+++ b/gcc/range-op-float.cc
@@ -572,8 +572,7 @@ foperator_lt::fold_range (irange &r, tree type,
     {
       if (real_less (&op1.upper_bound (), &op2.lower_bound ()))
 	r = range_true (type);
-      else if (finite_operands_p (op1, op2)
-	       && !real_less (&op1.lower_bound (), &op2.upper_bound ()))
+      else if (!real_less (&op1.lower_bound (), &op2.upper_bound ()))
 	r = range_false (type);
       else
 	r = range_true_and_false (type);
@@ -688,8 +687,7 @@ foperator_le::fold_range (irange &r, tree type,
     {
       if (real_compare (LE_EXPR, &op1.upper_bound (), &op2.lower_bound ()))
 	r = range_true (type);
-      else if (finite_operands_p (op1, op2)
-	       && !real_compare (LE_EXPR, &op1.lower_bound (), &op2.upper_bound ()))
+      else if (!real_compare (LE_EXPR, &op1.lower_bound (), &op2.upper_bound ()))
 	r = range_false (type);
       else
 	r = range_true_and_false (type);
@@ -796,8 +794,7 @@ foperator_gt::fold_range (irange &r, tree type,
     {
       if (real_compare (GT_EXPR, &op1.lower_bound (), &op2.upper_bound ()))
 	r = range_true (type);
-      else if (finite_operands_p (op1, op2)
-	       && !real_compare (GT_EXPR, &op1.upper_bound (), &op2.lower_bound ()))
+      else if (!real_compare (GT_EXPR, &op1.upper_bound (), &op2.lower_bound ()))
 	r = range_false (type);
       else
 	r = range_true_and_false (type);
@@ -912,8 +909,7 @@ foperator_ge::fold_range (irange &r, tree type,
     {
       if (real_compare (GE_EXPR, &op1.lower_bound (), &op2.upper_bound ()))
 	r = range_true (type);
-      else if (finite_operands_p (op1, op2)
-	       && !real_compare (GE_EXPR, &op1.upper_bound (), &op2.lower_bound ()))
+      else if (!real_compare (GE_EXPR, &op1.upper_bound (), &op2.lower_bound ()))
 	r = range_false (type);
       else
 	r = range_true_and_false (type);
-- 
2.37.1

[COMMITTED] Setting explicit NANs sets UNDEFINED for -ffinite-math-only.

[Aldy Hernandez]

We recently agreed that setting a range of NAN should instead set
UNDEFINED for -ffinite-math-only.  This patch makes that change to
frange::set_nan() directly.  Also, calling frange::update_nan() will now
be a nop for !HONOR_NANS.

Doing this in the setters simplifies everywhere we set NANs, as it keeps
us from introducing NANs by mistake.

gcc/ChangeLog:

	* value-range.cc (frange::set): Call set_nan unconditionally.
	(range_tests_nan): Adjust tests.
	(range_tests_signed_zeros): Same.
	(range_tests_floats): Same.
	* value-range.h (frange::update_nan): Guard with HONOR_NANS.
	(frange::set_nan): Set undefined if !HONOR_NANS.
---
 gcc/value-range.cc | 59 ++++++++++++++++++++++-----------------------
 gcc/value-range.h  | 60 +++++++++++++++++++++++++++++-----------------
 2 files changed, 67 insertions(+), 52 deletions(-)

diff --git a/gcc/value-range.cc b/gcc/value-range.cc
index a307559b654..87239fafa77 100644
--- a/gcc/value-range.cc
+++ b/gcc/value-range.cc
@@ -304,13 +304,8 @@ frange::set (tree type,
   if (real_isnan (&min) || real_isnan (&max))
     {
       gcc_checking_assert (real_identical (&min, &max));
-      if (HONOR_NANS (type))
-	{
-	  bool sign = real_isneg (&min);
-	  set_nan (type, sign);
-	}
-      else
-	set_undefined ();
+      bool sign = real_isneg (&min);
+      set_nan (type, sign);
       return;
     }
 
@@ -3624,6 +3619,7 @@ range_tests_nan ()
 {
   frange r0, r1;
   REAL_VALUE_TYPE q, r;
+  bool signbit;
 
   // Equal ranges but with differing NAN bits are not equal.
   if (HONOR_NANS (float_type_node))
@@ -3735,6 +3731,26 @@ range_tests_nan ()
   r0.set_nan (float_type_node);
   r0.clear_nan ();
   ASSERT_TRUE (r0.undefined_p ());
+
+  // [10,20] NAN ^ [21,25] NAN = [NAN]
+  r0 = frange_float ("10", "20");
+  r0.update_nan ();
+  r1 = frange_float ("21", "25");
+  r1.update_nan ();
+  r0.intersect (r1);
+  ASSERT_TRUE (r0.known_isnan ());
+
+  // NAN U [5,6] should be [5,6] +-NAN.
+  r0.set_nan (float_type_node);
+  r1 = frange_float ("5", "6");
+  r1.clear_nan ();
+  r0.union_ (r1);
+  real_from_string (&q, "5");
+  real_from_string (&r, "6");
+  ASSERT_TRUE (real_identical (&q, &r0.lower_bound ()));
+  ASSERT_TRUE (real_identical (&r, &r0.upper_bound ()));
+  ASSERT_TRUE (!r0.signbit_p (signbit));
+  ASSERT_TRUE (r0.maybe_isnan ());
 }
 
 static void
@@ -3742,7 +3758,6 @@ range_tests_signed_zeros ()
 {
   tree zero = build_zero_cst (float_type_node);
   tree neg_zero = fold_build1 (NEGATE_EXPR, float_type_node, zero);
-  REAL_VALUE_TYPE q, r;
   frange r0, r1;
   bool signbit;
 
@@ -3788,18 +3803,6 @@ range_tests_signed_zeros ()
   r0.intersect (r1);
   ASSERT_TRUE (r0.zero_p ());
 
-  // NAN U [5,6] should be [5,6] NAN.
-  r0.set_nan (float_type_node);
-  r1 = frange_float ("5", "6");
-  r1.clear_nan ();
-  r0.union_ (r1);
-  real_from_string (&q, "5");
-  real_from_string (&r, "6");
-  ASSERT_TRUE (real_identical (&q, &r0.lower_bound ()));
-  ASSERT_TRUE (real_identical (&r, &r0.upper_bound ()));
-  ASSERT_TRUE (!r0.signbit_p (signbit));
-  ASSERT_TRUE (r0.maybe_isnan ());
-
   r0 = frange_float ("+0", "5");
   r0.clear_nan ();
   ASSERT_TRUE (r0.signbit_p (signbit) && !signbit);
@@ -3823,7 +3826,10 @@ range_tests_signed_zeros ()
   r1 = frange_float ("0", "0");
   r1.update_nan ();
   r0.intersect (r1);
-  ASSERT_TRUE (r0.known_isnan ());
+  if (HONOR_NANS (float_type_node))
+    ASSERT_TRUE (r0.known_isnan ());
+  else
+    ASSERT_TRUE (r0.undefined_p ());
 
   r0.set_nonnegative (float_type_node);
   ASSERT_TRUE (r0.signbit_p (signbit) && !signbit);
@@ -3863,7 +3869,8 @@ range_tests_floats ()
 {
   frange r0, r1;
 
-  range_tests_nan ();
+  if (HONOR_NANS (float_type_node))
+    range_tests_nan ();
   range_tests_signbit ();
 
   if (HONOR_SIGNED_ZEROS (float_type_node))
@@ -3936,14 +3943,6 @@ range_tests_floats ()
   r0.intersect (r1);
   ASSERT_EQ (r0, frange_float ("15", "20"));
 
-  // [10,20] NAN ^ [21,25] NAN = [NAN]
-  r0 = frange_float ("10", "20");
-  r0.update_nan ();
-  r1 = frange_float ("21", "25");
-  r1.update_nan ();
-  r0.intersect (r1);
-  ASSERT_TRUE (r0.known_isnan ());
-
   // [10,20] ^ [21,25] = []
   r0 = frange_float ("10", "20");
   r0.clear_nan ();
diff --git a/gcc/value-range.h b/gcc/value-range.h
index d1663620444..b06ca7477cd 100644
--- a/gcc/value-range.h
+++ b/gcc/value-range.h
@@ -1111,11 +1111,14 @@ inline void
 frange::update_nan ()
 {
   gcc_checking_assert (!undefined_p ());
-  m_pos_nan = true;
-  m_neg_nan = true;
-  normalize_kind ();
-  if (flag_checking)
-    verify_range ();
+  if (HONOR_NANS (m_type))
+    {
+      m_pos_nan = true;
+      m_neg_nan = true;
+      normalize_kind ();
+      if (flag_checking)
+	verify_range ();
+    }
 }
 
 // Like above, but set the sign of the NAN.
@@ -1124,11 +1127,14 @@ inline void
 frange::update_nan (bool sign)
 {
   gcc_checking_assert (!undefined_p ());
-  m_pos_nan = !sign;
-  m_neg_nan = sign;
-  normalize_kind ();
-  if (flag_checking)
-    verify_range ();
+  if (HONOR_NANS (m_type))
+    {
+      m_pos_nan = !sign;
+      m_neg_nan = sign;
+      normalize_kind ();
+      if (flag_checking)
+	verify_range ();
+    }
 }
 
 // Clear the NAN bit and adjust the range.
@@ -1213,12 +1219,17 @@ frange_val_is_max (const REAL_VALUE_TYPE &r, const_tree type)
 inline void
 frange::set_nan (tree type)
 {
-  m_kind = VR_NAN;
-  m_type = type;
-  m_pos_nan = true;
-  m_neg_nan = true;
-  if (flag_checking)
-    verify_range ();
+  if (HONOR_NANS (type))
+    {
+      m_kind = VR_NAN;
+      m_type = type;
+      m_pos_nan = true;
+      m_neg_nan = true;
+      if (flag_checking)
+	verify_range ();
+    }
+  else
+    set_undefined ();
 }
 
 // Build a NAN of type TYPE with SIGN.
@@ -1226,12 +1237,17 @@ frange::set_nan (tree type)
 inline void
 frange::set_nan (tree type, bool sign)
 {
-  m_kind = VR_NAN;
-  m_type = type;
-  m_neg_nan = sign;
-  m_pos_nan = !sign;
-  if (flag_checking)
-    verify_range ();
+  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 ();
 }
 
 // Return TRUE if range is known to be finite.
-- 
2.37.1