Fix fallout from importing upstream nonzero changes to value_range.

From-SVN: r271906

6 files changed, 23 insertions, 23 deletions

diff --git a/gcc/range-op.c b/gcc/range-op.c
index 465eafe..ce59be5 100644
--- a/gcc/range-op.c
+++ b/gcc/range-op.c
@@ -400,7 +400,7 @@ irange_pointer_optimization (enum tree_code code, signop s, irange &r,
   else if (n == WIDE_INT_RANGE_NULL)
     r.union_ (range_zero (type));
   else if (n == WIDE_INT_RANGE_NONNULL)
-    r.union_ (range_non_zero (type));
+    r.union_ (range_nonzero (type));
   else
     gcc_unreachable ();
 }
@@ -2157,7 +2157,7 @@ operator_addr_expr::fold_range (irange& r, const irange& lh,
     r = range_zero (rh.type ());
   else
     if (!lh.contains_p (wi::zero (TYPE_PRECISION (lh.type ()))))
-      r = range_non_zero (rh.type ());
+      r = range_nonzero (rh.type ());
     else
       return false;
   return true;
diff --git a/gcc/range.c b/gcc/range.c
index eae1e52..c5a8fb6 100644
--- a/gcc/range.c
+++ b/gcc/range.c
@@ -160,7 +160,7 @@ get_tree_range (irange &r, tree expr)
 	  if (irange::supports_type_p (type))
 	    {
 	      if (tree_single_nonzero_warnv_p (expr, &ov))
-		r = range_non_zero (type);
+		r = range_nonzero (type);
 	      else
 		r.set_varying (type);
 	      return true;
@@ -305,7 +305,7 @@ irange::cast (tree new_type)
     {
       if (!contains_p (wi::zero (TYPE_PRECISION (m_type))))
 	{
-	  // Don't use range_non_zero because it will recurse into cast().
+	  // Don't use range_nonzero because it will recurse into cast().
 	  unsigned prec = TYPE_PRECISION (new_type);
 	  irange nz (new_type, wi::zero (prec), wi::zero (prec),
 		     irange::INVERSE);
@@ -799,7 +799,7 @@ irange::dump (pretty_printer *buffer) const
 {
   wide_int min = wi::min_value (TYPE_PRECISION (m_type), TYPE_SIGN (m_type));
   wide_int max = wi::max_value (TYPE_PRECISION (m_type), TYPE_SIGN (m_type));
-  if (POINTER_TYPE_P (m_type) && non_zero_p ())
+  if (POINTER_TYPE_P (m_type) && nonzero_p ())
     pp_string (buffer, "[ non-zero pointer ]");
   else
     for (unsigned i = 0; i < m_nitems; ++i)
@@ -894,7 +894,7 @@ range_zero (tree type)
 }
 
 irange
-range_non_zero (tree type)
+range_nonzero (tree type)
 {
   wide_int zero = wi::zero (TYPE_PRECISION (type));
   return irange (type, zero, zero, irange::INVERSE);
@@ -1077,7 +1077,7 @@ irange_tests ()
 				  UCHAR (0), UCHAR (254)));
 
   // Test that NOT(0) is [1..255] in 8-bit land.
-  irange not_zero = range_non_zero (unsigned_char_type_node);
+  irange not_zero = range_nonzero (unsigned_char_type_node);
   ASSERT_TRUE (not_zero == irange (unsigned_char_type_node, UCHAR (1), UCHAR (255)));
 
   // Check that [0,127][0x..ffffff80,0x..ffffff]
@@ -1289,7 +1289,7 @@ irange_tests ()
   // "NOT 0 at signed 32-bits" ==> [-MIN_32,-1][1, +MAX_32].  This is
   // is outside of the range of a smaller range, return the full
   // smaller range.
-  r0 = range_non_zero (integer_type_node);
+  r0 = range_nonzero (integer_type_node);
   r0.cast (short_integer_type_node);
   r1 = irange (short_integer_type_node,
 	       TYPE_MIN_VALUE (short_integer_type_node),
@@ -1300,7 +1300,7 @@ irange_tests ()
   //
   // NONZERO signed 16-bits is [-MIN_16,-1][1, +MAX_16].
   // Converting this to 32-bits signed is [-MIN_16,-1][1, +MAX_16].
-  r0 = range_non_zero (short_integer_type_node);
+  r0 = range_nonzero (short_integer_type_node);
   r0.cast (integer_type_node);
   r1 = irange (integer_type_node, INT (-32768), INT (-1));
   r2 = irange (integer_type_node, INT (1), INT (32767));
@@ -1540,10 +1540,10 @@ irange_tests ()
   r0 = irange (integer_type_node, INT (0), INT (0));
   ASSERT_TRUE (r0.zero_p ());
 
-  // Test non_zero_p().
+  // Test nonzero_p().
   r0 = irange (integer_type_node, INT (0), INT (0));
   r0.invert ();
-  ASSERT_TRUE (r0.non_zero_p ());
+  ASSERT_TRUE (r0.nonzero_p ());
 
   // Test irange / value_range conversion functions.
   r0 = irange (integer_type_node, INT (10), INT (20), irange::INVERSE);
diff --git a/gcc/range.h b/gcc/range.h
index cf27b87..4190e55 100644
--- a/gcc/range.h
+++ b/gcc/range.h
@@ -79,7 +79,7 @@ class irange
   bool varying_p () const;
   bool undefined_p () const;
   bool zero_p () const;
-  bool non_zero_p () const;
+  bool nonzero_p () const;
   bool singleton_p () const;
   bool singleton_p (wide_int &) const;
   bool contains_p (const wide_int &element) const;
@@ -112,7 +112,7 @@ private:
 }; // class irange
 
 irange range_zero (tree type);
-irange range_non_zero (tree type);
+irange range_nonzero (tree type);
 irange range_intersect (const irange &, const irange &);
 irange range_union (const irange &, const irange &);
 irange range_invert (const irange &);
@@ -225,7 +225,7 @@ irange::zero_p () const
 }
 
 inline bool
-irange::non_zero_p () const
+irange::nonzero_p () const
 {
   unsigned prec = TYPE_PRECISION (m_type);
   return *this == irange (m_type, wi::zero (prec), wi::zero (prec), INVERSE);
diff --git a/gcc/ssa-range-cache.cc b/gcc/ssa-range-cache.cc
index ba1eebc..da2cdbf 100644
--- a/gcc/ssa-range-cache.cc
+++ b/gcc/ssa-range-cache.cc
@@ -586,7 +586,7 @@ gori_cache::edge_range (irange &r, edge e, tree name)
   // so just punt for now on those.
   if (r.varying_p () && m_non_null.non_null_deref_p (name, src) &&
       !cfun->can_throw_non_call_exceptions)
-    r = range_non_zero (TREE_TYPE (name));
+    r = range_nonzero (TREE_TYPE (name));
 
   if (outgoing_edge_range_p (er, e, name, &r))
     r = er;
diff --git a/gcc/ssa-range.cc b/gcc/ssa-range.cc
index 4512f3f..0336696 100644
--- a/gcc/ssa-range.cc
+++ b/gcc/ssa-range.cc
@@ -691,7 +691,7 @@ ssa_ranger::range_of_call (irange &r, gcall *call, tree name ATTRIBUTE_UNUSED,
 
   if (gimple_call_nonnull_result_p (call))
     {
-      r = range_non_zero (type);
+      r = range_nonzero (type);
       return true;
     }
   r.set_varying (type);
@@ -893,7 +893,7 @@ global_ranger::range_of_expr (irange&r, tree op, gimple *s)
       // there is a deref.   Punt for now.
       if (!cfun->can_throw_non_call_exceptions && r.varying_p () &&
 	  m_gori.non_null_deref_p (op, bb))
-	r = range_non_zero (TREE_TYPE (op));
+	r = range_nonzero (TREE_TYPE (op));
       return true;
     }
 
diff --git a/gcc/tree-vrp.c b/gcc/tree-vrp.c
index 9d274f6..8537bfc 100644
--- a/gcc/tree-vrp.c
+++ b/gcc/tree-vrp.c
@@ -1546,7 +1546,7 @@ canonicalize_value_range (value_range_base *vr, tree expr_type)
 	      && (max == vr->max ()
 		  || operand_equal_p (vr->max (), max, 0)))))
     {
-      vr->set_nonnull (expr_type);
+      vr->set_nonzero (expr_type);
       return;
     }
 }
