diff --git a/gcc/asan.cc b/gcc/asan.cc
index 8276f12cc69..9960803b99f 100644
--- a/gcc/asan.cc
+++ b/gcc/asan.cc
@@ -816,7 +816,7 @@ handle_builtin_alloca (gcall *call, gimple_stmt_iterator *iter)
   tree redzone_size = build_int_cst (size_type_node, ASAN_RED_ZONE_SIZE);
 
   /* Extract lower bits from old_size.  */
-  wide_int size_nonzero_bits = get_nonzero_bits (old_size);
+  wide_int size_nonzero_bits = get_known_zero_bits (old_size);
   wide_int rz_mask
     = wi::uhwi (redzone_mask, wi::get_precision (size_nonzero_bits));
   wide_int old_size_lower_bits = wi::bit_and (size_nonzero_bits, rz_mask);
diff --git a/gcc/fold-const.cc b/gcc/fold-const.cc
index 9f7beae14e5..c85231b4ca1 100644
--- a/gcc/fold-const.cc
+++ b/gcc/fold-const.cc
@@ -10815,7 +10815,7 @@ expr_not_equal_to (tree t, const wide_int &w)
 	return true;
       /* If T has some known zero bits and W has any of those bits set,
 	 then T is known not to be equal to W.  */
-      if (wi::ne_p (wi::zext (wi::bit_and_not (w, get_nonzero_bits (t)),
+      if (wi::ne_p (wi::zext (wi::bit_and_not (w, get_known_zero_bits (t)),
 			      TYPE_PRECISION (TREE_TYPE (t))), 0))
 	return true;
       return false;
@@ -16508,7 +16508,7 @@ tree_nonzero_bits (const_tree t)
     case INTEGER_CST:
       return wi::to_wide (t);
     case SSA_NAME:
-      return get_nonzero_bits (t);
+      return get_known_zero_bits (t);
     case NON_LVALUE_EXPR:
     case SAVE_EXPR:
       return tree_nonzero_bits (TREE_OPERAND (t, 0));
diff --git a/gcc/gimple-range-op.cc b/gcc/gimple-range-op.cc
index 7764166d5fb..90c6f7b3fd9 100644
--- a/gcc/gimple-range-op.cc
+++ b/gcc/gimple-range-op.cc
@@ -477,7 +477,7 @@ public:
     if (lh.undefined_p ())
       return false;
     unsigned prec = TYPE_PRECISION (type);
-    wide_int nz = lh.get_nonzero_bits ();
+    wide_int nz = lh.get_known_zero_bits ();
     wide_int pop = wi::shwi (wi::popcount (nz), prec);
     // Calculating the popcount of a singleton is trivial.
     if (lh.singleton_p ())
diff --git a/gcc/ipa-cp.cc b/gcc/ipa-cp.cc
index d2bcd5e5e69..4ba7ef878ba 100644
--- a/gcc/ipa-cp.cc
+++ b/gcc/ipa-cp.cc
@@ -1119,7 +1119,7 @@ ipcp_bits_lattice::known_nonzero_p () const
 void
 ipcp_bits_lattice::get_value_and_mask (tree operand, widest_int *valuep, widest_int *maskp)
 {
-  wide_int get_nonzero_bits (const_tree);
+  wide_int get_known_zero_bits (const_tree);
 
   if (TREE_CODE (operand) == INTEGER_CST)
     {
diff --git a/gcc/ipa-prop.cc b/gcc/ipa-prop.cc
index e6cf25591b3..e3cd5cf6415 100644
--- a/gcc/ipa-prop.cc
+++ b/gcc/ipa-prop.cc
@@ -2331,7 +2331,7 @@ ipa_compute_jump_functions_for_edge (struct ipa_func_body_info *fbi,
 	{
 	  if (TREE_CODE (arg) == SSA_NAME)
 	    ipa_set_jfunc_bits (jfunc, 0,
-				widest_int::from (get_nonzero_bits (arg),
+				widest_int::from (get_known_zero_bits (arg),
 						  TYPE_SIGN (TREE_TYPE (arg))));
 	  else
 	    ipa_set_jfunc_bits (jfunc, wi::to_widest (arg), 0);
@@ -5816,7 +5816,7 @@ ipcp_update_bits (struct cgraph_node *node)
 
 	  wide_int nonzero_bits = wide_int::from (bits[i]->mask, prec, UNSIGNED)
 				  | wide_int::from (bits[i]->value, prec, sgn);
-	  set_nonzero_bits (ddef, nonzero_bits);
+	  set_known_zero_bits (ddef, nonzero_bits);
 	}
       else
 	{
diff --git a/gcc/match.pd b/gcc/match.pd
index 194ba8f5188..0f58f1ad2ae 100644
--- a/gcc/match.pd
+++ b/gcc/match.pd
@@ -1199,7 +1199,7 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
 (simplify
  (bit_and (bit_not SSA_NAME@0) INTEGER_CST@1)
  (if (INTEGRAL_TYPE_P (TREE_TYPE (@0))
-      && wi::bit_and_not (get_nonzero_bits (@0), wi::to_wide (@1)) == 0)
+      && wi::bit_and_not (get_known_zero_bits (@0), wi::to_wide (@1)) == 0)
   (bit_xor @0 @1)))
 
 /* For constants M and N, if M == (1LL << cst) - 1 && (N & M) == M,
@@ -1317,7 +1317,7 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
 (simplify
  (bit_and SSA_NAME@0 INTEGER_CST@1)
  (if (INTEGRAL_TYPE_P (TREE_TYPE (@0))
-      && wi::bit_and_not (get_nonzero_bits (@0), wi::to_wide (@1)) == 0)
+      && wi::bit_and_not (get_known_zero_bits (@0), wi::to_wide (@1)) == 0)
   @0))
 #endif
 
@@ -2286,7 +2286,7 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
   (if (TREE_INT_CST_LOW (@1) & 1)
    { constant_boolean_node (cmp == NE_EXPR, type); })))
 
-/* Arguments on which one can call get_nonzero_bits to get the bits
+/* Arguments on which one can call get_known_zero_bits to get the bits
    possibly set.  */
 (match with_possible_nonzero_bits
  INTEGER_CST@0)
@@ -2300,7 +2300,7 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
  (bit_and:c with_possible_nonzero_bits@0 @2))
 
 /* Same for bits that are known to be set, but we do not have
-   an equivalent to get_nonzero_bits yet.  */
+   an equivalent to get_known_zero_bits yet.  */
 (match (with_certain_nonzero_bits2 @0)
  INTEGER_CST@0)
 (match (with_certain_nonzero_bits2 @0)
@@ -2310,7 +2310,7 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
 (for cmp (eq ne)
  (simplify
   (cmp:c (with_possible_nonzero_bits2 @0) (with_certain_nonzero_bits2 @1))
-  (if (wi::bit_and_not (wi::to_wide (@1), get_nonzero_bits (@0)) != 0)
+  (if (wi::bit_and_not (wi::to_wide (@1), get_known_zero_bits (@0)) != 0)
    { constant_boolean_node (cmp == NE_EXPR, type); })))
 
 /* ((X inner_op C0) outer_op C1)
@@ -2336,7 +2336,7 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
     wide_int cst_emit;
 
     if (TREE_CODE (@2) == SSA_NAME)
-      zero_mask_not = get_nonzero_bits (@2);
+      zero_mask_not = get_known_zero_bits (@2);
     else
       fail = true;
 
@@ -3562,7 +3562,7 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
       int width = ceil_log2 (element_precision (TREE_TYPE (@0)));
       int prec = TYPE_PRECISION (TREE_TYPE (@1));
      }
-     (if ((get_nonzero_bits (@1) & wi::mask (width, false, prec)) == 0)
+     (if ((get_known_zero_bits (@1) & wi::mask (width, false, prec)) == 0)
       @0)))))
 #endif
 
diff --git a/gcc/range-op.cc b/gcc/range-op.cc
index 49ee7be3d3b..7e5b3ad6aad 100644
--- a/gcc/range-op.cc
+++ b/gcc/range-op.cc
@@ -804,8 +804,8 @@ operator_lt::fold_range (irange &r, tree type,
     r = range_true (type);
   else if (!wi::lt_p (op1.lower_bound (), op2.upper_bound (), sign))
     r = range_false (type);
-  // Use nonzero bits to determine if < 0 is false.
-  else if (op2.zero_p () && !wi::neg_p (op1.get_nonzero_bits (), sign))
+  // Use known-zero bits to determine if < 0 is false.
+  else if (op2.zero_p () && !wi::neg_p (op1.get_known_zero_bits (), sign))
     r = range_false (type);
   else
     r = range_true_and_false (type);
@@ -2552,16 +2552,16 @@ operator_cast::fold_range (irange &r, tree type ATTRIBUTE_UNUSED,
 	return true;
     }
 
-  // Update the nonzero mask.  Truncating casts are problematic unless
+  // Update the known-zero mask.  Truncating casts are problematic unless
   // the conversion fits in the resulting outer type.
-  wide_int nz = inner.get_nonzero_bits ();
+  wide_int nz = inner.get_known_zero_bits ();
   if (truncating_cast_p (inner, outer)
       && wi::rshift (nz, wi::uhwi (TYPE_PRECISION (outer.type ()),
 				   TYPE_PRECISION (inner.type ())),
 		     TYPE_SIGN (inner.type ())) != 0)
     return true;
   nz = wide_int::from (nz, TYPE_PRECISION (type), TYPE_SIGN (inner.type ()));
-  r.set_nonzero_bits (nz);
+  r.set_known_zero_bits (nz);
 
   return true;
 }
@@ -2794,8 +2794,8 @@ operator_bitwise_and::fold_range (irange &r, tree type,
   if (range_operator::fold_range (r, type, lh, rh))
     {
       if (!lh.undefined_p () && !rh.undefined_p ())
-	r.set_nonzero_bits (wi::bit_and (lh.get_nonzero_bits (),
-					 rh.get_nonzero_bits ()));
+	r.set_known_zero_bits (wi::bit_and (lh.get_known_zero_bits (),
+					 rh.get_known_zero_bits ()));
       return true;
     }
   return false;
@@ -2805,7 +2805,7 @@ operator_bitwise_and::fold_range (irange &r, tree type,
 // Optimize BIT_AND_EXPR, BIT_IOR_EXPR and BIT_XOR_EXPR of signed types
 // by considering the number of leading redundant sign bit copies.
 // clrsb (X op Y) = min (clrsb (X), clrsb (Y)), so for example
-// [-1, 0] op [-1, 0] is [-1, 0] (where nonzero_bits doesn't help).
+// [-1, 0] op [-1, 0] is [-1, 0] (where known-zero bits doesn't help).
 static bool
 wi_optimize_signed_bitwise_op (irange &r, tree type,
 			       const wide_int &lh_lb, const wide_int &lh_ub,
@@ -3046,7 +3046,7 @@ operator_bitwise_and::wi_fold (irange &r, tree type,
 }
 
 static void
-set_nonzero_range_from_mask (irange &r, tree type, const irange &lhs)
+set_known_zero_range_from_mask (irange &r, tree type, const irange &lhs)
 {
   if (!lhs.contains_p (build_zero_cst (type)))
     r = range_nonzero (type);
@@ -3064,7 +3064,7 @@ operator_bitwise_and::simple_op1_range_solver (irange &r, tree type,
 {
   if (!op2.singleton_p ())
     {
-      set_nonzero_range_from_mask (r, type, lhs);
+      set_known_zero_range_from_mask (r, type, lhs);
       return;
     }
   unsigned int nprec = TYPE_PRECISION (type);
@@ -3157,14 +3157,14 @@ operator_bitwise_and::op1_range (irange &r, tree type,
       r.union_ (res);
     }
   if (r.undefined_p ())
-    set_nonzero_range_from_mask (r, type, lhs);
+    set_known_zero_range_from_mask (r, type, lhs);
 
   // For 0 = op1 & MASK, op1 is ~MASK.
   if (lhs.zero_p () && op2.singleton_p ())
     {
-      wide_int nz = wi::bit_not (op2.get_nonzero_bits ());
+      wide_int nz = wi::bit_not (op2.get_known_zero_bits ());
       int_range<2> tmp (type);
-      tmp.set_nonzero_bits (nz);
+      tmp.set_known_zero_bits (nz);
       r.intersect (tmp);
     }
   return true;
@@ -4851,7 +4851,7 @@ range_op_bitwise_and_tests ()
     int_range<2> mask = int_range<2> (INT (7), INT (7));
     op_bitwise_and.op1_range (res, integer_type_node, zero, mask);
     wide_int inv = wi::shwi (~7U, TYPE_PRECISION (integer_type_node));
-    ASSERT_TRUE (res.get_nonzero_bits () == inv);
+    ASSERT_TRUE (res.get_known_zero_bits () == inv);
   }
 
   // (NONZERO | X) is nonzero.
diff --git a/gcc/tree-data-ref.cc b/gcc/tree-data-ref.cc
index 978c3f002f7..1232c69174a 100644
--- a/gcc/tree-data-ref.cc
+++ b/gcc/tree-data-ref.cc
@@ -1027,7 +1027,7 @@ split_constant_offset (tree exp, tree *var, tree *off, value_range *exp_range,
 	  wide_int var_min = wi::to_wide (vr.min ());
 	  wide_int var_max = wi::to_wide (vr.max ());
 	  value_range_kind vr_kind = vr.kind ();
-	  wide_int var_nonzero = get_nonzero_bits (exp);
+	  wide_int var_nonzero = get_known_zero_bits (exp);
 	  vr_kind = intersect_range_with_nonzero_bits (vr_kind,
 						       &var_min, &var_max,
 						       var_nonzero,
diff --git a/gcc/tree-ssa-ccp.cc b/gcc/tree-ssa-ccp.cc
index 9778e776cf2..94528f430d3 100644
--- a/gcc/tree-ssa-ccp.cc
+++ b/gcc/tree-ssa-ccp.cc
@@ -297,7 +297,7 @@ get_default_value (tree var)
 	  val.mask = -1;
 	  if (flag_tree_bit_ccp)
 	    {
-	      wide_int nonzero_bits = get_nonzero_bits (var);
+	      wide_int nonzero_bits = get_known_zero_bits (var);
 	      tree value;
 	      widest_int mask;
 
@@ -1013,8 +1013,8 @@ ccp_finalize (bool nonzero_p)
 	  wide_int nonzero_bits
 	    = (wide_int::from (val->mask, precision, UNSIGNED)
 	       | wi::to_wide (val->value));
-	  nonzero_bits &= get_nonzero_bits (name);
-	  set_nonzero_bits (name, nonzero_bits);
+	  nonzero_bits &= get_known_zero_bits (name);
+	  set_known_zero_bits (name, nonzero_bits);
 	}
     }
 
@@ -2438,7 +2438,7 @@ evaluate_stmt (gimple *stmt)
       && TREE_CODE (gimple_get_lhs (stmt)) == SSA_NAME)
     {
       tree lhs = gimple_get_lhs (stmt);
-      wide_int nonzero_bits = get_nonzero_bits (lhs);
+      wide_int nonzero_bits = get_known_zero_bits (lhs);
       if (nonzero_bits != -1)
 	{
 	  if (!is_constant)
diff --git a/gcc/tree-ssa-dom.cc b/gcc/tree-ssa-dom.cc
index c7f095d79fc..b9b218f663a 100644
--- a/gcc/tree-ssa-dom.cc
+++ b/gcc/tree-ssa-dom.cc
@@ -1380,7 +1380,7 @@ dom_opt_dom_walker::set_global_ranges_from_unreachable_edges (basic_block bb)
 	    && !r.undefined_p ())
 	  {
 	    set_range_info (name, r);
-	    maybe_set_nonzero_bits (pred_e, name);
+	    maybe_set_known_zero_bits (pred_e, name);
 	  }
       }
 }
diff --git a/gcc/tree-ssa-reassoc.cc b/gcc/tree-ssa-reassoc.cc
index b39c3c882c4..407a3b7ee1d 100644
--- a/gcc/tree-ssa-reassoc.cc
+++ b/gcc/tree-ssa-reassoc.cc
@@ -3858,7 +3858,7 @@ optimize_range_tests_var_bound (enum tree_code opcode, int first, int length,
       /* maybe_optimize_range_tests allows statements without side-effects
 	 in the basic blocks as long as they are consumed in the same bb.
 	 Make sure rhs2's def stmt is not among them, otherwise we can't
-	 use safely get_nonzero_bits on it.  E.g. in:
+	 use safely get_known_zero_bits on it.  E.g. in:
 	  # RANGE [-83, 1] NONZERO 173
 	  # k_32 = PHI <k_47(13), k_12(9)>
 	 ...
@@ -3925,7 +3925,7 @@ optimize_range_tests_var_bound (enum tree_code opcode, int first, int length,
       if (rhs2 == NULL_TREE)
 	continue;
 
-      wide_int nz = get_nonzero_bits (rhs2);
+      wide_int nz = get_known_zero_bits (rhs2);
       if (wi::neg_p (nz))
 	continue;
 
diff --git a/gcc/tree-ssanames.cc b/gcc/tree-ssanames.cc
index 5c5d0e346c4..a140a194024 100644
--- a/gcc/tree-ssanames.cc
+++ b/gcc/tree-ssanames.cc
@@ -456,23 +456,23 @@ set_ptr_nonnull (tree name)
   pi->pt.null = 0;
 }
 
-/* Update the non-zero bits bitmask of NAME.  */
+/* Update the known-zero bits bitmask of NAME.  */
 
 void
-set_nonzero_bits (tree name, const wide_int_ref &mask)
+set_known_zero_bits (tree name, const wide_int_ref &mask)
 {
   gcc_assert (!POINTER_TYPE_P (TREE_TYPE (name)));
 
   int_range<2> r (TREE_TYPE (name));
-  r.set_nonzero_bits (mask);
+  r.set_known_zero_bits (mask);
   set_range_info (name, r);
 }
 
-/* Return a widest_int with potentially non-zero bits in SSA_NAME
+/* Return a widest_int with potentially known-zero bits in SSA_NAME
    NAME, the constant for INTEGER_CST, or -1 if unknown.  */
 
 wide_int
-get_nonzero_bits (const_tree name)
+get_known_zero_bits (const_tree name)
 {
   if (TREE_CODE (name) == INTEGER_CST)
     return wi::to_wide (name);
@@ -497,7 +497,7 @@ get_nonzero_bits (const_tree name)
      through vrange_storage.  */
   irange_storage_slot *ri
     = static_cast <irange_storage_slot *> (SSA_NAME_RANGE_INFO (name));
-  return ri->get_nonzero_bits ();
+  return ri->get_known_zero_bits ();
 }
 
 /* Return TRUE is OP, an SSA_NAME has a range of values [0..1], false
@@ -534,7 +534,7 @@ ssa_name_has_boolean_range (tree op)
       if (get_range_query (cfun)->range_of_expr (r, op) && r == onezero)
 	return true;
 
-      if (wi::eq_p (get_nonzero_bits (op), 1))
+      if (wi::eq_p (get_known_zero_bits (op), 1))
 	return true;
     }
 
diff --git a/gcc/tree-ssanames.h b/gcc/tree-ssanames.h
index ce10af9670a..f9cf6938269 100644
--- a/gcc/tree-ssanames.h
+++ b/gcc/tree-ssanames.h
@@ -58,8 +58,8 @@ struct GTY(()) ptr_info_def
 
 /* Sets the value range to SSA.  */
 extern bool set_range_info (tree, const vrange &);
-extern void set_nonzero_bits (tree, const wide_int_ref &);
-extern wide_int get_nonzero_bits (const_tree);
+extern void set_known_zero_bits (tree, const wide_int_ref &);
+extern wide_int get_known_zero_bits (const_tree);
 extern bool ssa_name_has_boolean_range (tree);
 extern void init_ssanames (struct function *, int);
 extern void fini_ssanames (struct function *);
diff --git a/gcc/tree-vect-patterns.cc b/gcc/tree-vect-patterns.cc
index 777ba2f5903..54776003af3 100644
--- a/gcc/tree-vect-patterns.cc
+++ b/gcc/tree-vect-patterns.cc
@@ -71,7 +71,7 @@ vect_get_range_info (tree var, wide_int *min_value, wide_int *max_value)
   *min_value = wi::to_wide (vr.min ());
   *max_value = wi::to_wide (vr.max ());
   value_range_kind vr_type = vr.kind ();
-  wide_int nonzero = get_nonzero_bits (var);
+  wide_int nonzero = get_known_zero_bits (var);
   signop sgn = TYPE_SIGN (TREE_TYPE (var));
   if (intersect_range_with_nonzero_bits (vr_type, min_value, max_value,
 					 nonzero, sgn) == VR_RANGE)
diff --git a/gcc/tree-vrp.cc b/gcc/tree-vrp.cc
index e5a292bb875..2b81a3dd168 100644
--- a/gcc/tree-vrp.cc
+++ b/gcc/tree-vrp.cc
@@ -2242,7 +2242,7 @@ register_edge_assert_for (tree name, edge e,
    from the non-zero bitmask.  */
 
 void
-maybe_set_nonzero_bits (edge e, tree var)
+maybe_set_known_zero_bits (edge e, tree var)
 {
   basic_block cond_bb = e->src;
   gimple *stmt = last_stmt (cond_bb);
@@ -2276,7 +2276,7 @@ maybe_set_nonzero_bits (edge e, tree var)
 	return;
     }
   cst = gimple_assign_rhs2 (stmt);
-  set_nonzero_bits (var, wi::bit_and_not (get_nonzero_bits (var),
+  set_known_zero_bits (var, wi::bit_and_not (get_known_zero_bits (var),
 					  wi::to_wide (cst)));
 }
 
@@ -3754,7 +3754,7 @@ vrp_asserts::remove_range_assertions ()
 			SSA_NAME_RANGE_INFO (var) = NULL;
 		      }
 		    duplicate_ssa_name_range_info (var, lhs);
-		    maybe_set_nonzero_bits (single_pred_edge (bb), var);
+		    maybe_set_known_zero_bits (single_pred_edge (bb), var);
 		  }
 	      }
 
diff --git a/gcc/tree-vrp.h b/gcc/tree-vrp.h
index b8644e9d0a7..1cfed8ea52c 100644
--- a/gcc/tree-vrp.h
+++ b/gcc/tree-vrp.h
@@ -61,7 +61,7 @@ extern tree find_case_label_range (gswitch *, const irange *vr);
 extern bool find_case_label_index (gswitch *, size_t, tree, size_t *);
 extern bool overflow_comparison_p (tree_code, tree, tree, bool, tree *);
 extern tree get_single_symbol (tree, bool *, tree *);
-extern void maybe_set_nonzero_bits (edge, tree);
+extern void maybe_set_known_zero_bits (edge, tree);
 extern wide_int masked_increment (const wide_int &val_in, const wide_int &mask,
 				  const wide_int &sgnbit, unsigned int prec);
 
diff --git a/gcc/tree.cc b/gcc/tree.cc
index 81a6ceaf181..921a9881b1e 100644
--- a/gcc/tree.cc
+++ b/gcc/tree.cc
@@ -3025,7 +3025,7 @@ tree_ctz (const_tree expr)
       ret1 = wi::ctz (wi::to_wide (expr));
       return MIN (ret1, prec);
     case SSA_NAME:
-      ret1 = wi::ctz (get_nonzero_bits (expr));
+      ret1 = wi::ctz (get_known_zero_bits (expr));
       return MIN (ret1, prec);
     case PLUS_EXPR:
     case MINUS_EXPR:
diff --git a/gcc/value-range-pretty-print.cc b/gcc/value-range-pretty-print.cc
index 3a3b4b44cbd..0f95ad1e956 100644
--- a/gcc/value-range-pretty-print.cc
+++ b/gcc/value-range-pretty-print.cc
@@ -107,7 +107,7 @@ vrange_printer::print_irange_bound (const wide_int &bound, tree type) const
 void
 vrange_printer::print_irange_bitmasks (const irange &r) const
 {
-  wide_int nz = r.get_nonzero_bits ();
+  wide_int nz = r.get_known_zero_bits ();
   if (nz == -1)
     return;
 
diff --git a/gcc/value-range-storage.cc b/gcc/value-range-storage.cc
index 6e054622830..74aaa929c4c 100644
--- a/gcc/value-range-storage.cc
+++ b/gcc/value-range-storage.cc
@@ -150,7 +150,7 @@ irange_storage_slot::set_irange (const irange &r)
 {
   gcc_checking_assert (fits_p (r));
 
-  m_ints[0] = r.get_nonzero_bits ();
+  m_ints[0] = r.get_known_zero_bits ();
 
   unsigned pairs = r.num_pairs ();
   for (unsigned i = 0; i < pairs; ++i)
@@ -174,7 +174,7 @@ irange_storage_slot::get_irange (irange &r, tree type) const
       int_range<2> tmp (type, m_ints[i], m_ints[i + 1]);
       r.union_ (tmp);
     }
-  r.set_nonzero_bits (get_nonzero_bits ());
+  r.set_known_zero_bits (get_known_zero_bits ());
 }
 
 // Return the size in bytes to allocate a slot that can hold R.
@@ -220,7 +220,7 @@ irange_storage_slot::dump () const
       m_ints[i + 1].dump ();
     }
   fprintf (stderr, "NONZERO ");
-  wide_int nz = get_nonzero_bits ();
+  wide_int nz = get_known_zero_bits ();
   nz.dump ();
 }
 
diff --git a/gcc/value-range-storage.h b/gcc/value-range-storage.h
index 0cf95ebf7c1..cfa15b48884 100644
--- a/gcc/value-range-storage.h
+++ b/gcc/value-range-storage.h
@@ -70,7 +70,7 @@ public:
   static irange_storage_slot *alloc_slot (vrange_allocator &, const irange &r);
   void set_irange (const irange &r);
   void get_irange (irange &r, tree type) const;
-  wide_int get_nonzero_bits () const { return m_ints[0]; }
+  wide_int get_known_zero_bits () const { return m_ints[0]; }
   bool fits_p (const irange &r) const;
   static size_t size (const irange &r);
   void dump () const;
diff --git a/gcc/value-range.cc b/gcc/value-range.cc
index bcda4987307..05c43485cef 100644
--- a/gcc/value-range.cc
+++ b/gcc/value-range.cc
@@ -837,7 +837,7 @@ irange::operator= (const irange &src)
 
   m_num_ranges = lim;
   m_kind = src.m_kind;
-  m_nonzero_mask = src.m_nonzero_mask;
+  m_known_zero_mask = src.m_known_zero_mask;
   if (flag_checking)
     verify_range ();
   return *this;
@@ -894,7 +894,7 @@ irange::copy_to_legacy (const irange &src)
       m_base[0] = src.m_base[0];
       m_base[1] = src.m_base[1];
       m_kind = src.m_kind;
-      m_nonzero_mask = src.m_nonzero_mask;
+      m_known_zero_mask = src.m_known_zero_mask;
       return;
     }
   // Copy multi-range to legacy.
@@ -959,7 +959,7 @@ irange::irange_set (tree min, tree max)
   m_base[1] = max;
   m_num_ranges = 1;
   m_kind = VR_RANGE;
-  m_nonzero_mask = NULL;
+  m_known_zero_mask = NULL;
   normalize_kind ();
 
   if (flag_checking)
@@ -1033,7 +1033,7 @@ irange::irange_set_anti_range (tree min, tree max)
     }
 
   m_kind = VR_RANGE;
-  m_nonzero_mask = NULL;
+  m_known_zero_mask = NULL;
   normalize_kind ();
 
   if (flag_checking)
@@ -1090,7 +1090,7 @@ irange::set (tree min, tree max, value_range_kind kind)
       m_base[0] = min;
       m_base[1] = max;
       m_num_ranges = 1;
-      m_nonzero_mask = NULL;
+      m_known_zero_mask = NULL;
       return;
     }
 
@@ -1140,7 +1140,7 @@ irange::set (tree min, tree max, value_range_kind kind)
   m_base[0] = min;
   m_base[1] = max;
   m_num_ranges = 1;
-  m_nonzero_mask = NULL;
+  m_known_zero_mask = NULL;
   normalize_kind ();
   if (flag_checking)
     verify_range ();
@@ -1159,8 +1159,8 @@ irange::verify_range ()
     }
   if (m_kind == VR_VARYING)
     {
-      gcc_checking_assert (!m_nonzero_mask
-			   || wi::to_wide (m_nonzero_mask) == -1);
+      gcc_checking_assert (!m_known_zero_mask
+			   || wi::to_wide (m_known_zero_mask) == -1);
       gcc_checking_assert (m_num_ranges == 1);
       gcc_checking_assert (varying_compatible_p ());
       return;
@@ -1255,7 +1255,7 @@ irange::legacy_equal_p (const irange &other) const
 			       other.tree_lower_bound (0))
 	  && vrp_operand_equal_p (tree_upper_bound (0),
 				  other.tree_upper_bound (0))
-	  && get_nonzero_bits () == other.get_nonzero_bits ());
+	  && get_known_zero_bits () == other.get_known_zero_bits ());
 }
 
 bool
