https://gcc.gnu.org/g:7efbea5bc64865ff347f86cd8d029d96acbb14d4
commit r17-5951-g7efbea5bc64865ff347f86cd8d029d96acbb14d4 Author: Andrew MacLeod <[email protected]> Date: Fri Oct 30 10:03:38 2026 -0400 Remove null from pt_solution The null field in pt_solution is a remenant from when no range for a pointer was stored, and an extra bit in the alias structure was ultized to communicate non-nullness. This is now fully tracked by a prange, and is no longer needed. Add a couple of helpers as well to prange_storage and ptr_nonnull_p () now replaces !pt.null as a query. This also means that a pt_solution no loonger has any flow sensitive information in it, and that pointers are no longer "special" from that perspective. gcc/ * gimple-pretty-print.cc (pp_points_to_solution): Do not print null field. * tree-ssa-alias.cc (ptrs_compare_unequal): Use ptr_nonnull_p. (dump_points_to_solution): Don't print null field. (same_addr_size_stores_p): Use ptr_nonnull_p. * tree-ssa-alias.h (pt_solution::null): Remove bit member. * tree-ssa-structalias.cc (find_what_var_points_to): Ignore null. (find_what_p_points_to): Likewise. (pt_solution_reset): Likewise. (pt_solution_ior_into): Likewise. (ipa_escaped_pt): Don't set null field. * tree-ssanames.cc (set_range_info): Do not check pt_solution for the null field. (ptr_nonnull_p): New. (set_ptr_nonnull): Update to Remove 0 from the range. (reset_flow_sensitive_info): No need to clear the null field in pt_solution. (flow_sensitive_info_storage::save): Move to header. (flow_sensitive_info_storage::restore): Move to header. (flow_sensitive_info_storage::save_and_clear): Move to header. (flow_sensitive_info_storage::clear_storage): Move to header. * tree-ssanames.h (ptr_nonnull_p): New prototype. (flow_sensitive_info_storage::save): Simplify and inline. (flow_sensitive_info_storage::restore): Likewise. (flow_sensitive_info_storage::save_and_clear): Likewise. (flow_sensitive_info_storage::clear_storage): Likewise. (flow_sensitive_info_storage::null): Remove member. * value-query.cc (get_ssa_name_ptr_info_nonnull): Delete. (gimple_range_global): Do not check pt_solution null field. * value-range-storage.cc (prange_storage::set_nonnull): New. * value-range-storage.h (prange_storage::nonnull_p): New. (prange_storage::set_nonnull): New prototype. gcc/testsuite/ * gcc.dg/torture/pr39074-2.c: Remove NULL from pt output. * gcc.dg/torture/pr39074.c: Likewise. Diff: --- gcc/gimple-pretty-print.cc | 2 - gcc/testsuite/gcc.dg/torture/pr39074-2.c | 2 +- gcc/testsuite/gcc.dg/torture/pr39074.c | 2 +- gcc/tree-ssa-alias.cc | 9 ++-- gcc/tree-ssa-alias.h | 4 -- gcc/tree-ssa-structalias.cc | 12 ++--- gcc/tree-ssanames.cc | 93 +++++++------------------------- gcc/tree-ssanames.h | 39 +++++++++----- gcc/value-query.cc | 40 +++----------- gcc/value-range-storage.cc | 46 ++++++++++++++++ gcc/value-range-storage.h | 24 +++++++++ 11 files changed, 131 insertions(+), 142 deletions(-) diff --git a/gcc/gimple-pretty-print.cc b/gcc/gimple-pretty-print.cc index 7adcc4bb075c..e9c2586f26d0 100644 --- a/gcc/gimple-pretty-print.cc +++ b/gcc/gimple-pretty-print.cc @@ -823,8 +823,6 @@ pp_points_to_solution (pretty_printer *pp, const pt_solution *pt) pp_string (pp, "escaped "); if (pt->ipa_escaped) pp_string (pp, "unit-escaped "); - if (pt->null) - pp_string (pp, "null "); if (pt->const_pool) pp_string (pp, "const-pool "); if (pt->vars diff --git a/gcc/testsuite/gcc.dg/torture/pr39074-2.c b/gcc/testsuite/gcc.dg/torture/pr39074-2.c index 16c10e88277d..ea9c0d3e9d29 100644 --- a/gcc/testsuite/gcc.dg/torture/pr39074-2.c +++ b/gcc/testsuite/gcc.dg/torture/pr39074-2.c @@ -31,4 +31,4 @@ int main() } /* { dg-final { scan-tree-dump "y.\?.._. = { i }" "alias" } } */ -/* { dg-final { scan-tree-dump "y.\?.._., points-to NULL, points-to vars: { D..... }" "alias" } } */ +/* { dg-final { scan-tree-dump "y.\?.._., points-to vars: { D..... }" "alias" } } */ diff --git a/gcc/testsuite/gcc.dg/torture/pr39074.c b/gcc/testsuite/gcc.dg/torture/pr39074.c index eec4873405d4..d28b35e118e5 100644 --- a/gcc/testsuite/gcc.dg/torture/pr39074.c +++ b/gcc/testsuite/gcc.dg/torture/pr39074.c @@ -30,4 +30,4 @@ int main() } /* { dg-final { scan-tree-dump "y.\?.._. = { i }" "alias" } } */ -/* { dg-final { scan-tree-dump "y.\?.._., points-to NULL, points-to vars: { D..... }" "alias" } } */ +/* { dg-final { scan-tree-dump "y.\?.._., points-to vars: { D..... }" "alias" } } */ diff --git a/gcc/tree-ssa-alias.cc b/gcc/tree-ssa-alias.cc index 23490c07ecdd..41072b4d5d9b 100644 --- a/gcc/tree-ssa-alias.cc +++ b/gcc/tree-ssa-alias.cc @@ -516,7 +516,7 @@ ptrs_compare_unequal (tree ptr1, tree ptr2) || pt1->vars_contains_restrict || pt1->vars_contains_interposable) return false; - if (integer_zerop (ptr2) && !pt1->null) + if (integer_zerop (ptr2) && ptr_nonnull_p (ptr1)) return true; if (TREE_CODE (ptr2) == SSA_NAME) { @@ -525,7 +525,7 @@ ptrs_compare_unequal (tree ptr1, tree ptr2) || pt2->vars_contains_restrict || pt2->vars_contains_interposable) return false; - if ((!pt1->null || !pt2->null) + if ((ptr_nonnull_p (ptr1) || ptr_nonnull_p (ptr2)) /* ??? We do not represent FUNCTION_DECL and LABEL_DECL in pt.vars but only set pt.vars_contains_nonlocal. This makes compares involving those and other nonlocals @@ -683,9 +683,6 @@ dump_points_to_solution (FILE *file, const pt_solution *pt) if (pt->ipa_escaped) fprintf (file, ", points-to unit escaped"); - if (pt->null) - fprintf (file, ", points-to NULL"); - if (pt->const_pool) fprintf (file, ", points-to const-pool"); @@ -3399,7 +3396,7 @@ same_addr_size_stores_p (tree base1, poly_int64 offset1, poly_int64 size1, /* Be conservative with non-call exceptions when the address might be NULL. */ - if (cfun->can_throw_non_call_exceptions && pt->null) + if (cfun->can_throw_non_call_exceptions && !ptr_nonnull_p (ptr)) return false; /* Check that ptr points relative to obj. */ diff --git a/gcc/tree-ssa-alias.h b/gcc/tree-ssa-alias.h index 2e6344a0b6ee..a67293ae4ae2 100644 --- a/gcc/tree-ssa-alias.h +++ b/gcc/tree-ssa-alias.h @@ -43,10 +43,6 @@ struct GTY(()) pt_solution reference. */ unsigned int ipa_escaped : 1; - /* Nonzero if the points-to set includes 'nothing', the points-to set - includes memory at address NULL. */ - unsigned int null : 1; - /* Nonzero if the points-to set includes a readonly object like a STRING_CST that does not have an underlying declaration but will end up in the constant pool. */ diff --git a/gcc/tree-ssa-structalias.cc b/gcc/tree-ssa-structalias.cc index 1db7c69be657..af8100d49a52 100644 --- a/gcc/tree-ssa-structalias.cc +++ b/gcc/tree-ssa-structalias.cc @@ -874,11 +874,9 @@ find_what_var_points_to (tree fndecl, varinfo_t orig_vi) { varinfo_t vi = get_varinfo (i); - if (vi->is_artificial_var) + if (vi->is_artificial_var && vi->id != nothing_id) { - if (vi->id == nothing_id) - pt->null = 1; - else if (vi->id == escaped_id) + if (vi->id == escaped_id) { if (in_ipa_mode) pt->ipa_escaped = 1; @@ -948,8 +946,6 @@ find_what_p_points_to (tree fndecl, tree p) return; pt_solution pt = find_what_var_points_to (fndecl, vi); - /* Conservatively set to NULL from PTA (to true). */ - pt.null = 1; set_ssa_name_pt_solution (p, pt); /* Preserve pointer nonnull globally computed. */ if (nonnull) @@ -993,7 +989,6 @@ pt_solution_reset (struct pt_solution *pt) { memset (pt, 0, sizeof (struct pt_solution)); pt->anything = true; - pt->null = true; } /* Set the points-to solution *PT to point only to the variables @@ -1046,7 +1041,6 @@ pt_solution_ior_into (struct pt_solution *dest, struct pt_solution *src) dest->nonlocal |= src->nonlocal; dest->escaped |= src->escaped; dest->ipa_escaped |= src->ipa_escaped; - dest->null |= src->null; dest->const_pool |= src->const_pool ; dest->vars_contains_nonlocal |= src->vars_contains_nonlocal; dest->vars_contains_escaped |= src->vars_contains_escaped; @@ -1834,7 +1828,7 @@ make_pass_build_ealias (gcc::context *ctxt) /* IPA PTA solutions for ESCAPED. */ struct pt_solution ipa_escaped_pt - = { true, false, false, false, false, false, + = { true, false, false, false, false, false, false, false, false, false, false, NULL }; diff --git a/gcc/tree-ssanames.cc b/gcc/tree-ssanames.cc index 426d43c48ea2..f64868b497d1 100644 --- a/gcc/tree-ssanames.cc +++ b/gcc/tree-ssanames.cc @@ -488,14 +488,6 @@ set_range_info (tree name, const vrange &r) if (!tmp.intersect (r) || tmp.undefined_p ()) return false; - if (POINTER_TYPE_P (type)) - { - // Preserve nonnullness in the points-to solution as well. - pt_solution *pt = get_pt_solution (name); - if (!tmp.contains_zero_p () && pt->null) - set_ptr_nonnull (name); - } - if (!range_info_set_range (name, tmp)) return false; @@ -514,13 +506,31 @@ set_range_info (tree name, const vrange &r) return true; } +/* query nonnull attribute for pointer NAME. */ + +bool +ptr_nonnull_p (tree name) +{ + gcc_assert (POINTER_TYPE_P (TREE_TYPE (name))); + prange_storage *ps = ssa_name_prange_storage (name); + return ps ? ps->nonnull_p (TREE_TYPE (name)) : false; +} + /* Set nonnull attribute to pointer NAME. */ void set_ptr_nonnull (tree name) { gcc_assert (POINTER_TYPE_P (TREE_TYPE (name))); - get_pt_solution (name)->null = 0; + prange_storage *ps = ssa_name_prange_storage (name); + if (ps) + { + ps->set_nonnull (TREE_TYPE (name)); + return; + } + prange pr; + pr.set_nonzero (TREE_TYPE (name)); + range_info_set_range (name, pr); } /* Update the non-zero bits bitmask of NAME. */ @@ -1029,13 +1039,7 @@ reset_flow_sensitive_info (tree name) pt_solution *pt = s ? s->pt : NULL; SSA_NAME_RANGE_INFO (name) = NULL; if (pt) - { - set_pt_solution (name, pt); - /* [E]VRP can derive context sensitive alignment info and - non-nullness properties. We must reset both. The alignment went - with the range storage above; only the nullness is left. */ - pt->null = 1; - } + set_pt_solution (name, pt); // Clear range info in the current range query. get_range_query (cfun)->reset_range_info (name); @@ -1169,60 +1173,3 @@ make_pass_release_ssa_names (gcc::context *ctxt) { return new pass_release_ssa_names (ctxt); } - -/* Save and restore of flow sensitive information. */ - -/* Save off the flow sensitive info from NAME. */ - -void -flow_sensitive_info_storage::save (tree name) -{ - gcc_assert (state == 0); - range_info = SSA_NAME_RANGE_INFO (name); - if (!POINTER_TYPE_P (TREE_TYPE (name))) - { - state = 1; - return; - } - state = -1; - const pt_solution *pt = ssa_name_pt_solution (name); - null = pt ? pt->null : true; -} - -/* Restore the flow sensitive info from NAME. */ - -void -flow_sensitive_info_storage::restore (tree name) -{ - gcc_assert (state != 0); - /* The storage carries the range, its bitmask and -- for now -- the - alignment, so reinstating it restores all three. Only the nullness - lives outside it. */ - SSA_NAME_RANGE_INFO (name) = range_info; - if (!POINTER_TYPE_P (TREE_TYPE (name))) - { - gcc_assert (state == 1); - return; - } - gcc_assert (state == -1); - prange_storage *s = ssa_name_prange_storage (name); - if (s && s->pt) - s->pt->null = null; -} - -/* Save off the flow sensitive info from NAME. - And reset the flow sensitive info of NAME. */ - -void -flow_sensitive_info_storage::save_and_clear (tree name) -{ - save (name); - reset_flow_sensitive_info (name); -} - -/* Clear the storage. */ -void -flow_sensitive_info_storage::clear_storage (void) -{ - state = 0; -} diff --git a/gcc/tree-ssanames.h b/gcc/tree-ssanames.h index 98e21eeeb444..781368710278 100644 --- a/gcc/tree-ssanames.h +++ b/gcc/tree-ssanames.h @@ -64,6 +64,7 @@ extern bool get_ptr_info_alignment (const_tree, unsigned int *, extern void mark_ptr_info_alignment_unknown (tree); extern void set_ptr_info_alignment (tree, unsigned int, unsigned int); extern void set_ptr_nonnull (tree); +extern bool ptr_nonnull_p (tree); extern tree copy_ssa_name_fn (struct function *, tree, gimple *); extern tree duplicate_ssa_name_fn (struct function *, tree, gimple *); @@ -130,21 +131,35 @@ make_temp_ssa_name (tree type, gimple *stmt, const char *name) class flow_sensitive_info_storage { public: - void save (tree); - void save_and_clear (tree); - void restore (tree); - void clear_storage (); + /* Save the flow sensitive info from NAME. */ + inline void save (tree name) + { + gcc_checking_assert (state == 0); + range_info = SSA_NAME_RANGE_INFO (name); + state = 1; + } + + /* Restore the flow sensitive info from NAME. */ + inline void restore (tree name) const + { + gcc_checking_assert (state == 1); + SSA_NAME_RANGE_INFO (name) = range_info; + } + + /* Save the flow sensitive info from NAME and reset that info. */ + inline void save_and_clear (tree name) + { + save (name); + reset_flow_sensitive_info (name); + } + + /* Clear the storage. */ + inline void clear_storage () { state = 0; } private: - /* 0 means there is nothing saved. - 1 means non pointer is saved. - -1 means a pointer type is saved. - -2 means a pointer type is saved but no information was saved. */ + /* 0 means there is nothing saved. 1 means something is saved. */ int state = 0; - /* The range info, which for a pointer also carries the bitmask and the - alignment, so those need no separate slot here. */ + /* The range info contains all flow sensitive information now. */ vrange_storage *range_info = nullptr; - /* Flow sensitive pointer information not held in the range. */ - bool null = true; }; #endif /* GCC_TREE_SSANAMES_H */ diff --git a/gcc/value-query.cc b/gcc/value-query.cc index e52900752438..a35029237ec2 100644 --- a/gcc/value-query.cc +++ b/gcc/value-query.cc @@ -592,26 +592,6 @@ get_ssa_name_range_info (vrange &r, const_tree name) r.set_varying (type); } -// Return nonnull attribute of pointer NAME from its points-to solution. - -static inline bool -get_ssa_name_ptr_info_nonnull (const_tree name) -{ - gcc_assert (POINTER_TYPE_P (TREE_TYPE (name))); - const pt_solution *pt = ssa_name_pt_solution (name); - if (pt == NULL) - return false; - /* TODO Now pt->null is conservatively set to true in PTA - analysis. vrp is the only pass (including ipa-vrp) - that clears pt.null via set_ptr_nonnull when it knows - for sure. PTA will preserves the pt.null value set by VRP. - - When PTA analysis is improved, pt.anything, pt.nonlocal - and pt.escaped may also has to be considered before - deciding that pointer cannot point to NULL. */ - return !pt->null; -} - // Update the global range for NAME into the SSA_RANGE_NAME_INFO and // Return the legacy global range for NAME if it has one, otherwise // return VARYING. @@ -639,13 +619,12 @@ gimple_range_global (vrange &r, tree name, struct function *fun) // ~[0, 0]. Note that this is only valid with default definitions // of PARM_DECLs if (POINTER_TYPE_P (type) - && ((cfun && fun == cfun && nonnull_arg_p (sym)) - || get_ssa_name_ptr_info_nonnull (name))) - { - prange nz (type); - nz.set_nonzero (type); - r.intersect (nz); - } + && ((cfun && fun == cfun && nonnull_arg_p (sym)))) + { + prange nz (type); + nz.set_nonzero (type); + r.intersect (nz); + } } // If this is a local automatic with no definition, use undefined. else if (TREE_CODE (sym) != RESULT_DECL) @@ -658,13 +637,6 @@ gimple_range_global (vrange &r, tree name, struct function *fun) get_ssa_name_range_info (r, name); if (r.undefined_p ()) r.set_varying (type); - // pt.null may still carry non-nullness the stored range does not. - if (POINTER_TYPE_P (type) && get_ssa_name_ptr_info_nonnull (name)) - { - prange nz (type); - nz.set_nonzero (type); - r.intersect (nz); - } } else r.set_varying (type); diff --git a/gcc/value-range-storage.cc b/gcc/value-range-storage.cc index 62879585b6d3..bb2a58788b30 100644 --- a/gcc/value-range-storage.cc +++ b/gcc/value-range-storage.cc @@ -883,6 +883,52 @@ prange_storage::fits_p (const prange &r) const return num_words <= m_trailing_ints.num_elements (); } +// Ensure this range of type TYPE does not contain zero. + +void +prange_storage::set_nonnull (tree type) +{ + gcc_checking_assert (m_kind != PR_UNDEFINED); + switch (m_kind) + { + case PR_VARYING: + case PR_FULL: + m_kind = PR_NONZERO; + return; + + case PR_NONZERO: + return; + + case PR_ZERO: + m_kind = PR_UNDEFINED; + return; + + case PR_OTHER: + if (get_word (0, type) != 0) + return; + // [0,1] -> [1,1] is a special case and requires adjustments. + // otherwise we can simply set the lower bound to 1. + if (get_word (1, type) != 1) + set_word (0, wi::one (TYPE_PRECISION (type)), type); + else + { + // This is very uncoomon, and rather than trying to cover + // the edge cases (ie, bitmask present, points to) + // simply load the range, remove zero, and resave it. + prange pr; + this->get_vrange (pr, type); + prange nz; + nz.set_nonzero (type); + if (pr.intersect (nz)) + this->set_prange (pr); + } + return; + + default: + gcc_unreachable (); + } +} + irange_bitmask prange_storage::get_bitmask (tree type) const { diff --git a/gcc/value-range-storage.h b/gcc/value-range-storage.h index a3a2821a4459..b58a2f23bd32 100644 --- a/gcc/value-range-storage.h +++ b/gcc/value-range-storage.h @@ -132,6 +132,8 @@ public: bool equal_p (const prange &r) const; bool fits_p (const prange &r) const; irange_bitmask get_bitmask (tree type) const; + bool nonnull_p (tree type) const; + void set_nonnull (tree type); void dump () const; // The points-to solution for the SSA name is flow insensitive and is @@ -162,6 +164,28 @@ private: trailing_wide_ints<PRANGE_STORAGE_NINTS> m_trailing_ints; }; +// Return TRUE if this range of type TYPE does not contain zero. + +inline bool +prange_storage::nonnull_p (tree type) const +{ + switch (m_kind) + { + case PR_UNDEFINED: + case PR_VARYING: + case PR_ZERO: + case PR_FULL: + return false; + case PR_NONZERO: + return true; + case PR_OTHER: + return (get_word (0, type) != 0); + default: + gcc_unreachable (); + } +} + + // Efficient memory storage for an frange. class GTY((tag ("VR_FRANGE"))) frange_storage : public vrange_storage
