https://gcc.gnu.org/g:001042d29189eddcce8b06da0f579973774ed6be
commit r17-6000-g001042d29189eddcce8b06da0f579973774ed6be Author: Andrew MacLeod <[email protected]> Date: Wed Nov 4 16:58:41 2026 -0500 Rework prange points-to API to be address centric. Changes the prange local points-to pt_API into an addr_ based one to avoid confusion with the pt_solution routines. * gimple-range-fold.cc (fold_using_range::fold_stmt): Adjust pt_ names in prange to addr_ API. (fold_using_range::range_of_phi): Likewise. * ipa-prop.cc (ipa_set_jfunc_vr): Likewise. (ipa_record_return_value_range_1): Likewise. * range-op-ptr.cc (pointer_plus_operator::fold_range): Likewise. (pointer_plus_operator::op2_range): Likewise. (operator_pointer_diff::fold_range): Likewise. (operator_cast::fold_range): Likewise. (operator_cast::lhs_op1_relation): Likewise (operator_equal::fold_range): Likewise. (operator_equal::op1_range): Likewise. (operator_not_equal::fold_range): Likewise. (operator_not_equal::op1_range): Likewise. * tree-ssa-threadbackward.cc (find_taken_edge_goto): Likewise. * tree-vrp.cc (rvrp_folder::value_of_expr): Likewise. (rvrp_folder::value_on_edge): Likewise. * value-query.cc (range_query::get_tree_range): Likewise. * value-range-pretty-print.cc (vrange_printer::print_addr): Rename from print_pt and adjust. (vrange_printer::visit): Call print_addr. * value-range-pretty-print.h (print_addr): Change prototype name. * value-range-storage.cc (prange_storage::alloc): Adjust to new API naming convention. (prange_storage::prange_storage): Likewise. (prange_storage::prange_format): Likewise. (prange_storage::set_prange): Likewise. (prange_storage::get_prange): Likewise. (prange_storage::equal_p): Likewise. (prange_storage::set_nonnull): Likewise. * value-range-storage.h (prange_storage::m_known_p): Rename. (prange_storage::m_addr): Rename. * value-range.cc (inchash::add_vrange): Adjust to new API. (prange::set_addr): Renamed and adjust. (prange::addr_base): Likewise. (prange::addr_offset): Likewise. (prange::addr_size): Likewise. (prange::set): Adjust to new API. (prange::union_): Likewise. (prange::intersect): Likewise. (prange::operator=): Likewise. (prange::operator==): Likewise. (prange::invert): Likewise. (prange::verify_range): Likewise. * value-range.h (prange::set_addr): Rename for new API and adjust. (prange::set_addr_unknown): Likewise. (prange::addr_unknown_p): Likewise. (prange::addr_known): Likewise. (prange::addr_excluded): Likewise. (prange::addr_same_known_p): Likewise. (prange::addr_same_excluded_p): Likewise. (prange::addr_invert): Likewise. (prange::addr_inverted_p): Likewise. (prange::addr_base): Likewise. (prange::addr_offset): Likewise. (prange::addr_size): Likewise. (prange::m_addr): Likewise. (prange::m_known_p): Likewise. (prange::addr_equal_p): Likewise. (prange::set_undefined): Adjust to new API. (prange::set_varying): Likewise. (prange::set_nonzero): Likewise. (prange::set_zero): Likewise. (prange::varying_compatible_p): Likewise. Diff: --- gcc/gimple-range-fold.cc | 10 +-- gcc/ipa-prop.cc | 10 +-- gcc/range-op-ptr.cc | 30 ++++---- gcc/tree-ssa-threadbackward.cc | 2 +- gcc/tree-vrp.cc | 4 +- gcc/value-query.cc | 2 +- gcc/value-range-pretty-print.cc | 30 ++++---- gcc/value-range-pretty-print.h | 2 +- gcc/value-range-storage.cc | 26 +++---- gcc/value-range-storage.h | 4 +- gcc/value-range.cc | 99 ++++++++++++------------ gcc/value-range.h | 161 +++++++++++++++++++++------------------- 12 files changed, 194 insertions(+), 186 deletions(-) diff --git a/gcc/gimple-range-fold.cc b/gcc/gimple-range-fold.cc index 72a74a737cbd..8a08c10cf905 100644 --- a/gcc/gimple-range-fold.cc +++ b/gcc/gimple-range-fold.cc @@ -761,7 +761,7 @@ fold_using_range::fold_stmt (vrange &r, gimple *s, fur_source &src, tree name) { prange &p = as_a <prange> (r); // Check to see if points_to should be set. - if (p.pt_unknown_p () && name && gimple_code (s) == GIMPLE_ASSIGN) + if (p.addr_unknown_p () && name && gimple_code (s) == GIMPLE_ASSIGN) { tree rhs = gimple_assign_rhs1 (s); tree_code code = gimple_assign_rhs_code (s); @@ -769,7 +769,7 @@ fold_using_range::fold_stmt (vrange &r, gimple *s, fur_source &src, tree name) if (code != SSA_NAME && get_gimple_rhs_class (code) == GIMPLE_SINGLE_RHS && TREE_CODE (rhs) == ADDR_EXPR) - p.set_pt (rhs, true); + p.set_addr (rhs, true); else { // If we couldn't find anything, try fold. @@ -777,7 +777,7 @@ fold_using_range::fold_stmt (vrange &r, gimple *s, fur_source &src, tree name) rhs = gimple_fold_stmt_to_constant_1 (s, pta_valueize, pta_valueize); if (rhs && TREE_CODE (rhs) == ADDR_EXPR) - p.set_pt (rhs, true); + p.set_addr (rhs, true); } } } @@ -1520,8 +1520,8 @@ fold_using_range::range_of_phi (vrange &r, gphi *phi, fur_source &src) { prange &ptr = as_a <prange> (arg_range); // If it doesn't already point at something, set points to. - if (ptr.pt_unknown_p () && TREE_CODE (single_arg) == ADDR_EXPR) - ptr.set_pt (single_arg, true); + if (ptr.addr_unknown_p () && TREE_CODE (single_arg) == ADDR_EXPR) + ptr.set_addr (single_arg, true); r = ptr; return true; } diff --git a/gcc/ipa-prop.cc b/gcc/ipa-prop.cc index eb220b92eab0..8f7cf8556ba1 100644 --- a/gcc/ipa-prop.cc +++ b/gcc/ipa-prop.cc @@ -2403,9 +2403,9 @@ ipa_set_jfunc_vr (ipa_jump_func *jf, const vrange &tmp) if (is_a <prange> (tmp)) { const prange &pr = as_a <prange> (tmp); - tree t = pr.pt_invariant (); + tree t = pr.addr_known (); if (!t) - t = pr.pt_invariant_away (); + t = pr.addr_excluded (); if (t && !is_gimple_ip_invariant (t)) { if (dump_file && (dump_flags & TDF_DETAILS)) @@ -2415,7 +2415,7 @@ ipa_set_jfunc_vr (ipa_jump_func *jf, const vrange &tmp) fprintf (dump_file, "\n"); } prange stripped = pr; - stripped.set_pt_unknown (); + stripped.set_addr_unknown (); jf->m_vr = ipa_get_value_range (stripped); return; } @@ -6038,9 +6038,9 @@ ipa_record_return_value_range_1 (cgraph_node *n, value_range val) if (is_a<prange> (val)) { const prange &pr = as_a <prange> (val); - tree t = pr.pt_invariant (); + tree t = pr.addr_known (); if (!t) - t = pr.pt_invariant_away (); + t = pr.addr_excluded (); if (t && !is_gimple_ip_invariant (t)) { if (dump_file && (dump_flags & TDF_DETAILS)) diff --git a/gcc/range-op-ptr.cc b/gcc/range-op-ptr.cc index 8dfcceb64fa9..e2c0273489bb 100644 --- a/gcc/range-op-ptr.cc +++ b/gcc/range-op-ptr.cc @@ -372,7 +372,7 @@ pointer_plus_operator::fold_range (prange &r, tree type, // If op1 refers to an object, op1 + 0 will also refer to the object. if (rh_lb == rh_ub && rh_lb == 0) - r.set_pt (op1); + r.set_addr (op1); update_known_bitmask (r, POINTER_PLUS_EXPR, op1, op2); return true; @@ -388,11 +388,11 @@ pointer_plus_operator::op2_range (irange &r, tree type, r.set_varying (type); // If the LHS and OP1 are equal, the op2 must be zero. - if (rel == VREL_EQ || lhs.pt_invariant_p (op1)) + if (rel == VREL_EQ || lhs.addr_same_known_p (op1)) r.set_zero (type); // If the LHS and OP1 are not equal, the offset must be non-zero. // AWM: Check if aliasing may mean we can't do the not_equal check. - else if (rel == VREL_NE || lhs.pt_inverted_p (op1)) + else if (rel == VREL_NE || lhs.addr_inverted_p (op1)) r.set_nonzero (type); else return false; @@ -496,7 +496,7 @@ operator_pointer_diff::fold_range (irange &r, tree type, relation_kind rel = trio.op1_op2 (); op1_op2_relation_effect (r, type, op1, op2, rel); // if op1 and op2 point to the same object, the diff is 0. - if (op1.pt_invariant_p (op2)) + if (op1.addr_same_known_p (op2)) r.set_zero (type); update_bitmask (r, op1, op2); return true; @@ -574,7 +574,7 @@ operator_cast::fold_range (prange &r, tree type, r.set (type, inner.lower_bound (), inner.upper_bound ()); // The resulting pointer still points to the same object. - r.set_pt (inner); + r.set_addr (inner); r.update_bitmask (inner.get_bitmask ()); return true; @@ -741,9 +741,9 @@ operator_cast::lhs_op1_relation (const prange &lhs, // inequality in the points to fields. if (lhs_prec == op1_prec) { - if (lhs.pt_invariant_p (op1)) + if (lhs.addr_same_known_p (op1)) return VREL_EQ; - if (lhs.pt_inverted_p (op1)) + if (lhs.addr_inverted_p (op1)) return VREL_NE; } unsigned prec = MIN (lhs_prec, op1_prec); @@ -900,9 +900,9 @@ operator_equal::fold_range (irange &r, tree type, bool op1_const = wi::eq_p (op1.lower_bound (), op1.upper_bound ()); bool op2_const = wi::eq_p (op2.lower_bound (), op2.upper_bound ()); // Check for points to equality and inequality first. - if (op1.pt_invariant_p (op2)) + if (op1.addr_same_known_p (op2)) r = range_true (type); - else if (op1.pt_inverted_p (op2)) + else if (op1.addr_inverted_p (op2)) r = range_false (type); else if (op1_const && op2_const) { @@ -959,8 +959,8 @@ operator_equal::op1_range (prange &r, tree type, { r.set_varying (type); // OP2 refers to OBJ, so OP1 does not refer to OBJ. - if (tree obj = op2.pt_invariant ()) - r.set_pt (obj, false); + if (tree obj = op2.addr_known ()) + r.set_addr (obj, false); } break; @@ -1010,9 +1010,9 @@ operator_not_equal::fold_range (irange &r, tree type, bool op1_const = wi::eq_p (op1.lower_bound (), op1.upper_bound ()); bool op2_const = wi::eq_p (op2.lower_bound (), op2.upper_bound ()); // Check for points to equality and inequality first. - if (op1.pt_inverted_p (op2)) + if (op1.addr_inverted_p (op2)) r = range_true (type); - else if (op1.pt_invariant_p (op2)) + else if (op1.addr_same_known_p (op2)) r = range_false (type); else if (op1_const && op2_const) { @@ -1064,8 +1064,8 @@ operator_not_equal::op1_range (prange &r, tree type, { r.set_varying (type); // Check if op1 is known not to refer to op2 points to object. - if (tree obj = op2.pt_invariant ()) - r.set_pt (obj, false); + if (tree obj = op2.addr_known ()) + r.set_addr (obj, false); } break; diff --git a/gcc/tree-ssa-threadbackward.cc b/gcc/tree-ssa-threadbackward.cc index c9902d0dc687..ce086a55190e 100644 --- a/gcc/tree-ssa-threadbackward.cc +++ b/gcc/tree-ssa-threadbackward.cc @@ -352,7 +352,7 @@ back_threader::find_taken_edge_goto (const vec<basic_block> &path, if (r.undefined_p ()) return UNREACHABLE_EDGE; - dest = r.pt_invariant (); + dest = r.addr_known (); if (!dest) return NULL; } diff --git a/gcc/tree-vrp.cc b/gcc/tree-vrp.cc index 159bf22729e1..a7377d7dd3a8 100644 --- a/gcc/tree-vrp.cc +++ b/gcc/tree-vrp.cc @@ -981,7 +981,7 @@ public: if (is_a <prange> (r)) { prange &p = as_a <prange> (r); - ret = p.pt_invariant (); + ret = p.addr_known (); // A const points has to be gimple_min_invariant. gcc_checking_assert (!ret || is_gimple_min_invariant (ret)); } @@ -1014,7 +1014,7 @@ public: if (is_a <prange> (r)) { prange &p = as_a <prange> (r); - ret = p.pt_invariant (); + ret = p.addr_known (); // A const points has to be gimple_min_invariant. gcc_checking_assert (!ret || is_gimple_min_invariant (ret)); } diff --git a/gcc/value-query.cc b/gcc/value-query.cc index a35029237ec2..0a6de62d7638 100644 --- a/gcc/value-query.cc +++ b/gcc/value-query.cc @@ -433,7 +433,7 @@ range_query::get_tree_range (vrange &r, tree expr, gimple *stmt, // Set points to field. gcc_checking_assert (is_a <prange> (r)); prange &ptr = as_a <prange> (r); - ptr.set_pt (expr, true); + ptr.set_addr (expr, true); return true; } diff --git a/gcc/value-range-pretty-print.cc b/gcc/value-range-pretty-print.cc index 8b857b1d59a9..3335f2335288 100644 --- a/gcc/value-range-pretty-print.cc +++ b/gcc/value-range-pretty-print.cc @@ -113,30 +113,30 @@ vrange_printer::visit (const irange &r) const } void -vrange_printer::print_pt (const prange &r) const +vrange_printer::print_addr (const prange &r) const { - bool points_to_p = false; - tree pt = r.pt_invariant (); - if (pt) - points_to_p = true; + bool known_p = false; + tree addr = r.addr_known (); + if (addr) + known_p = true; else - pt = r.pt_invariant_away (); + addr = r.addr_excluded (); - if (pt) + if (addr) { - if (points_to_p) + if (known_p) pp_string (pp, " -> "); else pp_string (pp, " ! -> "); - dump_generic_node (pp, pt, 0, TDF_NONE | TDF_NOUID, false); - if (points_to_p) + dump_generic_node (pp, addr, 0, TDF_NONE | TDF_NOUID, false); + if (known_p) { int_range_max sz; int_range_max off; tree b; - b = r.pt_base (); - r.pt_offset(off); - r.pt_size (sz); + b = r.addr_base (); + r.addr_offset(off); + r.addr_size (sz); pp_string (pp, " { Base: "); dump_generic_node (pp, b, 0, TDF_NONE | TDF_NOUID, false); if (!off.varying_p () && !off.undefined_p () && !off.zero_p ()) @@ -178,8 +178,8 @@ vrange_printer::visit (const prange &r) const print_int_bound (pp, r.upper_bound (), r.type ()); pp_character (pp, ']'); print_irange_bitmasks (pp, r.m_bitmask); - // Dump the points to field if there is one. - print_pt (r); + // Dump the address field if there is one. + print_addr (r); } void diff --git a/gcc/value-range-pretty-print.h b/gcc/value-range-pretty-print.h index b6e6a4887827..6bcbd4ff7b1f 100644 --- a/gcc/value-range-pretty-print.h +++ b/gcc/value-range-pretty-print.h @@ -30,7 +30,7 @@ public: void visit (const prange &) const override; void visit (const frange &) const override; private: - void print_pt (const prange &) const; + void print_addr (const prange &) const; void print_frange_nan (const frange &) const; void print_real_value (tree type, const REAL_VALUE_TYPE &r) const; diff --git a/gcc/value-range-storage.cc b/gcc/value-range-storage.cc index d7df014819d8..ce203e67c36c 100644 --- a/gcc/value-range-storage.cc +++ b/gcc/value-range-storage.cc @@ -597,8 +597,8 @@ prange_storage::alloc (vrange_internal_alloc &allocator, const prange &r, size_t size = sizeof (prange_storage) + extra_size; prange_storage *p = static_cast <prange_storage *> (allocator.alloc (size)); new (p) prange_storage (r); - if (p->m_pt && !shared_p) - p->m_pt = unshare_expr_without_location (p->m_pt); + if (p->m_addr && !shared_p) + p->m_addr = unshare_expr_without_location (p->m_addr); return p; } @@ -626,7 +626,7 @@ prange_storage::prange_storage (const prange &r) : vrange_storage (VR_PRANGE) // // Compare the bounds against a fresh set_nonzero () rather than using // prange::operator==, because operator== also compares the bitmask and -// points-to info, which are stored separately here, so a non-null pointer that +// address info, which are stored separately here, so a non-null pointer that // also carries e.g. an alignment bitmask still belongs in PR_NONZERO. static inline bool @@ -674,9 +674,9 @@ prange_storage::prange_format (const prange &r, unsigned &num_words) if (!r.get_bitmask ().unknown_p ()) num_words += 2; - // PR_FULL must have a bitmask or points to, or it should be PR_VARYING. + // PR_FULL must have a bitmask or an address, or it should be PR_VARYING. gcc_checking_assert (kind != PR_FULL || !r.get_bitmask ().unknown_p () - || r.m_pt != NULL_TREE); + || r.m_addr != NULL_TREE); return kind; } @@ -686,8 +686,8 @@ prange_storage::set_prange (const prange &r) unsigned num_words; m_kind = prange_format (r, num_words); m_has_bitmask = false; - m_points_to_p = false; - m_pt = r.m_pt; + m_known_p = false; + m_addr = r.m_addr; unsigned index = 0; @@ -709,7 +709,7 @@ prange_storage::set_prange (const prange &r) } m_has_bitmask = !r.get_bitmask ().unknown_p (); - m_points_to_p = r.m_points_to_p; + m_known_p = r.m_known_p; if (m_has_bitmask) { @@ -775,8 +775,8 @@ prange_storage::get_prange (prange &r, tree type) const else r.m_bitmask.set_unknown (TYPE_PRECISION (type)); - r.m_points_to_p = m_points_to_p; - r.m_pt = m_pt; + r.m_known_p = m_known_p; + r.m_addr = m_addr; if (flag_checking) r.verify_range (); @@ -830,10 +830,10 @@ prange_storage::equal_p (const prange &r) const if (!r.m_bitmask.unknown_p ()) return false; - if (m_pt != r.m_pt) + if (m_addr != r.m_addr) return false; // Storage objects are only equal If they point to the same memory. - if (m_points_to_p != r.m_points_to_p) + if (m_known_p != r.m_known_p) return false; return true; @@ -882,7 +882,7 @@ prange_storage::set_nonnull (tree type) else { // This is very uncoomon, and rather than trying to cover - // the edge cases (ie, bitmask present, points to) + // the edge cases (ie, bitmask present, address present) // simply load the range, remove zero, and resave it. prange pr; this->get_vrange (pr, type); diff --git a/gcc/value-range-storage.h b/gcc/value-range-storage.h index 4deda7ef9f10..a33054b805c6 100644 --- a/gcc/value-range-storage.h +++ b/gcc/value-range-storage.h @@ -124,7 +124,7 @@ private: // needs eight-byte alignment, so there is a four-byte hole. enum prange_kind m_kind : 4; unsigned int m_has_bitmask : 1; - unsigned int m_points_to_p : 1; + unsigned int m_known_p : 1; public: friend void gt_ggc_mx_vrange_storage(void *); @@ -158,7 +158,7 @@ private: prange_storage (const prange &r); static enum prange_kind prange_format (const prange &r, unsigned &num_words); - tree m_pt; + tree m_addr; // We don't use TRAILING_WIDE_INT_ACCESSOR because the getters here // must be const. Perhaps TRAILING_WIDE_INT_ACCESSOR could be made diff --git a/gcc/value-range.cc b/gcc/value-range.cc index 4a76c91db9b6..8df26d8bff3a 100644 --- a/gcc/value-range.cc +++ b/gcc/value-range.cc @@ -464,11 +464,11 @@ add_vrange (const vrange &v, inchash::hash &hstate, hstate.add_wide_int (bm.value ()); hstate.add_wide_int (bm.mask ()); bool flag = false; - tree tmp = r.pt_invariant (); + tree tmp = r.addr_known (); if (tmp) flag = true; else - tmp = r.pt_invariant_away (); + tmp = r.addr_excluded (); hstate.add_ptr (tmp); hstate.add_flag (flag); } @@ -530,23 +530,23 @@ irange::set_nonnegative (tree type) } -// Set the points to info for EXPR if possible. POINTS_TO_P is true if it -// points to EXPR, and FALSE if it points away. +// Set the address info to EXPR if possible. KNOWN_P is TRUE if this range +// is known to be EXPR, and FALSE if it is known to exclude EXPR. void -prange::set_pt (tree expr, bool points_to_p) +prange::set_addr (tree expr, bool known_p) { gcc_checking_assert (m_kind != VR_UNDEFINED); gcc_checking_assert (!expr || TREE_CODE (expr) != SSA_NAME); - m_pt = NULL_TREE; - m_points_to_p = false; + m_addr = NULL_TREE; + m_known_p = false; - // A zero range means no points-to info. + // A zero range means no address info. if (zero_p ()) return; - // No points to initially may make this VARYING. + // No address initially may make this VARYING. if (varying_compatible_p ()) set_varying (type ()); else @@ -573,37 +573,38 @@ prange::set_pt (tree expr, bool points_to_p) if (!size.is_constant ()) return; - m_pt = expr; - m_points_to_p = points_to_p; + m_addr = expr; + m_known_p = known_p; m_kind = VR_RANGE; } // Return object/allocation the pointer refers into, otherwise NULL_TREE. tree -prange::pt_base () const +prange::addr_base () const { - if (!m_pt) + if (!m_addr || !m_known_p) return NULL_TREE; aff_tree off; poly_widest_int sz; - gcc_checking_assert (m_pt); - return get_inner_reference_aff (m_pt, &off, &sz); + gcc_checking_assert (m_addr); + return get_inner_reference_aff (m_addr, &off, &sz); } // Return possible byte offset range from BASE. void -prange::pt_offset (irange &r) const +prange::addr_offset (irange &r) const { aff_tree off; poly_widest_int sz; - gcc_checking_assert (m_pt); + gcc_checking_assert (m_addr); + gcc_checking_assert (m_known_p); - get_inner_reference_aff (m_pt, &off, &sz); + get_inner_reference_aff (m_addr, &off, &sz); gcc_checking_assert (off.offset.is_constant ()); widest_int w = off.offset.coeffs[0]; @@ -614,14 +615,15 @@ prange::pt_offset (irange &r) const // Return possible size range of the referenced object. void -prange::pt_size (irange &r) const +prange::addr_size (irange &r) const { aff_tree off; poly_widest_int sz; - gcc_checking_assert (m_pt); + gcc_checking_assert (m_addr); + gcc_checking_assert (m_known_p); - get_inner_reference_aff (m_pt, &off, &sz); + get_inner_reference_aff (m_addr, &off, &sz); gcc_checking_assert (sz.is_constant ()); widest_int w = sz.coeffs[0]; @@ -678,7 +680,7 @@ prange::set (tree type, const wide_int &min, const wide_int &max, { m_kind = VR_VARYING; m_bitmask.set_unknown (TYPE_PRECISION (type)); - set_pt_unknown (); + set_addr_unknown (); if (flag_checking) verify_range (); return; @@ -686,7 +688,7 @@ prange::set (tree type, const wide_int &min, const wide_int &max, m_kind = VR_RANGE; m_bitmask = irange_bitmask (type, min, max); - set_pt_unknown (); + set_addr_unknown (); if (flag_checking) verify_range (); } @@ -756,10 +758,10 @@ prange::union_ (const vrange &v) new_range.m_bitmask.union_ (m_bitmask); new_range.m_bitmask.union_ (r.m_bitmask); - // Keep it simple, either both point to the same thing or both - // do not point to the same thing, or we drop the points to info. - if (pt_equal_p (r)) - new_range.set_pt (*this); + // Keep it simple, either both name the same address or both do not, + // or we drop the address info. + if (addr_equal_p (r)) + new_range.set_addr (*this); if (new_range.varying_compatible_p ()) { @@ -796,8 +798,9 @@ prange::intersect (const vrange &v) return true; } - // If this points to and away, results are undefined, - if (pt_inverted_p (r)) + // If one knows the address and the other excludes it, the result is + // undefined. + if (addr_inverted_p (r)) { set_undefined (); return true; @@ -818,24 +821,24 @@ prange::intersect (const vrange &v) set_undefined (); else if (!m_bitmask.intersect (r.m_bitmask)) set_undefined (); - // If only one object points to something, that is the intersection. - else if (pt_unknown_p () && !r.pt_unknown_p ()) - set_pt (r); - else if (!pt_unknown_p () && !r.pt_unknown_p ()) + // If only one has an address, that is the intersection. + else if (addr_unknown_p () && !r.addr_unknown_p ()) + set_addr (r); + else if (!addr_unknown_p () && !r.addr_unknown_p ()) { - // If both point to something, we want to be careful. Without aliasing - // 2 different values can point to the same thing, so UNDEFINED is + // If both have an address, we want to be careful. Without aliasing + // 2 different values can name the same address, so UNDEFINED is // not appropriate, but we want to keep the rule that intersection // never becomes larger. - // If the other object points to something specific, and this one does - // not, use the specific one. Otherwise leave the range as is. - if (pt_invariant_away () && r.pt_invariant ()) - set_pt (r); + // If the other operand knows an address and this one only excludes + // one, use the known one. Otherwise leave the range as is. + if (addr_excluded () && r.addr_known ()) + set_addr (r); } - // If this evolves to zero, clear all points-to info. - if (zero_p () && !pt_unknown_p ()) - set_pt_unknown (); + // If this evolves to zero, clear all address info. + if (zero_p () && !addr_unknown_p ()) + set_addr_unknown (); if (varying_compatible_p ()) { @@ -858,7 +861,7 @@ prange::operator= (const prange &src) m_min = src.m_min; m_max = src.m_max; m_bitmask = src.m_bitmask; - set_pt (src); + set_addr (src); if (flag_checking) verify_range (); return *this; @@ -875,7 +878,7 @@ prange::operator== (const prange &src) const if (varying_p ()) return types_compatible_p (type (), src.type ()); - if (!pt_equal_p (src)) + if (!addr_equal_p (src)) return false; return (m_min == src.m_min && m_max == src.m_max @@ -895,10 +898,10 @@ prange::invert () return false; // Invert the points_to object. If that worked, this is done. - if (pt_invert ()) + if (addr_invert ()) return true; else - set_pt_unknown (); + set_addr_unknown (); wide_int new_lb, new_ub; unsigned prec = TYPE_PRECISION (type ()); @@ -935,7 +938,7 @@ prange::verify_range () const if (m_kind == VR_UNDEFINED) { - gcc_checking_assert (pt_unknown_p ()); + gcc_checking_assert (addr_unknown_p ()); return; } @@ -948,7 +951,7 @@ prange::verify_range () const } gcc_checking_assert (!varying_compatible_p ()); gcc_checking_assert (m_kind == VR_RANGE); - if (!pt_unknown_p ()) + if (!addr_unknown_p ()) { gcc_checking_assert (!varying_p ()); gcc_checking_assert (!undefined_p ()); diff --git a/gcc/value-range.h b/gcc/value-range.h index 0b88b46ebc52..6762e60a6625 100644 --- a/gcc/value-range.h +++ b/gcc/value-range.h @@ -443,43 +443,48 @@ public: irange_bitmask get_bitmask () const final override; void update_bitmask (const irange_bitmask &) final override; - // prange interface to points to information. - // It can point_to or point_away from an object. This represents both - // sides of a conditional. ie: + // prange interface to address information. + // It can be known to be a particular address, or exclude that address. + // This represents both sides of a conditional. ie: // if (p == &foo) - // // p points to foo. + // // p known to be foo. // else - // // p points away from foo. - // pt_invariant () and pt_invariant_away () - Return pt if this is invariant. - void set_pt (const prange &r); - void set_pt (tree ptr, bool points_to_p = true); - - // unknown_p () is true if no object is pointed to. - void set_pt_unknown (); - bool pt_unknown_p () const; - - // Invariant points-to are is_gimple_min_invariant_p (). - // Return expression or NULL_TREE for points-to or away - tree pt_invariant () const; - tree pt_invariant_away () const; - - // Return true if THIS and R both point to the same object. - bool pt_invariant_p (const prange &r) const; - // Return true if THIS and R both point away from the same object. - bool pt_invariant_away_p (const prange &r) const; - // Return true if THIS and R refer to the same object, and one is inverted - // from the other, Ie, both to and away. - bool pt_inverted_p (const prange &r) const; - - // Invert THIS if it points either to or away from an object. - bool pt_invert (); - - // pt_base () - object/allocation the pointer refers into. - tree pt_base () const; - // pt_offset () - possible byte offset range from BASE. - void pt_offset (irange &) const; - // pt_size () - possible size range of the referenced object. - void pt_size (irange &) const; + // // p excludes foo. + + // The address is is_gimple_min_invariant, which is relative to the + // current function -- it is NOT is_gimple_ip_invariant, and may name a + // local. Any consumer crossing a function boundary must re-check. + + // Set this address to the same as R, if any. + void set_addr (const prange &r); + void set_addr (tree addr, bool known_p = true); + + void set_addr_unknown (); + bool addr_unknown_p () const; + + // Return expression or NULL_TREE for known or excluded. + tree addr_known () const; + tree addr_excluded () const; + + // Return true if THIS and R are known to be the same address. + bool addr_same_known_p (const prange &r) const; + // Return true if THIS and R both exclude the same address. + bool addr_same_excluded_p (const prange &r) const; + + // If either known or excluded, invert and return TRUE. + bool addr_invert (); + // Return true if THIS and R refer to the same address, and one is inverted + // from the other, Ie, both known and excluded + bool addr_inverted_p (const prange &r) const; + + // These routines decompose addr to its component parts for a known address. + + // addr_base () - object/allocation the pointer refers into. + tree addr_base () const; + // addr_offset () - possible byte offset range from BASE. + void addr_offset (irange &) const; + // addr_size () - possible size range of the referenced object. + void addr_size (irange &) const; protected: bool varying_compatible_p () const; @@ -489,11 +494,12 @@ protected: wide_int m_max; irange_bitmask m_bitmask; - // A prange can point to an object, or NOT point to an object. - tree m_pt; // object points-to refers to. - bool m_points_to_p; // Does it point to it (TRUE), or not (FALSE). - // If P has the same points to fields as THIS. - bool pt_equal_p (const class prange &p) const; + // A prange can be known to be a particular address, or known to exclude + // one. + tree m_addr; // Address referred to. + bool m_known_p; // Is it known (TRUE), or excluded (FALSE). + // Return TRUE if P has the same address fields as THIS. + bool addr_equal_p (const class prange &p) const; }; // Unsupported temporaries may be created by ranger before it's known @@ -1400,7 +1406,7 @@ inline void prange::set_undefined () { m_kind = VR_UNDEFINED; - set_pt_unknown (); + set_addr_unknown (); } inline void @@ -1411,7 +1417,7 @@ prange::set_varying (tree type) m_min = wi::zero (TYPE_PRECISION (type)); m_max = wi::max_value (TYPE_PRECISION (type), UNSIGNED); m_bitmask.set_unknown (TYPE_PRECISION (type)); - set_pt_unknown (); + set_addr_unknown (); if (flag_checking) verify_range (); @@ -1425,7 +1431,7 @@ prange::set_nonzero (tree type) m_min = wi::one (TYPE_PRECISION (type)); m_max = wi::max_value (TYPE_PRECISION (type), UNSIGNED); m_bitmask.set_unknown (TYPE_PRECISION (type)); - set_pt_unknown (); + set_addr_unknown (); if (flag_checking) verify_range (); @@ -1439,7 +1445,7 @@ prange::set_zero (tree type) wide_int zero = wi::zero (TYPE_PRECISION (type)); m_min = m_max = zero; m_bitmask = irange_bitmask (zero, zero); - set_pt_unknown (); + set_addr_unknown (); if (flag_checking) verify_range (); @@ -1493,7 +1499,7 @@ inline bool prange::varying_compatible_p () const { return (!undefined_p () && m_min == 0 && m_max == -1 - && get_bitmask ().unknown_p () && pt_unknown_p ()); + && get_bitmask ().unknown_p () && addr_unknown_p ()); } inline irange_bitmask @@ -1508,18 +1514,17 @@ prange::fits_p (const vrange &) const return true; } -// Set this range's point-to object to PTR, and POINTS_TO_P is TRUE if it -// does point to it, and FALSE if it does not point to it. +// Copy the address information from R, if it has any. inline void -prange::set_pt (const prange &r) +prange::set_addr (const prange &r) { - // Do not set points-to info if this is zero or undefined. - if (!r.pt_unknown_p () && (undefined_p () || zero_p())) + // Do not set address info if this is zero or undefined. + if (!r.addr_unknown_p () && (undefined_p () || zero_p())) return; - m_pt = r.m_pt; - m_points_to_p = r.m_points_to_p; + m_addr = r.m_addr; + m_known_p = r.m_known_p; if (r.undefined_p ()) return; @@ -1534,79 +1539,79 @@ prange::set_pt (const prange &r) // ------------------------------------------------------------------ inline void -prange::set_pt_unknown () +prange::set_addr_unknown () { - m_pt = NULL_TREE; - m_points_to_p = false; + m_addr = NULL_TREE; + m_known_p = false; // If this is a transition from a range, check for varying compatibility. if (m_kind == VR_RANGE && varying_compatible_p ()) m_kind = VR_VARYING; } inline bool -prange::pt_unknown_p () const +prange::addr_unknown_p () const { - return (m_pt == NULL_TREE); + return (m_addr == NULL_TREE); } inline bool -prange::pt_equal_p (const prange &p) const +prange::addr_equal_p (const prange &p) const { // A prange object invokes vrp_operand_equal_p as we want ranges to compare // equal to each other if they refer to the same object, even if the // tree has become unshared. - return (m_points_to_p == p.m_points_to_p - && vrp_operand_equal_p (m_pt, p.m_pt)); + return (m_known_p == p.m_known_p + && vrp_operand_equal_p (m_addr, p.m_addr)); } inline bool -prange::pt_inverted_p (const prange &r) const +prange::addr_inverted_p (const prange &r) const { - return m_pt && vrp_operand_equal_p (m_pt, r.m_pt) - && m_points_to_p != r.m_points_to_p; + return m_addr && vrp_operand_equal_p (m_addr, r.m_addr) + && m_known_p != r.m_known_p; } inline bool -prange::pt_invert () +prange::addr_invert () { - if (m_pt) + if (m_addr) { - m_points_to_p = !m_points_to_p; + m_known_p = !m_known_p; return true; } return false; } inline tree -prange::pt_invariant () const +prange::addr_known () const { - if (m_pt && m_points_to_p) - return m_pt; + if (m_addr && m_known_p) + return m_addr; return NULL_TREE; } inline tree -prange::pt_invariant_away () const +prange::addr_excluded () const { - if (m_pt && !m_points_to_p) - return m_pt; + if (m_addr && !m_known_p) + return m_addr; return NULL_TREE; } inline bool -prange::pt_invariant_p (const prange &r) const +prange::addr_same_known_p (const prange &r) const { - if (m_pt && m_points_to_p && vrp_operand_equal_p (r.m_pt, m_pt) - && m_points_to_p == r.m_points_to_p) + if (m_addr && m_known_p && vrp_operand_equal_p (r.m_addr, m_addr) + && m_known_p == r.m_known_p) return true; return false; } inline bool -prange::pt_invariant_away_p (const prange &r) const +prange::addr_same_excluded_p (const prange &r) const { - if (m_pt && !m_points_to_p && vrp_operand_equal_p (r.m_pt, m_pt) - && m_points_to_p == r.m_points_to_p) + if (m_addr && !m_known_p && vrp_operand_equal_p (r.m_addr, m_addr) + && m_known_p == r.m_known_p) return true; return false; }