@@ -1290,7 +1290,7 @@ irange::operator== (const irange &other) const
 	  || !operand_equal_p (ub, ub_other, 0))
 	return false;
     }
-  return get_nonzero_bits () == other.get_nonzero_bits ();
+  return get_known_zero_bits () == other.get_known_zero_bits ();
 }
 
 /* Return TRUE if this is a symbolic range.  */
@@ -1433,11 +1433,11 @@ irange::contains_p (tree cst) const
 
   gcc_checking_assert (TREE_CODE (cst) == INTEGER_CST);
 
-  // See if we can exclude CST based on the nonzero bits.
-  if (m_nonzero_mask)
+  // See if we can exclude CST based on the known-zero bits.
+  if (m_known_zero_mask)
     {
       wide_int cstw = wi::to_wide (cst);
-      if (cstw != 0 && wi::bit_and (wi::to_wide (m_nonzero_mask), cstw) == 0)
+      if (cstw != 0 && wi::bit_and (wi::to_wide (m_known_zero_mask), cstw) == 0)
 	return false;
     }
 
@@ -2335,7 +2335,7 @@ irange::irange_single_pair_union (const irange &r)
     {
       // If current upper bound is new upper bound, we're done.
       if (wi::le_p (wi::to_wide (r.m_base[1]), wi::to_wide (m_base[1]), sign))
-	return union_nonzero_bits (r);
+	return union_known_zero_bits (r);
       // Otherwise R has the new upper bound.
       // Check for overlap/touching ranges, or single target range.
       if (m_max_ranges == 1
@@ -2348,7 +2348,7 @@ irange::irange_single_pair_union (const irange &r)
 	  m_base[3] = r.m_base[1];
 	  m_num_ranges = 2;
 	}
-      union_nonzero_bits (r);
+      union_known_zero_bits (r);
       return true;
     }
 
