Provide cleaner set_nan(), clear_nan(), and update_nan() methods.

set_* has a very specific meaning for irange's and friends.  Methods
prefixed with set_* are setters clobbering the existing range.  As
such, the current set_nan() method is confusing in that it's not
actually setting a range to a NAN, but twiddling the NAN flags for an
existing frange.

This patch replaces set_nan() with an update_nan() to set the flag,
and clear_nan() to clear it.  This makes the code clearer, and though
the confusing tristate is still there, it will be removed in upcoming
patches.

Also, there is now an actual set_nan() method to set the range to a
NAN.  This replaces two out of class functions doing the same thing.
In future patches I will also add the ability to create a NAN with a
specific sign, but doing so now would be confusing because we're not
tracking NAN signs.

We should also submit set_signbit to the same fate, but it's about to
get removed.

No functional changes.

Regstrapped on x86-64 Linux, plus I ran selftests for
-ffinite-math-only.

gcc/ChangeLog:

	* range-op-float.cc (frange_set_nan): Remove.
	(build_lt): Use set_nan, update_nan, clear_nan.
	(build_gt): Same.
	(foperator_equal::op1_range): Same.
	(foperator_not_equal::op1_range): Same.
	(foperator_lt::op1_range): Same.
	(foperator_lt::op2_range): Same.
	(foperator_le::op1_range): Same.
	(foperator_le::op2_range): Same.
	(foperator_gt::op1_range): Same.
	(foperator_gt::op2_range): Same.
	(foperator_ge::op1_range): Same.
	(foperator_ge::op2_range): Same.
	(foperator_unordered::op1_range): Same.
	(foperator_ordered::op1_range): Same.
	* value-query.cc (range_query::get_tree_range): Same.
	* value-range.cc (frange::set_nan): Same.
	(frange::update_nan): Same.
	(frange::union_): Same.
	(frange::intersect): Same.
	(range_tests_nan): Same.
	(range_tests_signed_zeros): Same.
	(range_tests_signbit): Same.
	(range_tests_floats): Same.
	* value-range.h (class frange): Add update_nan and clear_nan.
	(frange::set_nan): New.

1 files changed, 26 insertions, 26 deletions

diff --git a/gcc/value-range.cc b/gcc/value-range.cc
index d40a4eb..dd82742 100644
--- a/gcc/value-range.cc
+++ b/gcc/value-range.cc
@@ -270,7 +270,7 @@ tree_compare (tree_code code, tree op1, tree op2)
 // Set the NAN property.  Adjust the range if appopriate.
 
 void
-frange::set_nan (fp_prop::kind k)
+frange::update_nan (fp_prop::kind k)
 {
   if (k == fp_prop::YES)
     {
@@ -280,7 +280,7 @@ frange::set_nan (fp_prop::kind k)
 	  return;
 	}
       gcc_checking_assert (!undefined_p ());
-      *this = frange_nan (m_type);
+      set_nan (m_type);
       return;
     }
 
@@ -474,7 +474,7 @@ frange::union_ (const vrange &v)
       *this = r;
       m_props = save;
       m_props.union_ (r.m_props);
-      set_nan (fp_prop::VARYING);
+      update_nan (fp_prop::VARYING);
       if (flag_checking)
 	verify_range ();
       return true;
@@ -482,7 +482,7 @@ frange::union_ (const vrange &v)
   if (r.known_nan ())
     {
       m_props.union_ (r.m_props);
-      set_nan (fp_prop::VARYING);
+      update_nan (fp_prop::VARYING);
       if (flag_checking)
 	verify_range ();
       return true;
@@ -531,7 +531,7 @@ frange::intersect (const vrange &v)
       if (m_props == r.m_props)
 	return false;
 
-      *this = frange_nan (m_type);
+      set_nan (m_type);
       return true;
     }
   // ?? Perhaps the intersection of a NAN and anything is a NAN ??.
@@ -3634,14 +3634,14 @@ range_tests_nan ()
       r1 = frange_float ("10", "12");
       r0 = r1;
       ASSERT_EQ (r0, r1);
-      r0.set_nan (fp_prop::NO);
+      r0.clear_nan ();
       ASSERT_NE (r0, r1);
-      r0.set_nan (fp_prop::YES);
+      r0.clear_nan ();
       ASSERT_NE (r0, r1);
     }
 
   // NAN ranges are not equal to each other.
-  r0 = frange_nan (float_type_node);
+  r0.set_nan (float_type_node);
   r1 = r0;
   ASSERT_FALSE (r0 == r1);
   ASSERT_FALSE (r0 == r0);
@@ -3649,8 +3649,8 @@ range_tests_nan ()
 
   // [5,6] U NAN = [5,6] NAN.
   r0 = frange_float ("5", "6");
-  r0.set_nan (fp_prop::NO);
-  r1 = frange_nan (float_type_node);
+  r0.clear_nan ();
+  r1.set_nan (float_type_node);
   r0.union_ (r1);
   real_from_string (&q, "5");
   real_from_string (&r, "6");
