From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-ed1-x531.google.com (mail-ed1-x531.google.com [IPv6:2a00:1450:4864:20::531]) by sourceware.org (Postfix) with ESMTPS id 06D143858412 for ; Mon, 24 Oct 2022 07:21:50 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 06D143858412 Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=gmail.com Received: by mail-ed1-x531.google.com with SMTP id r14so27832992edc.7 for ; Mon, 24 Oct 2022 00:21:49 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=cc:to:subject:message-id:date:from:in-reply-to:references :mime-version:from:to:cc:subject:date:message-id:reply-to; bh=wAGLyKJD1LN5TcP8UJHli9Ra4gVNRAzTwHaT1qvEf3U=; b=br2cb6LxITx39N2O3yyx9GlGwdvoW8mcJGbMsgdCGulL8BkQlFqTcqTtx+eM4uUwD3 yz9GKi0woPcjLmfD16Q4D9puV0q2JOX18OHbQ1OOmmdwh0WwF+/HTkQquz7/G3ApupVn 8fl1WZzu6cZk6DUhsbrc+RFBbjvoxU1YRfvSdUCQ1tuYkZaXZ9qeK0W8DzxA6YFFVJFS FZxKRJf0W1EeBAonlaSbWV4vs7EVWhouYWkg9ZqYnTsrcdL1E9BSZD6ZORdKYEHOXtiU tQIoSonmsbE1gtc2pGXYhEnYe5nAO2xJUZjHhaGyq+3MDZJaXCR/ltw2vrbgXQpkQuUR aNpg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=cc:to:subject:message-id:date:from:in-reply-to:references :mime-version:x-gm-message-state:from:to:cc:subject:date:message-id :reply-to; bh=wAGLyKJD1LN5TcP8UJHli9Ra4gVNRAzTwHaT1qvEf3U=; b=s74F4v0x92eZbEjgm3zRtY79pzPxun2OUTS3wlK3Rk926pgIFwo/1kAgczj526tVAT zIrqw/GaPx3a0j000TpzH2V0Nm7zPBsy9n7kubMeJWmaUb+IxVjVZFVYtBwwmbIYa/ws 8vZ76xHX7SDqykqHrc/tk2ZIFDXov7wdcHgfWY6WW3btQWrCpBOdFKuP8Hg+/qUVCXdU UXLa0DJULJwP5hiHJbpqn77IQO/+VPprcyZPrpS3Bc5rNJ72s29sXDq3tG6/4hIl2zS1 t0xwCgQIzgm7la63Z3ToXXTs+jtfAGuGTNZpCvRTIMjRx5AqfahRYdn9DNokcRnZHO+5 LcrQ== X-Gm-Message-State: ACrzQf03iR2NZPDJ+DCMYjTYarvSve0pFcu74mBldp1EM4LXYxRjqtk3 QXrWnfvEymJn0HbxbcFwfiqpUmCq1w1kU2OeUtU= X-Google-Smtp-Source: AMsMyM7TunY9cGxDFPWwpVaFRzfKkY9O69vFl39ywF1irpffa8rCrEY9nNJKgU2laQhLqJLsrF1fdTU1yQIXs2c8rB4= X-Received: by 2002:a17:907:7208:b0:78e:176e:e0c6 with SMTP id dr8-20020a170907720800b0078e176ee0c6mr26398777ejc.594.1666596108253; Mon, 24 Oct 2022 00:21:48 -0700 (PDT) MIME-Version: 1.0 References: <20221021131426.308205-1-aldyh@redhat.com> In-Reply-To: <20221021131426.308205-1-aldyh@redhat.com> From: Richard Biener Date: Mon, 24 Oct 2022 09:21:35 +0200 Message-ID: Subject: Re: [PATCH] Rename nonzero_bits to known_zero_bits. To: Aldy Hernandez Cc: GCC patches Content-Type: text/plain; charset="UTF-8" X-Spam-Status: No, score=-8.1 required=5.0 tests=BAYES_00,DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,FREEMAIL_FROM,GIT_PATCH_0,RCVD_IN_DNSWL_NONE,SPF_HELO_NONE,SPF_PASS,TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org List-Id: On Fri, Oct 21, 2022 at 3:15 PM Aldy Hernandez via Gcc-patches wrote: > > The name nonzero_bits is confusing. We're not tracking nonzero bits. > We're tracking known-zero bits, or at the worst we're tracking "maye > nonzero bits". But really, the only thing we're sure about in the > "nonzero" bits are the bits that are zero, which are known to be 0. > We're not tracking nonzero bits. > > I know we've been carrying around this name forever, but the fact that > both of the maintainers of the code *HATE* it, should be telling. > Also, we'd also like to track known-one bits in the irange, so it's > best to keep the nomenclature consistent. > > Andrew, are you ok with this naming, or would you prefer something > else? But it's the same as on RTL. And on release branches. But yes, it's maybe_nonzero_bits. Ideally we'd track known/unknown_bits (both zero and one) instead. bit-CCP already computes that but throws away the ones: unsigned int precision = TYPE_PRECISION (TREE_TYPE (val->value)); 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); so I think instead of renaming can you see what it takes to also record known set bits? (yeah, needs two masks instead of one in the storage) > gcc/ChangeLog: > > * asan.cc (handle_builtin_alloca): Rename *nonzero* to *known_zero*. > * fold-const.cc (expr_not_equal_to): Same. > (tree_nonzero_bits): Same. > * gimple-range-op.cc: Same. > * ipa-cp.cc (ipcp_bits_lattice::get_value_and_mask): Same. > * ipa-prop.cc (ipa_compute_jump_functions_for_edge): Same. > (ipcp_update_bits): Same. > * match.pd: Same. > * range-op.cc (operator_lt::fold_range): Same. > (operator_cast::fold_range): Same. > (operator_bitwise_and::fold_range): Same. > (set_nonzero_range_from_mask): Same. > (set_known_zero_range_from_mask): Same. > (operator_bitwise_and::simple_op1_range_solver): Same. > (operator_bitwise_and::op1_range): Same. > (range_op_cast_tests): Same. > (range_op_bitwise_and_tests): Same. > * tree-data-ref.cc (split_constant_offset): Same. > * tree-ssa-ccp.cc (get_default_value): Same. > (ccp_finalize): Same. > (evaluate_stmt): Same. > * tree-ssa-dom.cc > (dom_opt_dom_walker::set_global_ranges_from_unreachable_edges): Same. > * tree-ssa-reassoc.cc (optimize_range_tests_var_bound): Same. > * tree-ssanames.cc (set_nonzero_bits): Same. > (set_known_zero_bits): Same. > (get_nonzero_bits): Same. > (get_known_zero_bits): Same. > (ssa_name_has_boolean_range): Same. > * tree-ssanames.h (set_nonzero_bits): Same. > (get_nonzero_bits): Same. > (set_known_zero_bits): Same. > (get_known_zero_bits): Same. > * tree-vect-patterns.cc (vect_get_range_info): Same. > * tree-vrp.cc (maybe_set_nonzero_bits): Same. > (maybe_set_known_zero_bits): Same. > (vrp_asserts::remove_range_assertions): Same. > * tree-vrp.h (maybe_set_nonzero_bits): Same. > (maybe_set_known_zero_bits): Same. > * tree.cc (tree_ctz): Same. > * value-range-pretty-print.cc > (vrange_printer::print_irange_bitmasks): Same. > * value-range-storage.cc (irange_storage_slot::set_irange): Same. > (irange_storage_slot::get_irange): Same. > (irange_storage_slot::dump): Same. > * value-range-storage.h: Same. > * value-range.cc (irange::operator=): Same. > (irange::copy_to_legacy): Same. > (irange::irange_set): Same. > (irange::irange_set_anti_range): Same. > (irange::set): Same. > (irange::verify_range): Same. > (irange::legacy_equal_p): Same. > (irange::operator==): Same. > (irange::contains_p): Same. > (irange::irange_single_pair_union): Same. > (irange::irange_union): Same. > (irange::irange_intersect): Same. > (irange::invert): Same. > (irange::get_nonzero_bits_from_range): Same. > (irange::get_known_zero_bits_from_range): Same. > (irange::set_range_from_nonzero_bits): Same. > (irange::set_range_from_known_zero_bits): Same. > (irange::set_nonzero_bits): Same. > (irange::set_known_zero_bits): Same. > (irange::get_nonzero_bits): Same. > (irange::get_known_zero_bits): Same. > (irange::intersect_nonzero_bits): Same. > (irange::intersect_known_zero_bits): Same. > (irange::union_nonzero_bits): Same. > (irange::union_known_zero_bits): Same. > (range_tests_nonzero_bits): Same. > * value-range.h (irange::varying_compatible_p): Same. > (gt_ggc_mx): Same. > (gt_pch_nx): Same. > (irange::set_undefined): Same. > (irange::set_varying): Same. > --- > gcc/asan.cc | 2 +- > gcc/fold-const.cc | 4 +- > gcc/gimple-range-op.cc | 2 +- > gcc/ipa-cp.cc | 2 +- > gcc/ipa-prop.cc | 4 +- > gcc/match.pd | 14 +-- > gcc/range-op.cc | 28 +++--- > gcc/tree-data-ref.cc | 2 +- > gcc/tree-ssa-ccp.cc | 8 +- > gcc/tree-ssa-dom.cc | 2 +- > gcc/tree-ssa-reassoc.cc | 4 +- > gcc/tree-ssanames.cc | 14 +-- > gcc/tree-ssanames.h | 4 +- > gcc/tree-vect-patterns.cc | 2 +- > gcc/tree-vrp.cc | 6 +- > gcc/tree-vrp.h | 2 +- > gcc/tree.cc | 2 +- > gcc/value-range-pretty-print.cc | 2 +- > gcc/value-range-storage.cc | 6 +- > gcc/value-range-storage.h | 2 +- > gcc/value-range.cc | 148 ++++++++++++++++---------------- > gcc/value-range.h | 36 ++++---- > 22 files changed, 148 insertions(+), 148 deletions(-) > > 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 > ... > @@ -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 (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 > @@ -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)) > { > -- > 2.37.3 >