@@ -2371,7 +2371,7 @@ irange::irange_single_pair_union (const irange &r)
       m_base[3] = m_base[1];
       m_base[1] = r.m_base[1];
     }
-  union_nonzero_bits (r);
+  union_known_zero_bits (r);
   return true;
 }
 
@@ -2408,7 +2408,7 @@ irange::irange_union (const irange &r)
 
   // If this ranges fully contains R, then we need do nothing.
   if (irange_contains_p (r))
-    return union_nonzero_bits (r);
+    return union_known_zero_bits (r);
 
   // Do not worry about merging and such by reserving twice as many
   // pairs as needed, and then simply sort the 2 ranges into this
@@ -2496,7 +2496,7 @@ irange::irange_union (const irange &r)
   m_num_ranges = i / 2;
 
   m_kind = VR_RANGE;
-  union_nonzero_bits (r);
+  union_known_zero_bits (r);
   return true;
 }
 
@@ -2576,13 +2576,13 @@ irange::irange_intersect (const irange &r)
       if (undefined_p ())
 	return true;
 
-      res |= intersect_nonzero_bits (r);
+      res |= intersect_known_zero_bits (r);
       return res;
     }
 
   // If R fully contains this, then intersection will change nothing.
   if (r.irange_contains_p (*this))
-    return intersect_nonzero_bits (r);
+    return intersect_known_zero_bits (r);
 
   signop sign = TYPE_SIGN (TREE_TYPE(m_base[0]));
   unsigned bld_pair = 0;