@@ -3659,34 +3659,34 @@ range_tests_nan ()
   ASSERT_TRUE (r0.maybe_nan ());
 
   // NAN U NAN = NAN
-  r0 = frange_nan (float_type_node);
-  r1 = frange_nan (float_type_node);
+  r0.set_nan (float_type_node);
+  r1.set_nan (float_type_node);
   r0.union_ (r1);
   ASSERT_TRUE (real_isnan (&r0.lower_bound ()));
   ASSERT_TRUE (real_isnan (&r1.upper_bound ()));
   ASSERT_TRUE (r0.known_nan ());
 
   // [INF, INF] ^ NAN = VARYING
-  r0 = frange_nan (float_type_node);
+  r0.set_nan (float_type_node);
   r1 = frange_float ("+Inf", "+Inf");
   r0.intersect (r1);
   ASSERT_TRUE (r0.varying_p ());
 
   // NAN ^ NAN = NAN
-  r0 = frange_nan (float_type_node);
-  r1 = frange_nan (float_type_node);
+  r0.set_nan (float_type_node);
+  r1.set_nan (float_type_node);
   r0.intersect (r1);
   ASSERT_TRUE (r0.known_nan ());
 
   // VARYING ^ NAN = NAN.
-  r0 = frange_nan (float_type_node);
+  r0.set_nan (float_type_node);
   r1.set_varying (float_type_node);
   r0.intersect (r1);
   ASSERT_TRUE (r0.known_nan ());
 
   // Setting the NAN bit to yes, forces to range to [NAN, NAN].
   r0.set_varying (float_type_node);
-  r0.set_nan (fp_prop::YES);
+  r0.update_nan (fp_prop::YES);
   ASSERT_TRUE (r0.known_nan ());
   ASSERT_TRUE (real_isnan (&r0.lower_bound ()));
   ASSERT_TRUE (real_isnan (&r0.upper_bound ()));
@@ -3736,7 +3736,7 @@ range_tests_signed_zeros ()
   ASSERT_TRUE (r0.zero_p () && !r0.known_signbit (signbit));
 
   // NAN U [5,6] should be [5,6] with no sign info.
-  r0 = frange_nan (float_type_node);
+  r0.set_nan (float_type_node);
   r1 = frange_float ("5", "6");
   r0.union_ (r1);
   real_from_string (&q, "5");
@@ -3762,7 +3762,7 @@ range_tests_signbit ()
   // the signbit property set.
   r0 = frange_float ("-5", "10");
   r0.set_signbit (fp_prop::YES);
-  r0.set_nan (fp_prop::NO);
+  r0.clear_nan ();
   ASSERT_TRUE (r0.known_signbit (signbit) && signbit);
   r1 = frange_float ("-5", "0");
   ASSERT_TRUE (real_identical (&r0.lower_bound (), &r1.lower_bound ()));
@@ -3770,20 +3770,20 @@ range_tests_signbit ()
 
   // Negative numbers should have the SIGNBIT set.
   r0 = frange_float ("-5", "-1");
-  r0.set_nan (fp_prop::NO);
+  r0.clear_nan ();
   ASSERT_TRUE (r0.known_signbit (signbit) && signbit);
   // Positive numbers should have the SIGNBIT clear.
   r0 = frange_float ("1", "10");
-  r0.set_nan (fp_prop::NO);
+  r0.clear_nan ();
   ASSERT_TRUE (r0.known_signbit (signbit) && !signbit);
   // Numbers containing zero should have an unknown SIGNBIT.
   r0 = frange_float ("0", "10");
-  r0.set_nan (fp_prop::NO);
+  r0.clear_nan ();
   ASSERT_TRUE (!r0.known_signbit (signbit));
   // Numbers spanning both positive and negative should have an
   // unknown SIGNBIT.
   r0 = frange_float ("-10", "10");
-  r0.set_nan (fp_prop::NO);
+  r0.clear_nan ();
   ASSERT_TRUE (!r0.known_signbit (signbit));
   r0.set_varying (float_type_node);
   ASSERT_TRUE (!r0.known_signbit (signbit));
@@ -3791,12 +3791,12 @@ range_tests_signbit ()
   // Ignore signbit changes when the sign bit is obviously known from
   // the range.
   r0 = frange_float ("5", "10");
-  r0.set_nan (fp_prop::NO);
+  r0.clear_nan ();
   r0.set_signbit (fp_prop::VARYING);
   ASSERT_TRUE (r0.known_signbit (signbit) && !signbit);
   r0 = frange_float ("-5", "-1");
   r0.set_signbit (fp_prop::NO);
-  r0.set_nan (fp_prop::NO);
+  r0.clear_nan ();
   ASSERT_TRUE (r0.undefined_p ());
 }
 
@@ -3817,7 +3817,7 @@ range_tests_floats ()
   if (r0.maybe_nan ())
     ASSERT_TRUE (r0.varying_p ());
   // ...unless it has some special property...
-  r0.set_nan (fp_prop::NO);
+  r0.clear_nan ();
   ASSERT_FALSE (r0.varying_p ());
 
   // The endpoints of a VARYING are +-INF.