Cache irange::num_pairs() for non-legacy code.

This does for num_pairs() what my previous patch did for VR_UNDEFINED
and VR_VARYING.

Note that VR_ANTI_RANGE for legacy is always set to 2 ranges.  There
is only one way of representing a range, so a range that can be
represented as a VR_RANGE will never have a kind of VR_ANTI_RANGE.
Also legacy symbolics can also use VR_ANTI_RANGE, but no one will ever
ask for the bounds of such range, so m_num_ranges is irrelevant.

gcc/ChangeLog:

	* value-range.cc (irange::legacy_num_pairs): Remove.
	(irange::invert): Change gcc_assert to gcc_checking_assert.
	* value-range.h (irange::num_pairs): Adjust for a cached
	num_pairs().  Also, rename all gcc_assert's to
	gcc_checking_assert's.

2 files changed, 9 insertions, 39 deletions

diff --git a/gcc/value-range.cc b/gcc/value-range.cc
index 297dd60..dc76ed7 100644
--- a/gcc/value-range.cc
+++ b/gcc/value-range.cc
@@ -369,11 +369,9 @@ irange::verify_range ()
 {
   if (m_kind == VR_UNDEFINED)
     {
-      gcc_assert (m_num_ranges == 0);
+      gcc_checking_assert (m_num_ranges == 0);
       return;
     }
-  gcc_assert (m_num_ranges != 0);
-
   if (m_kind == VR_VARYING)
     {
       gcc_checking_assert (m_num_ranges == 1);
@@ -382,50 +380,23 @@ irange::verify_range ()
     }
   if (!legacy_mode_p ())
     {
+      gcc_checking_assert (m_num_ranges != 0);
       gcc_checking_assert (!varying_compatible_p ());
       for (unsigned i = 0; i < m_num_ranges; ++i)
 	{
 	  tree lb = tree_lower_bound (i);
 	  tree ub = tree_upper_bound (i);
 	  int c = compare_values (lb, ub);
-	  gcc_assert (c == 0 || c == -1);
+	  gcc_checking_assert (c == 0 || c == -1);
 	}
       return;
     }
   if (m_kind == VR_RANGE || m_kind == VR_ANTI_RANGE)
     {
-      gcc_assert (m_num_ranges == 1);
+      gcc_checking_assert (m_num_ranges == 1);
       int cmp = compare_values (tree_lower_bound (0), tree_upper_bound (0));
-      gcc_assert (cmp == 0 || cmp == -1 || cmp == -2);
-    }
-}
-
-unsigned
-irange::legacy_num_pairs () const
-{
-  gcc_checking_assert (legacy_mode_p ());
-
-  if (undefined_p ())
-    return 0;
-  if (varying_p ())
-    return 1;
-  // Inlined symbolic_p for performance:
-  if (!is_gimple_min_invariant (min ()) || !is_gimple_min_invariant (max ()))
-    {
-      value_range numeric_range (*this);
-      numeric_range.normalize_symbolics ();
-      return numeric_range.num_pairs ();
-    }
-  if (m_kind == VR_ANTI_RANGE)
-    {
-      // ~[MIN, X] has one sub-range of [X+1, MAX], and
-      // ~[X, MAX] has one sub-range of [MIN, X-1].
-      if (vrp_val_is_min (min ()) || vrp_val_is_max (max ()))
-	return 1;
-      return 2;
+      gcc_checking_assert (cmp == 0 || cmp == -1 || cmp == -2);
     }
-  gcc_checking_assert (m_num_ranges == 1);
-  return 1;
 }
 
 // Return the lower bound for a sub-range.  PAIR is the sub-range in
@@ -1810,7 +1781,7 @@ irange::invert ()
       return;
     }
 
-  gcc_assert (!undefined_p () && !varying_p ());
+  gcc_checking_assert (!undefined_p () && !varying_p ());
 
   // We always need one more set of bounds to represent an inverse, so
   // if we're at the limit, we can't properly represent things.
diff --git a/gcc/value-range.h b/gcc/value-range.h
index e000432..7e36e21 100644
--- a/gcc/value-range.h
+++ b/gcc/value-range.h
@@ -118,7 +118,6 @@ protected:
   void legacy_union (irange *, const irange *);
   void legacy_intersect (irange *, const irange *);
   void verify_range ();
-  unsigned legacy_num_pairs () const;
   wide_int legacy_lower_bound (unsigned = 0) const;
   wide_int legacy_upper_bound (unsigned) const;
   int value_inside_range (tree) const;
@@ -207,10 +206,10 @@ irange::kind () const
 inline unsigned
 irange::num_pairs () const
 {
-  if (!legacy_mode_p ())
-    return m_num_ranges;
+  if (m_kind == VR_ANTI_RANGE)
+    return constant_p () ? 2 : 1;
   else
-    return legacy_num_pairs ();
+    return m_num_ranges;
 }
 
 inline tree