@@ -2658,7 +2658,7 @@ irange::irange_intersect (const irange &r)
     }
 
   m_kind = VR_RANGE;
-  intersect_nonzero_bits (r);
+  intersect_known_zero_bits (r);
   return true;
 }
 
@@ -2801,7 +2801,7 @@ irange::invert ()
   signop sign = TYPE_SIGN (ttype);
   wide_int type_min = wi::min_value (prec, sign);
   wide_int type_max = wi::max_value (prec, sign);
-  m_nonzero_mask = NULL;
+  m_known_zero_mask = NULL;
   if (m_num_ranges == m_max_ranges
       && lower_bound () != type_min
       && upper_bound () != type_max)
@@ -2876,10 +2876,10 @@ irange::invert ()
     verify_range ();
 }
 
-// Return the nonzero bits inherent in the range.
+// Return the known-zero bits inherent in the range.
 
 wide_int
-irange::get_nonzero_bits_from_range () const
+irange::get_known_zero_bits_from_range () const
 {
   // For legacy symbolics.
   if (!constant_p ())
@@ -2900,25 +2900,25 @@ irange::get_nonzero_bits_from_range () const
 // so and return TRUE.
 
 bool
-irange::set_range_from_nonzero_bits ()
+irange::set_range_from_known_zero_bits ()
 {
   gcc_checking_assert (!undefined_p ());
-  if (!m_nonzero_mask)
+  if (!m_known_zero_mask)
     return false;
-  unsigned popcount = wi::popcount (wi::to_wide (m_nonzero_mask));
+  unsigned popcount = wi::popcount (wi::to_wide (m_known_zero_mask));
 
   // If we have only one bit set in the mask, we can figure out the
   // range immediately.
   if (popcount == 1)
     {
       // Make sure we don't pessimize the range.
-      if (!contains_p (m_nonzero_mask))
+      if (!contains_p (m_known_zero_mask))
 	return false;
 
       bool has_zero = contains_p (build_zero_cst (type ()));
-      tree nz = m_nonzero_mask;
+      tree nz = m_known_zero_mask;
       set (nz, nz);
-      m_nonzero_mask = nz;
+      m_known_zero_mask = nz;
       if (has_zero)
 	{
 	  int_range<2> zero;
@@ -2936,14 +2936,14 @@ irange::set_range_from_nonzero_bits ()
 }
 
 void
-irange::set_nonzero_bits (const wide_int_ref &bits)
+irange::set_known_zero_bits (const wide_int_ref &bits)
 {
   gcc_checking_assert (!undefined_p ());
   unsigned prec = TYPE_PRECISION (type ());
 
   if (bits == -1)
     {
-      m_nonzero_mask = NULL;
+      m_known_zero_mask = NULL;
       normalize_kind ();
       if (flag_checking)
 	verify_range ();
@@ -2955,8 +2955,8 @@ irange::set_nonzero_bits (const wide_int_ref &bits)
     m_kind = VR_RANGE;
 
   wide_int nz = wide_int::from (bits, prec, TYPE_SIGN (type ()));
-  m_nonzero_mask = wide_int_to_tree (type (), nz);
-  if (set_range_from_nonzero_bits ())
+  m_known_zero_mask = wide_int_to_tree (type (), nz);
+  if (set_range_from_known_zero_bits ())
     return;
 
   normalize_kind ();
@@ -2964,11 +2964,11 @@ irange::set_nonzero_bits (const wide_int_ref &bits)
     verify_range ();
 }
 
-// Return the nonzero bitmask.  This will return the nonzero bits plus
-// the nonzero bits inherent in the range.
+// Return the nonzero bitmask.  This will return the known-zero bits plus
+// the known-zero bits inherent in the range.
 
 wide_int
-irange::get_nonzero_bits () const
+irange::get_known_zero_bits () const
 {
   gcc_checking_assert (!undefined_p ());
   // The nonzero mask inherent in the range is calculated on-demand.
@@ -2979,10 +2979,10 @@ irange::get_nonzero_bits () const
   // the mask precisely up to date at all times.  Instead, we default
   // to -1 and set it when explicitly requested.  However, this
   // function will always return the correct mask.
-  if (m_nonzero_mask)
-    return wi::to_wide (m_nonzero_mask) & get_nonzero_bits_from_range ();
+  if (m_known_zero_mask)
+    return wi::to_wide (m_known_zero_mask) & get_known_zero_bits_from_range ();
   else
-    return get_nonzero_bits_from_range ();
+    return get_known_zero_bits_from_range ();
 }
 
 // Convert tree mask to wide_int.  Returns -1 for NULL masks.
@@ -2996,15 +2996,15 @@ mask_to_wi (tree mask, tree type)
     return wi::shwi (-1, TYPE_PRECISION (type));
 }
 
-// Intersect the nonzero bits in R into THIS and normalize the range.
+// Intersect the known-zero bits in R into THIS and normalize the range.
 // Return TRUE if the intersection changed anything.
 
 bool
-irange::intersect_nonzero_bits (const irange &r)
+irange::intersect_known_zero_bits (const irange &r)
 {
   gcc_checking_assert (!undefined_p () && !r.undefined_p ());
 
-  if (!m_nonzero_mask && !r.m_nonzero_mask)
+  if (!m_known_zero_mask && !r.m_known_zero_mask)
     {
       normalize_kind ();
       if (flag_checking)
@@ -3014,11 +3014,11 @@ irange::intersect_nonzero_bits (const irange &r)
 
   bool changed = false;
   tree t = type ();
-  if (mask_to_wi (m_nonzero_mask, t) != mask_to_wi (r.m_nonzero_mask, t))
+  if (mask_to_wi (m_known_zero_mask, t) != mask_to_wi (r.m_known_zero_mask, t))
     {
-      wide_int nz = get_nonzero_bits () & r.get_nonzero_bits ();
-      m_nonzero_mask = wide_int_to_tree (t, nz);
-      if (set_range_from_nonzero_bits ())
+      wide_int nz = get_known_zero_bits () & r.get_known_zero_bits ();
+      m_known_zero_mask = wide_int_to_tree (t, nz);
+      if (set_range_from_known_zero_bits ())
 	return true;
       changed = true;
     }
@@ -3028,15 +3028,15 @@ irange::intersect_nonzero_bits (const irange &r)
   return changed;
 }
 
-// Union the nonzero bits in R into THIS and normalize the range.
+// Union the known-zero bits in R into THIS and normalize the range.
 // Return TRUE if the union changed anything.
 
 bool
-irange::union_nonzero_bits (const irange &r)
+irange::union_known_zero_bits (const irange &r)
 {
   gcc_checking_assert (!undefined_p () && !r.undefined_p ());
 
-  if (!m_nonzero_mask && !r.m_nonzero_mask)
+  if (!m_known_zero_mask && !r.m_known_zero_mask)
     {
       normalize_kind ();
       if (flag_checking)
@@ -3046,14 +3046,14 @@ irange::union_nonzero_bits (const irange &r)
 
   bool changed = false;
   tree t = type ();
-  if (mask_to_wi (m_nonzero_mask, t) != mask_to_wi (r.m_nonzero_mask, t))
+  if (mask_to_wi (m_known_zero_mask, t) != mask_to_wi (r.m_known_zero_mask, t))
     {
-      wide_int nz = get_nonzero_bits () | r.get_nonzero_bits ();
-      m_nonzero_mask = wide_int_to_tree (t, nz);
-      // No need to call set_range_from_nonzero_bits, because we'll
+      wide_int nz = get_known_zero_bits () | r.get_known_zero_bits ();
+      m_known_zero_mask = wide_int_to_tree (t, nz);
+      // No need to call set_range_from_known_zero_bits, because we'll
       // never narrow the range.  Besides, it would cause endless
       // recursion because of the union_ in
-      // set_range_from_nonzero_bits.
+      // set_range_from_known_zero_bits.
       changed = true;
     }
   normalize_kind ();
@@ -3626,58 +3626,58 @@ range_tests_nonzero_bits ()
 {
   int_range<2> r0, r1;
 
-  // Adding nonzero bits to a varying drops the varying.
+  // Adding known-zero bits to a varying drops the varying.
   r0.set_varying (integer_type_node);
-  r0.set_nonzero_bits (255);
+  r0.set_known_zero_bits (255);
   ASSERT_TRUE (!r0.varying_p ());
-  // Dropping the nonzero bits brings us back to varying.
-  r0.set_nonzero_bits (-1);
+  // Dropping the known-zero bits brings us back to varying.
+  r0.set_known_zero_bits (-1);
   ASSERT_TRUE (r0.varying_p ());
 
-  // Test contains_p with nonzero bits.
+  // Test contains_p with known-zero bits.
   r0.set_zero (integer_type_node);
   ASSERT_TRUE (r0.contains_p (INT (0)));
   ASSERT_FALSE (r0.contains_p (INT (1)));
-  r0.set_nonzero_bits (0xfe);
+  r0.set_known_zero_bits (0xfe);
   ASSERT_FALSE (r0.contains_p (INT (0x100)));
   ASSERT_FALSE (r0.contains_p (INT (0x3)));
 
-  // Union of nonzero bits.
+  // Union of known-zero bits.
   r0.set_varying (integer_type_node);
-  r0.set_nonzero_bits (0xf0);
+  r0.set_known_zero_bits (0xf0);
   r1.set_varying (integer_type_node);
-  r1.set_nonzero_bits (0xf);
+  r1.set_known_zero_bits (0xf);
   r0.union_ (r1);
-  ASSERT_TRUE (r0.get_nonzero_bits () == 0xff);
+  ASSERT_TRUE (r0.get_known_zero_bits () == 0xff);
 
-  // Intersect of nonzero bits.
+  // Intersect of known-zero bits.
   r0.set (INT (0), INT (255));
-  r0.set_nonzero_bits (0xfe);
+  r0.set_known_zero_bits (0xfe);
   r1.set_varying (integer_type_node);
-  r1.set_nonzero_bits (0xf0);
+  r1.set_known_zero_bits (0xf0);
   r0.intersect (r1);
-  ASSERT_TRUE (r0.get_nonzero_bits () == 0xf0);
+  ASSERT_TRUE (r0.get_known_zero_bits () == 0xf0);
 
-  // Intersect where the mask of nonzero bits is implicit from the range.
+  // Intersect where the mask of known-zero bits is implicit from the range.
   r0.set_varying (integer_type_node);
   r1.set (INT (0), INT (255));
   r0.intersect (r1);
-  ASSERT_TRUE (r0.get_nonzero_bits () == 0xff);
+  ASSERT_TRUE (r0.get_known_zero_bits () == 0xff);
 
   // The union of a mask of 0xff..ffff00 with a mask of 0xff spans the
   // entire domain, and makes the range a varying.
   r0.set_varying (integer_type_node);
   wide_int x = wi::shwi (0xff, TYPE_PRECISION (integer_type_node));
   x = wi::bit_not (x);
-  r0.set_nonzero_bits (x); 	// 0xff..ff00
+  r0.set_known_zero_bits (x); 	// 0xff..ff00
   r1.set_varying (integer_type_node);
-  r1.set_nonzero_bits (0xff);
+  r1.set_known_zero_bits (0xff);
   r0.union_ (r1);
   ASSERT_TRUE (r0.varying_p ());
 
   // Test that setting a nonzero bit of 1 does not pessimize the range.
   r0.set_zero (integer_type_node);
-  r0.set_nonzero_bits (1);
+  r0.set_known_zero_bits (1);
   ASSERT_TRUE (r0.zero_p ());
 }
 
diff --git a/gcc/value-range.h b/gcc/value-range.h
index b48542a68aa..444f357afdf 100644
--- a/gcc/value-range.h
+++ b/gcc/value-range.h
@@ -156,9 +156,9 @@ public:
   virtual bool fits_p (const vrange &r) const override;
   virtual void accept (const vrange_visitor &v) const override;
 
-  // Nonzero masks.
-  wide_int get_nonzero_bits () const;
-  void set_nonzero_bits (const wide_int_ref &bits);
+  // Known bit masks.
+  wide_int get_known_zero_bits () const;
+  void set_known_zero_bits (const wide_int_ref &bits);
 
   // Deprecated legacy public methods.
   tree min () const;				// DEPRECATED
@@ -207,15 +207,15 @@ private:
 
   void irange_set_1bit_anti_range (tree, tree);
   bool varying_compatible_p () const;
-  bool intersect_nonzero_bits (const irange &r);
-  bool union_nonzero_bits (const irange &r);
-  wide_int get_nonzero_bits_from_range () const;
-  bool set_range_from_nonzero_bits ();
+  bool intersect_known_zero_bits (const irange &r);
+  bool union_known_zero_bits (const irange &r);
+  wide_int get_known_zero_bits_from_range () const;
+  bool set_range_from_known_zero_bits ();
 
   bool intersect (const wide_int& lb, const wide_int& ub);
   unsigned char m_num_ranges;
   unsigned char m_max_ranges;
-  tree m_nonzero_mask;
+  tree m_known_zero_mask;
   tree *m_base;
 };
 
@@ -687,11 +687,11 @@ irange::varying_compatible_p () const
   if (INTEGRAL_TYPE_P (t))
     return (wi::to_wide (l) == wi::min_value (prec, sign)
 	    && wi::to_wide (u) == wi::max_value (prec, sign)
-	    && (!m_nonzero_mask || wi::to_wide (m_nonzero_mask) == -1));
+	    && (!m_known_zero_mask || wi::to_wide (m_known_zero_mask) == -1));
   if (POINTER_TYPE_P (t))
     return (wi::to_wide (l) == 0
 	    && wi::to_wide (u) == wi::max_value (prec, sign)
-	    && (!m_nonzero_mask || wi::to_wide (m_nonzero_mask) == -1));
+	    && (!m_known_zero_mask || wi::to_wide (m_known_zero_mask) == -1));
   return true;
 }
 
@@ -758,8 +758,8 @@ gt_ggc_mx (irange *x)
       gt_ggc_mx (x->m_base[i * 2]);
       gt_ggc_mx (x->m_base[i * 2 + 1]);
     }
-  if (x->m_nonzero_mask)
-    gt_ggc_mx (x->m_nonzero_mask);
+  if (x->m_known_zero_mask)
+    gt_ggc_mx (x->m_known_zero_mask);
 }
 
 inline void