@@ -1641,7 +1641,7 @@ normalize_value_range_to_irange (irange &ir, const value_range_base *vr,
     ir = value_range_to_irange (vr_type, *vr);
   /* This will return ~[0,0] for [&var, &var].  */
   else if (POINTER_TYPE_P (expr_type) && !range_includes_zero_p (vr))
-    ir = range_non_zero (expr_type);
+    ir = range_nonzero (expr_type);
   else
     ir.set_varying (vr_type);
 }
@@ -1681,7 +1681,7 @@ ranger_fold (value_range_base *vr, enum tree_code code,
       && (code == MAX_EXPR || code == MIN_EXPR)
       && POINTER_TYPE_P (res.type ())
       && !res.zero_p ()
-      && !res.non_zero_p ())
+      && !res.nonzero_p ())
     {
       vr->set_varying ();
       return;
@@ -1714,9 +1714,9 @@ ranger_fold_unary (value_range_base *vr, enum tree_code code, tree expr_type,
       && (POINTER_TYPE_P (expr_type) || POINTER_TYPE_P (vr0_type)))
     {
       if (!range_includes_zero_p (vr0))
-	vr->set_nonnull (expr_type);
-      else if (range_is_null (vr0))
-	vr->set_null (expr_type);
+	vr->set_nonzero (expr_type);
+      else if (vr0->zero_p ())
+	vr->set_zero (expr_type);
       else
 	vr->set_varying ();
       return;