@@ -770,8 +770,8 @@ gt_pch_nx (irange *x)
       gt_pch_nx (x->m_base[i * 2]);
       gt_pch_nx (x->m_base[i * 2 + 1]);
     }
-  if (x->m_nonzero_mask)
-    gt_pch_nx (x->m_nonzero_mask);
+  if (x->m_known_zero_mask)
+    gt_pch_nx (x->m_known_zero_mask);
 }
 
 inline void
@@ -782,8 +782,8 @@ gt_pch_nx (irange *x, gt_pointer_operator op, void *cookie)
       op (&x->m_base[i * 2], NULL, cookie);
       op (&x->m_base[i * 2 + 1], NULL, cookie);
     }
-  if (x->m_nonzero_mask)
-    op (&x->m_nonzero_mask, NULL, cookie);
+  if (x->m_known_zero_mask)
+    op (&x->m_known_zero_mask, NULL, cookie);
 }
 
 template<unsigned N>
@@ -878,7 +878,7 @@ irange::set_undefined ()
 {
   m_kind = VR_UNDEFINED;
   m_num_ranges = 0;
-  m_nonzero_mask = NULL;
+  m_known_zero_mask = NULL;
 }
 
 inline void
@@ -886,7 +886,7 @@ irange::set_varying (tree type)
 {
   m_kind = VR_VARYING;
   m_num_ranges = 1;
-  m_nonzero_mask = NULL;
+  m_known_zero_mask = NULL;
 
   if (INTEGRAL_TYPE_P (type))
     {
