This patch has a lot of mechanical changes as well, but also some tweaks.
First, there was a little bit of the wild west in setting and getting
values, so I const-ified the interface, and add provided 2 routines to
access the pt_solution via an SSA_NAME rather than the ptr_info_def.
ssa_name_pt_solution(name) gets the pt_solution for an SSA_NAME,and
set_ssa_name_pt_solution (name, pt_solution &) sets the pt_solution for
a name.
This effectively hides where the pt_solution comes from for an ssa-name.
Other than the constification and adjustments to call the new routines,
tree-data-ref had a DR_PTR_INFO which cached a ptr_info_def pointer and
utilized it. Analysis indicates that caching the name and retrieving the
pointer info through the same API should also work. If an ssa-name
happens to get freed, it isn't reused until after the pass is done, so
we'd simply get no information in that expired ssa-name case. IM not
even sure if that can happen.
Another alternative would be to simply cache the pt_solution pointer as
that appears to be all that is required.. I'm thinking maybe that is the
way to go? Not sure.
Bootstrapped on x86_64-pc-linux-gnu with no regressions.
Andrew
From b4fa8bd1077b3180ddc9bcc3effcffe2fc810e28 Mon Sep 17 00:00:00 2001
From: Andrew MacLeod <[email protected]>
Date: Wed, 21 Oct 2026 20:53:20 -0400
Subject: [PATCH 6/9] constify and abstract pt_solution API.
This abstracts the pt_solution API for ssa_names such that the
pt_solution field is only accessed though a const pointer, acquired
through ssa_name_pt_solution(), or set via set_ssa_name_pt_solution.
It removes all reference to the ptr_info_def structyure which is slated
to be removed. This facilitates making the pt_solution a direct member
of a prange_storage.
Assisted-by: Claude Opus 5
* cfgexpand.cc (add_partitioned_vars_to_ptset): Adjust parameter.
(update_alias_info_with_stack_vars): Adjust to new API.
* gimple-pretty-print.cc (dump_ssaname_info): Likewise.
* gimple-range.cc: Adjust comment.
* ipa-icf.cc (sem_item_optimizer::fixup_pt_set): Adjust to new API.
* ipa-icf.h (fixup_pt_set): Adjust parameter in protoype.
* targhooks.cc (default_ref_may_alias_errno): Adjust to new API.
* tree-core.h: Adjust comment.
* tree-data-ref.cc (dr_analyze_alias): Adjust to new API.
(dr_may_alias_p): Likewise.
* tree-data-ref.h (struct dr_alias:ptr_name): Rename from ptr_info
and change type to tree.
(DR_PTR_NAME): Rename from DR_PTR_INFO.
* tree-if-conv.cc (predicate_load_or_store): Adjust to new API.
* tree-inline.cc (remap_ssa_name): Likewise.
* tree-ssa-address.cc (copy_ref_info): Likewise.
* tree-ssa-alias.cc (ptr_deref_may_alias_global_p): Likewise.
(ptr_deref_may_alias_auto_p): Likewise.
(ptr_deref_may_alias_decl_p ): Likewise.
(ptr_derefs_may_alias_p): Likewise.
(ptrs_compare_unequal): Likewise.
(dump_alias_info): Likewise.
(dump_points_to_solution): Change parameter type.
(dump_points_to_info_for): Change to new API.
(ref_maybe_used_by_call_p_1): Likewise.
(call_may_clobber_ref_p_1): Likewise.
(same_addr_size_stores_p): Likewise.
* tree-ssa-alias.h (dump_points_to_solution): Adjust parameters.
(pt_solution_singleton_or_null_p): Likewise.
(pt_solution_includes_global): Likewise.
(pt_solution_includes_auto): Likewise.
(pt_solution_includes): Likewise.
(pt_solution_includes_const_pool): Likewise.
(pt_solutions_intersect): Likewise.
* tree-ssa-ccp.cc (fold_builtin_alloca_with_align): Adjust to new API.
* tree-ssa-loop-ivopts.cc (rewrite_use_nonlinear_expr): Likewise.
* tree-ssa-loop-prefetch.cc (issue_prefetch_ref): Likewise.
* tree-ssa-structalias.cc (find_what_p_points_to): Likewise.
(pt_solution_singleton_or_null_p): Parameter constification.
(pt_solution_includes_global): Likewise.
(pt_solution_includes_auto): Likewise.
(pt_solution_includes_1): Likewise.
(pt_solution_includes): Likewise.
(pt_solution_includes_const_pool): Likewise.
(pt_solutions_intersect_1): Likewise.
(pt_solutions_intersect): Likewise.
* tree-ssa.cc (verify_ssa): Adjust to new API.
* tree-ssanames.cc (ssa_name_ptr_info) Make static inline.
(ssa_name_pt_solution): New.
(set_ssa_name_pt_solution): New.
(range_info_set_range): Adjust to new API.
(get_ptr_info_alignment): Likewise.
(mark_ptr_info_alignment_unknown): Likewise.
(get_ptr_info): Make static.
(duplicate_ssa_name_ptr_info): Adjust to new API.
(duplicate_ssa_name_range_info): Likewise.
(reset_flow_sensitive_info): Likewise.
(flow_sensitive_info_storage::save): Likewise.
(flow_sensitive_info_storage::restore): Likewise.
* tree-ssanames.h (ssa_name_ptr_info): Remove.
(ssa_name_pt_solution): New prototype.
(set_ssa_name_pt_solution): New prototype.
(get_ptr_info): Remove.
(duplicate_ssa_name_ptr_info): Adjust parameters.
* tree-vect-data-refs.cc (vect_duplicate_ssa_name_ptr_info): Adjust
to new API.
(vect_create_addr_base_for_vector_ref): Likewise.
(bump_vector_ptr): Likewise.
* value-query.cc (get_ssa_name_ptr_info_nonnull): Likewise.
* value-range-storage.h: Adjust comment.
---
gcc/cfgexpand.cc | 15 +++--
gcc/gimple-pretty-print.cc | 6 +-
gcc/gimple-range.cc | 2 +-
gcc/ipa-icf.cc | 6 +-
gcc/ipa-icf.h | 2 +-
gcc/targhooks.cc | 4 +-
gcc/tree-core.h | 2 +-
gcc/tree-data-ref.cc | 18 +++---
gcc/tree-data-ref.h | 10 ++--
gcc/tree-if-conv.cc | 2 +-
gcc/tree-inline.cc | 22 +++----
gcc/tree-ssa-address.cc | 13 ++--
gcc/tree-ssa-alias.cc | 110 +++++++++++++++++-----------------
gcc/tree-ssa-alias.h | 14 ++---
gcc/tree-ssa-ccp.cc | 8 +--
gcc/tree-ssa-loop-ivopts.cc | 2 +-
gcc/tree-ssa-loop-prefetch.cc | 2 +-
gcc/tree-ssa-structalias.cc | 25 ++++----
gcc/tree-ssa.cc | 6 +-
gcc/tree-ssanames.cc | 62 ++++++++++++-------
gcc/tree-ssanames.h | 12 ++--
gcc/tree-vect-data-refs.cc | 17 +++---
gcc/value-query.cc | 8 +--
gcc/value-range-storage.h | 3 +-
24 files changed, 197 insertions(+), 174 deletions(-)
diff --git a/gcc/cfgexpand.cc b/gcc/cfgexpand.cc
index 4bd311b11a3..d3c0ab43301 100644
--- a/gcc/cfgexpand.cc
+++ b/gcc/cfgexpand.cc
@@ -1070,7 +1070,7 @@ typedef hash_map<unsigned, bitmap, part_traits> part_hashmap;
variables bitmap. */
static void
-add_partitioned_vars_to_ptset (struct pt_solution *pt,
+add_partitioned_vars_to_ptset (const pt_solution *pt,
part_hashmap *decls_to_partitions,
hash_set<bitmap> *visited, bitmap temp)
{
@@ -1121,7 +1121,6 @@ update_alias_info_with_stack_vars (void)
{
bitmap part = NULL;
tree name;
- struct ptr_info_def *pi;
/* Not interested in partitions with single variable. */
if (stack_vars[i].representative != i
@@ -1156,8 +1155,9 @@ update_alias_info_with_stack_vars (void)
}
/* Make the SSA name point to all partition members. */
- pi = get_ptr_info (name);
- pt_solution_set (&pi->pt, part, false);
+ pt_solution pt;
+ pt_solution_set (&pt, part, false);
+ set_ssa_name_pt_solution (name, pt);
}
/* Make all points-to sets that contain one member of a partition
@@ -1171,11 +1171,10 @@ update_alias_info_with_stack_vars (void)
FOR_EACH_SSA_NAME (i, name, cfun)
{
- struct ptr_info_def *pi;
+ const pt_solution *pt = ssa_name_pt_solution (name);
- if (POINTER_TYPE_P (TREE_TYPE (name))
- && ((pi = SSA_NAME_PTR_INFO (name)) != NULL))
- add_partitioned_vars_to_ptset (&pi->pt, decls_to_partitions,
+ if (pt)
+ add_partitioned_vars_to_ptset (pt, decls_to_partitions,
&visited, temp);
}
diff --git a/gcc/gimple-pretty-print.cc b/gcc/gimple-pretty-print.cc
index ae7fdb2d752..4421df4d4d0 100644
--- a/gcc/gimple-pretty-print.cc
+++ b/gcc/gimple-pretty-print.cc
@@ -2400,13 +2400,11 @@ dump_ssaname_info (pretty_printer *pp, tree node, int spc)
if (TREE_CODE (node) != SSA_NAME)
return;
- if (POINTER_TYPE_P (TREE_TYPE (node))
- && SSA_NAME_PTR_INFO (node))
+ if (const pt_solution *pt = ssa_name_pt_solution (node))
{
unsigned int align, misalign;
- struct ptr_info_def *pi = SSA_NAME_PTR_INFO (node);
pp_string (pp, "# PT = ");
- pp_points_to_solution (pp, &pi->pt);
+ pp_points_to_solution (pp, pt);
newline_and_indent (pp, spc);
if (get_ptr_info_alignment (node, &align, &misalign))
{
diff --git a/gcc/gimple-range.cc b/gcc/gimple-range.cc
index 8fb248729fe..6f6a46f6179 100644
--- a/gcc/gimple-range.cc
+++ b/gcc/gimple-range.cc
@@ -616,7 +616,7 @@ gimple_ranger::reset_range_info (tree name)
}
// This routine will export whatever global ranges are known to GCC
-// SSA_RANGE_NAME_INFO and SSA_NAME_PTR_INFO fields.
+// SSA_NAME_RANGE_INFO field.
void
gimple_ranger::export_global_ranges ()
diff --git a/gcc/ipa-icf.cc b/gcc/ipa-icf.cc
index 9ef2149e3aa..5b5a44c1451 100644
--- a/gcc/ipa-icf.cc
+++ b/gcc/ipa-icf.cc
@@ -3517,7 +3517,7 @@ sem_item_optimizer::merge_classes (unsigned int prev_class_count,
/* Fixup points to set PT. */
void
-sem_item_optimizer::fixup_pt_set (struct pt_solution *pt)
+sem_item_optimizer::fixup_pt_set (const pt_solution *pt)
{
if (pt->vars == NULL)
return;
@@ -3564,8 +3564,8 @@ sem_item_optimizer::fixup_points_to_sets (void)
FOR_EACH_SSA_NAME (i, name, fn)
if (POINTER_TYPE_P (TREE_TYPE (name))
- && SSA_NAME_PTR_INFO (name))
- fixup_pt_set (&SSA_NAME_PTR_INFO (name)->pt);
+ && ssa_name_pt_solution (name))
+ fixup_pt_set (ssa_name_pt_solution (name));
fixup_pt_set (&fn->gimple_df->escaped);
fixup_pt_set (&fn->gimple_df->escaped_return);
diff --git a/gcc/ipa-icf.h b/gcc/ipa-icf.h
index 4135ad3eb9c..b1ccd00af1b 100644
--- a/gcc/ipa-icf.h
+++ b/gcc/ipa-icf.h
@@ -589,7 +589,7 @@ private:
void fixup_points_to_sets (void);
/* Fixup points to set PT. */
- void fixup_pt_set (struct pt_solution *pt);
+ void fixup_pt_set (const pt_solution *pt);
/* Adds a newly created congruence class CLS to worklist. */
void worklist_push (congruence_class *cls);
diff --git a/gcc/targhooks.cc b/gcc/targhooks.cc
index 0e4d0a15d0e..2cb4def6866 100644
--- a/gcc/targhooks.cc
+++ b/gcc/targhooks.cc
@@ -1699,8 +1699,8 @@ default_ref_may_alias_errno (ao_ref *ref)
else if (TREE_CODE (base) == MEM_REF
&& TREE_CODE (TREE_OPERAND (base, 0)) == SSA_NAME)
{
- struct ptr_info_def *pi = SSA_NAME_PTR_INFO (TREE_OPERAND (base, 0));
- return !pi || pi->pt.anything || pi->pt.nonlocal;
+ const pt_solution *pt = ssa_name_pt_solution (TREE_OPERAND (base, 0));
+ return !pt || pt->anything || pt->nonlocal;
}
return false;
}
diff --git a/gcc/tree-core.h b/gcc/tree-core.h
index 80d0540c763..6bab44f3c6d 100644
--- a/gcc/tree-core.h
+++ b/gcc/tree-core.h
@@ -1739,7 +1739,7 @@ struct GTY(()) tree_ssa_name {
/* Value range information for every type of SSA name.
The aliasing information for a prange is stored in prange_storage.
- See SSA_NAME_PTR_INFO in tree-ssanames.h. */
+ See ssa_name_pt_solution in tree-ssanames.h. */
struct GTY (()) vrange_storage *range_info;
/* Immediate uses list for this SSA_NAME. */
struct ssa_use_operand_t imm_uses;
diff --git a/gcc/tree-data-ref.cc b/gcc/tree-data-ref.cc
index d6da0fe58c3..517a09b44ac 100644
--- a/gcc/tree-data-ref.cc
+++ b/gcc/tree-data-ref.cc
@@ -1485,7 +1485,7 @@ dr_analyze_alias (struct data_reference *dr)
{
addr = TREE_OPERAND (base, 0);
if (TREE_CODE (addr) == SSA_NAME)
- DR_PTR_INFO (dr) = SSA_NAME_PTR_INFO (addr);
+ DR_PTR_NAME (dr) = addr;
}
}
@@ -3062,14 +3062,18 @@ dr_may_alias_p (const struct data_reference *a, const struct data_reference *b,
/* Try the points-to information recorded for the base pointers the
references were originally analyzed from. DR_BASE_OBJECT can be less
precise, rooting at another SSA name or at one created after points-to
- information was computed and thus without SSA_NAME_PTR_INFO. A
+ information was computed and thus without points-to info. A
recorded solution is not revalidated. It covers every dynamic value
of its SSA name, so it holds for cross-iteration queries as well. */
- struct ptr_info_def *pi_a = DR_PTR_INFO (a);
- struct ptr_info_def *pi_b = DR_PTR_INFO (b);
- if (pi_a && pi_b
- && !pt_solutions_intersect (&pi_a->pt, &pi_b->pt))
- return false;
+ tree name_a = DR_PTR_NAME (a);
+ tree name_b = DR_PTR_NAME (b);
+ if (name_a && name_b)
+ {
+ const pt_solution *pt_a = ssa_name_pt_solution (name_a);
+ const pt_solution *pt_b = ssa_name_pt_solution (name_b);
+ if (pt_a && pt_b && !pt_solutions_intersect (pt_a, pt_b))
+ return false;
+ }
if ((TREE_CODE (addr_a) == MEM_REF || TREE_CODE (addr_a) == TARGET_MEM_REF)
&& (TREE_CODE (addr_b) == MEM_REF || TREE_CODE (addr_b) == TARGET_MEM_REF)
diff --git a/gcc/tree-data-ref.h b/gcc/tree-data-ref.h
index e25f98d2966..68bdae3506b 100644
--- a/gcc/tree-data-ref.h
+++ b/gcc/tree-data-ref.h
@@ -129,9 +129,11 @@ struct indices
struct dr_alias
{
- /* The alias information that should be used for new pointers to this
- location. */
- struct ptr_info_def *ptr_info;
+ /* The base pointer SSA name the reference was analyzed from, whose
+ points-to information should be used for new pointers to this
+ location, or NULL_TREE. The name is recorded rather than its solution
+ so that nothing caches a pointer into the name's info. */
+ tree ptr_name;
};
/* An integer vector. A vector formally consists of an element of a vector
@@ -195,7 +197,7 @@ struct data_reference
#define DR_OFFSET(DR) (DR)->innermost.offset
#define DR_INIT(DR) (DR)->innermost.init
#define DR_STEP(DR) (DR)->innermost.step
-#define DR_PTR_INFO(DR) (DR)->alias.ptr_info
+#define DR_PTR_NAME(DR) (DR)->alias.ptr_name
#define DR_BASE_ALIGNMENT(DR) (DR)->innermost.base_alignment
#define DR_BASE_MISALIGNMENT(DR) (DR)->innermost.base_misalignment
#define DR_OFFSET_ALIGNMENT(DR) (DR)->innermost.offset_alignment
diff --git a/gcc/tree-if-conv.cc b/gcc/tree-if-conv.cc
index 8c104a93d7a..c6e16d8279b 100644
--- a/gcc/tree-if-conv.cc
+++ b/gcc/tree-if-conv.cc
@@ -2754,7 +2754,7 @@ predicate_load_or_store (gimple_stmt_iterator *gsi, gassign *stmt, tree mask)
tree ptr = build_int_cst (reference_alias_ptr_type (ref),
get_object_alignment (ref));
/* Copy points-to info if possible. */
- if (TREE_CODE (addr) == SSA_NAME && !SSA_NAME_PTR_INFO (addr))
+ if (TREE_CODE (addr) == SSA_NAME && !ssa_name_pt_solution (addr))
copy_ref_info (build2 (MEM_REF, TREE_TYPE (ref), addr, ptr),
ref);
if (TREE_CODE (lhs) == SSA_NAME)
diff --git a/gcc/tree-inline.cc b/gcc/tree-inline.cc
index 8162b1f5051..d32da3b2efe 100644
--- a/gcc/tree-inline.cc
+++ b/gcc/tree-inline.cc
@@ -234,7 +234,7 @@ remap_ssa_name (tree name, copy_body_data *id)
&& DECL_IGNORED_P (var)
&& !DECL_NAME (var)))
{
- struct ptr_info_def *pi;
+ const pt_solution *pt;
new_tree = make_ssa_name (remap_type (TREE_TYPE (name), id));
if (!var && SSA_NAME_IDENTIFIER (name))
SET_SSA_NAME_VAR_OR_IDENTIFIER (new_tree, SSA_NAME_IDENTIFIER (name));
@@ -245,12 +245,9 @@ remap_ssa_name (tree name, copy_body_data *id)
if (id->src_cfun->gimple_df
&& id->src_cfun->gimple_df->ipa_pta
&& POINTER_TYPE_P (TREE_TYPE (name))
- && (pi = SSA_NAME_PTR_INFO (name))
- && !pi->pt.anything)
- {
- struct ptr_info_def *new_pi = get_ptr_info (new_tree);
- new_pi->pt = pi->pt;
- }
+ && (pt = ssa_name_pt_solution (name))
+ && !pt->anything)
+ set_ssa_name_pt_solution (new_tree, *pt);
/* So can range-info. */
if (!POINTER_TYPE_P (TREE_TYPE (name))
&& SSA_NAME_RANGE_INFO (name))
@@ -273,7 +270,7 @@ remap_ssa_name (tree name, copy_body_data *id)
|| TREE_CODE (SSA_NAME_VAR (name)) != RESULT_DECL
|| !id->transform_return_to_modify))
{
- struct ptr_info_def *pi;
+ const pt_solution *pt;
new_tree = make_ssa_name (new_tree);
insert_decl_map (id, name, new_tree);
SSA_NAME_OCCURS_IN_ABNORMAL_PHI (new_tree)
@@ -282,12 +279,9 @@ remap_ssa_name (tree name, copy_body_data *id)
if (id->src_cfun->gimple_df
&& id->src_cfun->gimple_df->ipa_pta
&& POINTER_TYPE_P (TREE_TYPE (name))
- && (pi = SSA_NAME_PTR_INFO (name))
- && !pi->pt.anything)
- {
- struct ptr_info_def *new_pi = get_ptr_info (new_tree);
- new_pi->pt = pi->pt;
- }
+ && (pt = ssa_name_pt_solution (name))
+ && !pt->anything)
+ set_ssa_name_pt_solution (new_tree, *pt);
/* So can range-info. */
if (!POINTER_TYPE_P (TREE_TYPE (name))
&& SSA_NAME_RANGE_INFO (name))
diff --git a/gcc/tree-ssa-address.cc b/gcc/tree-ssa-address.cc
index 30baf81d789..22af52be8a2 100644
--- a/gcc/tree-ssa-address.cc
+++ b/gcc/tree-ssa-address.cc
@@ -1026,23 +1026,24 @@ copy_ref_info (tree new_ref, tree old_ref)
or decl base to the new one. */
if (new_ptr_base
&& TREE_CODE (new_ptr_base) == SSA_NAME
- && !SSA_NAME_PTR_INFO (new_ptr_base))
+ && !ssa_name_pt_solution (new_ptr_base))
{
if ((TREE_CODE (base) == MEM_REF
|| TREE_CODE (base) == TARGET_MEM_REF)
&& TREE_CODE (TREE_OPERAND (base, 0)) == SSA_NAME
- && SSA_NAME_PTR_INFO (TREE_OPERAND (base, 0)))
+ && ssa_name_pt_solution (TREE_OPERAND (base, 0)))
{
- duplicate_ssa_name_ptr_info
- (new_ptr_base, SSA_NAME_PTR_INFO (TREE_OPERAND (base, 0)));
+ duplicate_ssa_name_ptr_info (new_ptr_base,
+ TREE_OPERAND (base, 0));
reset_flow_sensitive_info (new_ptr_base);
}
else if (VAR_P (base)
|| TREE_CODE (base) == PARM_DECL
|| TREE_CODE (base) == RESULT_DECL)
{
- struct ptr_info_def *pi = get_ptr_info (new_ptr_base);
- pt_solution_set_var (&pi->pt, base);
+ pt_solution pt;
+ pt_solution_set_var (&pt, base);
+ set_ssa_name_pt_solution (new_ptr_base, pt);
}
}
diff --git a/gcc/tree-ssa-alias.cc b/gcc/tree-ssa-alias.cc
index a8196d11635..23490c07ecd 100644
--- a/gcc/tree-ssa-alias.cc
+++ b/gcc/tree-ssa-alias.cc
@@ -60,7 +60,7 @@ along with GCC; see the file COPYING3. If not see
a generation count for memory references.
SSA_NAME pointers may have associated points-to information
- accessible via the SSA_NAME_PTR_INFO macro. Flow-insensitive
+ accessible via ssa_name_pt_solution. Flow-insensitive
points-to information is (re-)computed by the TODO_rebuild_alias
pass manager todo. Points-to information is also used for more
precise tracking of call-clobbered and call-used variables and
@@ -220,22 +220,22 @@ dump_alias_stats (FILE *s)
bool
ptr_deref_may_alias_global_p (tree ptr, bool escaped_local_p)
{
- struct ptr_info_def *pi;
+ const pt_solution *pt;
/* If we end up with a pointer constant here that may point
to global memory. */
if (TREE_CODE (ptr) != SSA_NAME || !POINTER_TYPE_P (TREE_TYPE (ptr)))
return true;
- pi = SSA_NAME_PTR_INFO (ptr);
+ pt = ssa_name_pt_solution (ptr);
/* If we do not have points-to information for this variable,
we have to punt. */
- if (!pi)
+ if (!pt)
return true;
/* ??? This does not use TBAA to prune globals ptr may not access. */
- return pt_solution_includes_global (&pi->pt, escaped_local_p);
+ return pt_solution_includes_global (pt, escaped_local_p);
}
/* Return true, if dereferencing PTR may alias with a local automatic
@@ -244,21 +244,21 @@ ptr_deref_may_alias_global_p (tree ptr, bool escaped_local_p)
bool
ptr_deref_may_alias_auto_p (tree ptr)
{
- struct ptr_info_def *pi;
+ const pt_solution *pt;
/* If we end up with a pointer constant here that may point
to local stack memory. */
if (TREE_CODE (ptr) != SSA_NAME || !POINTER_TYPE_P (TREE_TYPE (ptr)))
return true;
- pi = SSA_NAME_PTR_INFO (ptr);
+ pt = ssa_name_pt_solution (ptr);
/* If we do not have points-to information for this variable,
we have to punt. */
- if (!pi)
+ if (!pt)
return true;
- return pt_solution_includes_auto (&pi->pt);
+ return pt_solution_includes_auto (pt);
}
@@ -269,7 +269,7 @@ ptr_deref_may_alias_auto_p (tree ptr)
static bool
ptr_deref_may_alias_decl_p (tree ptr, tree decl)
{
- struct ptr_info_def *pi;
+ const pt_solution *pt;
/* Conversions are irrelevant for points-to information and
data-dependence analysis can feed us those. */
@@ -326,11 +326,11 @@ ptr_deref_may_alias_decl_p (tree ptr, tree decl)
/* If we do not have useful points-to information for this pointer
we cannot disambiguate anything else. */
- pi = SSA_NAME_PTR_INFO (ptr);
- if (!pi)
+ pt = ssa_name_pt_solution (ptr);
+ if (!pt)
return true;
- return pt_solution_includes (&pi->pt, decl);
+ return pt_solution_includes (pt, decl);
}
/* Return true if dereferenced PTR1 and PTR2 may alias.
@@ -340,7 +340,7 @@ ptr_deref_may_alias_decl_p (tree ptr, tree decl)
bool
ptr_derefs_may_alias_p (tree ptr1, tree ptr2)
{
- struct ptr_info_def *pi1, *pi2;
+ const pt_solution *pt1, *pt2;
/* Conversions are irrelevant for points-to information and
data-dependence analysis can feed us those. */
@@ -413,14 +413,14 @@ ptr_derefs_may_alias_p (tree ptr1, tree ptr2)
/* If we do not have useful points-to information for either pointer
we cannot disambiguate anything else. */
- pi1 = SSA_NAME_PTR_INFO (ptr1);
- pi2 = SSA_NAME_PTR_INFO (ptr2);
- if (!pi1 || !pi2)
+ pt1 = ssa_name_pt_solution (ptr1);
+ pt2 = ssa_name_pt_solution (ptr2);
+ if (!pt1 || !pt2)
return true;
/* ??? This does not use TBAA to prune decls from the intersection
that not both pointers may access. */
- return pt_solutions_intersect (&pi1->pt, &pi2->pt);
+ return pt_solutions_intersect (pt1, pt2);
}
/* Return true if dereferencing PTR may alias *REF.
@@ -489,13 +489,13 @@ ptrs_compare_unequal (tree ptr1, tree ptr2)
/* Other code handles this correctly, no need to duplicate it here. */;
else if (obj1 && TREE_CODE (ptr2) == SSA_NAME)
{
- struct ptr_info_def *pi = SSA_NAME_PTR_INFO (ptr2);
+ const pt_solution *pt = ssa_name_pt_solution (ptr2);
/* We may not use restrict to optimize pointer comparisons.
See PR71062. So we have to assume that restrict-pointed-to
may be in fact obj1. */
- if (!pi
- || pi->pt.vars_contains_restrict
- || pi->pt.vars_contains_interposable)
+ if (!pt
+ || pt->vars_contains_restrict
+ || pt->vars_contains_interposable)
return false;
if (VAR_P (obj1)
&& (TREE_STATIC (obj1) || DECL_EXTERNAL (obj1)))
@@ -507,34 +507,34 @@ ptrs_compare_unequal (tree ptr1, tree ptr2)
|| ! decl_binds_to_current_def_p (obj1))
return false;
}
- return !pt_solution_includes (&pi->pt, obj1);
+ return !pt_solution_includes (pt, obj1);
}
else if (TREE_CODE (ptr1) == SSA_NAME)
{
- struct ptr_info_def *pi1 = SSA_NAME_PTR_INFO (ptr1);
- if (!pi1
- || pi1->pt.vars_contains_restrict
- || pi1->pt.vars_contains_interposable)
+ const pt_solution *pt1 = ssa_name_pt_solution (ptr1);
+ if (!pt1
+ || pt1->vars_contains_restrict
+ || pt1->vars_contains_interposable)
return false;
- if (integer_zerop (ptr2) && !pi1->pt.null)
+ if (integer_zerop (ptr2) && !pt1->null)
return true;
if (TREE_CODE (ptr2) == SSA_NAME)
{
- struct ptr_info_def *pi2 = SSA_NAME_PTR_INFO (ptr2);
- if (!pi2
- || pi2->pt.vars_contains_restrict
- || pi2->pt.vars_contains_interposable)
+ const pt_solution *pt2 = ssa_name_pt_solution (ptr2);
+ if (!pt2
+ || pt2->vars_contains_restrict
+ || pt2->vars_contains_interposable)
return false;
- if ((!pi1->pt.null || !pi2->pt.null)
+ if ((!pt1->null || !pt2->null)
/* ??? 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
imprecise. */
- && (!pi1->pt.vars_contains_nonlocal
- || !pi2->pt.vars_contains_nonlocal)
- && (!pt_solution_includes_const_pool (&pi1->pt)
- || !pt_solution_includes_const_pool (&pi2->pt)))
- return !pt_solutions_intersect (&pi1->pt, &pi2->pt);
+ && (!pt1->vars_contains_nonlocal
+ || !pt2->vars_contains_nonlocal)
+ && (!pt_solution_includes_const_pool (pt1)
+ || !pt_solution_includes_const_pool (pt2)))
+ return !pt_solutions_intersect (pt1, pt2);
}
}
@@ -642,14 +642,14 @@ dump_alias_info (FILE *file)
FOR_EACH_SSA_NAME (i, ptr, cfun)
{
- struct ptr_info_def *pi;
+ const pt_solution *pt;
if (!POINTER_TYPE_P (TREE_TYPE (ptr))
|| SSA_NAME_IN_FREE_LIST (ptr))
continue;
- pi = SSA_NAME_PTR_INFO (ptr);
- if (pi)
+ pt = ssa_name_pt_solution (ptr);
+ if (pt)
dump_points_to_info_for (file, ptr);
}
@@ -669,7 +669,7 @@ debug_alias_info (void)
/* Dump the points-to set *PT into FILE. */
void
-dump_points_to_solution (FILE *file, struct pt_solution *pt)
+dump_points_to_solution (FILE *file, const pt_solution *pt)
{
if (pt->anything)
fprintf (file, ", points-to anything");
@@ -752,12 +752,12 @@ debug (pt_solution *ptr)
void
dump_points_to_info_for (FILE *file, tree ptr)
{
- struct ptr_info_def *pi = SSA_NAME_PTR_INFO (ptr);
+ const pt_solution *pt = ssa_name_pt_solution (ptr);
print_generic_expr (file, ptr, dump_flags);
- if (pi)
- dump_points_to_solution (file, &pi->pt);
+ if (pt)
+ dump_points_to_solution (file, pt);
else
fprintf (file, ", points-to anything");
@@ -3006,11 +3006,11 @@ ref_maybe_used_by_call_p_1 (gcall *call, ao_ref *ref, bool tbaa_p)
|| TREE_CODE (base) == TARGET_MEM_REF)
&& TREE_CODE (TREE_OPERAND (base, 0)) == SSA_NAME)
{
- struct ptr_info_def *pi = SSA_NAME_PTR_INFO (TREE_OPERAND (base, 0));
- if (!pi)
+ const pt_solution *pt = ssa_name_pt_solution (TREE_OPERAND (base, 0));
+ if (!pt)
return true;
- if (pt_solutions_intersect (gimple_call_use_set (call), &pi->pt))
+ if (pt_solutions_intersect (gimple_call_use_set (call), pt))
return true;
}
else
@@ -3266,11 +3266,11 @@ call_may_clobber_ref_p_1 (gcall *call, ao_ref *ref, bool tbaa_p)
|| TREE_CODE (base) == TARGET_MEM_REF)
&& TREE_CODE (TREE_OPERAND (base, 0)) == SSA_NAME)
{
- struct ptr_info_def *pi = SSA_NAME_PTR_INFO (TREE_OPERAND (base, 0));
- if (!pi)
+ const pt_solution *pt = ssa_name_pt_solution (TREE_OPERAND (base, 0));
+ if (!pt)
return true;
- return pt_solutions_intersect (gimple_call_clobber_set (call), &pi->pt);
+ return pt_solutions_intersect (gimple_call_clobber_set (call), pt);
}
return true;
@@ -3391,15 +3391,15 @@ same_addr_size_stores_p (tree base1, poly_int64 offset1, poly_int64 size1,
tree ptr = TREE_OPERAND (memref, 0);
if (TREE_CODE (ptr) != SSA_NAME)
return false;
- struct ptr_info_def *pi = SSA_NAME_PTR_INFO (ptr);
+ const pt_solution *pt = ssa_name_pt_solution (ptr);
unsigned int pt_uid;
- if (pi == NULL
- || !pt_solution_singleton_or_null_p (&pi->pt, &pt_uid))
+ if (pt == NULL
+ || !pt_solution_singleton_or_null_p (pt, &pt_uid))
return false;
/* Be conservative with non-call exceptions when the address might
be NULL. */
- if (cfun->can_throw_non_call_exceptions && pi->pt.null)
+ if (cfun->can_throw_non_call_exceptions && pt->null)
return false;
/* Check that ptr points relative to obj. */
diff --git a/gcc/tree-ssa-alias.h b/gcc/tree-ssa-alias.h
index ac88b86df34..2e6344a0b6e 100644
--- a/gcc/tree-ssa-alias.h
+++ b/gcc/tree-ssa-alias.h
@@ -172,7 +172,7 @@ extern int walk_aliased_vdefs (ao_ref *, tree,
unsigned int limit = 0);
extern void dump_alias_info (FILE *);
extern void debug_alias_info (void);
-extern void dump_points_to_solution (FILE *, struct pt_solution *);
+extern void dump_points_to_solution (FILE *, const pt_solution *);
extern void debug (pt_solution &ref);
extern void debug (pt_solution *ptr);
extern void dump_points_to_info_for (FILE *, tree);
@@ -183,12 +183,12 @@ extern void dump_alias_stats (FILE *);
/* In tree-ssa-structalias.cc */
extern unsigned int compute_may_aliases (void);
extern bool pt_solution_empty_p (const pt_solution *);
-extern bool pt_solution_singleton_or_null_p (struct pt_solution *, unsigned *);
-extern bool pt_solution_includes_global (struct pt_solution *, bool);
-extern bool pt_solution_includes_auto (struct pt_solution *);
-extern bool pt_solution_includes (struct pt_solution *, const_tree);
-extern bool pt_solution_includes_const_pool (struct pt_solution *);
-extern bool pt_solutions_intersect (struct pt_solution *, struct pt_solution *);
+extern bool pt_solution_singleton_or_null_p (const pt_solution *, unsigned *);
+extern bool pt_solution_includes_global (const pt_solution *, bool);
+extern bool pt_solution_includes_auto (const pt_solution *);
+extern bool pt_solution_includes (const pt_solution *, const_tree);
+extern bool pt_solution_includes_const_pool (const pt_solution *);
+extern bool pt_solutions_intersect (const pt_solution *, const pt_solution *);
extern void pt_solution_reset (struct pt_solution *);
extern void pt_solution_set (struct pt_solution *, bitmap, bool);
extern void pt_solution_set_var (struct pt_solution *, tree);
diff --git a/gcc/tree-ssa-ccp.cc b/gcc/tree-ssa-ccp.cc
index 089c6ae3bf7..9bd288db99c 100644
--- a/gcc/tree-ssa-ccp.cc
+++ b/gcc/tree-ssa-ccp.cc
@@ -2717,11 +2717,11 @@ fold_builtin_alloca_with_align (gimple *stmt)
as it might need to handle more than one instance being
live at the same time. Instead of trying to detect this case
(using the first UID would be OK) just give up for now. */
- struct ptr_info_def *pi = SSA_NAME_PTR_INFO (lhs);
+ const pt_solution *pt = ssa_name_pt_solution (lhs);
unsigned uid = 0;
- if (pi != NULL
- && !pi->pt.anything
- && !pt_solution_singleton_or_null_p (&pi->pt, &uid))
+ if (pt != NULL
+ && !pt->anything
+ && !pt_solution_singleton_or_null_p (pt, &uid))
return NULL_TREE;
/* Declare array. */
diff --git a/gcc/tree-ssa-loop-ivopts.cc b/gcc/tree-ssa-loop-ivopts.cc
index 1a51c7046fb..6128e9d1ec9 100644
--- a/gcc/tree-ssa-loop-ivopts.cc
+++ b/gcc/tree-ssa-loop-ivopts.cc
@@ -7544,7 +7544,7 @@ rewrite_use_nonlinear_expr (struct ivopts_data *data,
gimple_seq_add_seq (&stmt_list, seq);
if (POINTER_TYPE_P (TREE_TYPE (tgt)))
{
- duplicate_ssa_name_ptr_info (comp, SSA_NAME_PTR_INFO (tgt));
+ duplicate_ssa_name_ptr_info (comp, tgt);
/* As this isn't a plain copy we have to reset alignment
information. */
mark_ptr_info_alignment_unknown (comp);
diff --git a/gcc/tree-ssa-loop-prefetch.cc b/gcc/tree-ssa-loop-prefetch.cc
index 4f53695679d..881f834aa84 100644
--- a/gcc/tree-ssa-loop-prefetch.cc
+++ b/gcc/tree-ssa-loop-prefetch.cc
@@ -1211,7 +1211,7 @@ issue_prefetch_ref (struct mem_ref *ref, unsigned unroll_factor, unsigned ahead)
&& TREE_CODE (addr_base) == SSA_NAME
&& TREE_CODE (addr) == SSA_NAME)
{
- duplicate_ssa_name_ptr_info (addr, SSA_NAME_PTR_INFO (addr_base));
+ duplicate_ssa_name_ptr_info (addr, addr_base);
/* As this isn't a plain copy we have to reset alignment
information. */
mark_ptr_info_alignment_unknown (addr);
diff --git a/gcc/tree-ssa-structalias.cc b/gcc/tree-ssa-structalias.cc
index 76fb3600e74..1db7c69be65 100644
--- a/gcc/tree-ssa-structalias.cc
+++ b/gcc/tree-ssa-structalias.cc
@@ -868,7 +868,7 @@ find_what_var_points_to (tree fndecl, varinfo_t orig_vi)
*slot = pt = XOBNEW (&final_solutions_obstack, struct pt_solution);
memset (pt, 0, sizeof (struct pt_solution));
- /* Translate artificial variables into SSA_NAME_PTR_INFO
+ /* Translate artificial variables into points-to info
attributes. */
EXECUTE_IF_SET_IN_BITMAP (vi->solution, 0, i, bi)
{
@@ -929,7 +929,6 @@ find_what_var_points_to (tree fndecl, varinfo_t orig_vi)
static void
find_what_p_points_to (tree fndecl, tree p)
{
- struct ptr_info_def *pi;
tree lookup_p = p;
varinfo_t vi;
prange vr;
@@ -948,10 +947,10 @@ find_what_p_points_to (tree fndecl, tree p)
if (!vi)
return;
- pi = get_ptr_info (p);
- pi->pt = find_what_var_points_to (fndecl, vi);
+ pt_solution pt = find_what_var_points_to (fndecl, vi);
/* Conservatively set to NULL from PTA (to true). */
- pi->pt.null = 1;
+ pt.null = 1;
+ set_ssa_name_pt_solution (p, pt);
/* Preserve pointer nonnull globally computed. */
if (nonnull)
set_ptr_nonnull (p);
@@ -1090,7 +1089,7 @@ pt_solution_empty_p (const pt_solution *pt)
return the var uid in *UID. */
bool
-pt_solution_singleton_or_null_p (struct pt_solution *pt, unsigned *uid)
+pt_solution_singleton_or_null_p (const pt_solution *pt, unsigned *uid)
{
if (pt->anything || pt->nonlocal || pt->escaped || pt->ipa_escaped
|| pt->vars == NULL
@@ -1106,7 +1105,7 @@ pt_solution_singleton_or_null_p (struct pt_solution *pt, unsigned *uid)
considered global. */
bool
-pt_solution_includes_global (struct pt_solution *pt, bool escaped_local_p)
+pt_solution_includes_global (const pt_solution *pt, bool escaped_local_p)
{
if (pt->anything
|| pt->nonlocal
@@ -1136,7 +1135,7 @@ pt_solution_includes_global (struct pt_solution *pt, bool escaped_local_p)
storage. */
bool
-pt_solution_includes_auto (struct pt_solution *pt)
+pt_solution_includes_auto (const pt_solution *pt)
{
if (pt->anything
|| pt->vars_contains_auto)
@@ -1157,7 +1156,7 @@ pt_solution_includes_auto (struct pt_solution *pt)
declaration DECL. */
static bool
-pt_solution_includes_1 (struct pt_solution *pt, const_tree decl)
+pt_solution_includes_1 (const pt_solution *pt, const_tree decl)
{
if (pt->anything)
return true;
@@ -1184,7 +1183,7 @@ pt_solution_includes_1 (struct pt_solution *pt, const_tree decl)
}
bool
-pt_solution_includes (struct pt_solution *pt, const_tree decl)
+pt_solution_includes (const pt_solution *pt, const_tree decl)
{
bool res = pt_solution_includes_1 (pt, decl);
if (res)
@@ -1198,7 +1197,7 @@ pt_solution_includes (struct pt_solution *pt, const_tree decl)
constant pool entry. */
bool
-pt_solution_includes_const_pool (struct pt_solution *pt)
+pt_solution_includes_const_pool (const pt_solution *pt)
{
return (pt->const_pool
|| pt->nonlocal
@@ -1210,7 +1209,7 @@ pt_solution_includes_const_pool (struct pt_solution *pt)
intersection. */
static bool
-pt_solutions_intersect_1 (struct pt_solution *pt1, struct pt_solution *pt2)
+pt_solutions_intersect_1 (const pt_solution *pt1, const pt_solution *pt2)
{
if (pt1->anything || pt2->anything)
return true;
@@ -1259,7 +1258,7 @@ pt_solutions_intersect_1 (struct pt_solution *pt1, struct pt_solution *pt2)
}
bool
-pt_solutions_intersect (struct pt_solution *pt1, struct pt_solution *pt2)
+pt_solutions_intersect (const pt_solution *pt1, const pt_solution *pt2)
{
bool res = pt_solutions_intersect_1 (pt1, pt2);
if (res)
diff --git a/gcc/tree-ssa.cc b/gcc/tree-ssa.cc
index b0cd2aa1b43..1be5290c85f 100644
--- a/gcc/tree-ssa.cc
+++ b/gcc/tree-ssa.cc
@@ -1075,7 +1075,7 @@ verify_ssa (bool check_modified_stmt, bool check_ssa_operands)
/* Keep track of SSA names present in the IL. */
size_t i;
tree name;
- hash_map <void *, tree> ssa_info;
+ hash_map <const void *, tree> ssa_info;
FOR_EACH_SSA_NAME (i, name, cfun)
{
@@ -1093,9 +1093,9 @@ verify_ssa (bool check_modified_stmt, bool check_ssa_operands)
goto err;
}
- void *info = NULL;
+ const void *info = NULL;
if (POINTER_TYPE_P (TREE_TYPE (name)))
- info = SSA_NAME_PTR_INFO (name);
+ info = ssa_name_pt_solution (name);
else if (INTEGRAL_TYPE_P (TREE_TYPE (name)))
info = SSA_NAME_RANGE_INFO (name);
if (info)
diff --git a/gcc/tree-ssanames.cc b/gcc/tree-ssanames.cc
index 5ab3f156e0c..e244c34a799 100644
--- a/gcc/tree-ssanames.cc
+++ b/gcc/tree-ssanames.cc
@@ -114,7 +114,7 @@ range_info_free (tree name)
/* Return the aliasing information for ssa-name NAME, or NULL if there
is none. Return NULL for non pointer types. */
-struct ptr_info_def *
+static inline struct ptr_info_def *
ssa_name_ptr_info (const_tree name)
{
vrange_storage *mem = SSA_NAME_RANGE_INFO (name);
@@ -123,6 +123,28 @@ ssa_name_ptr_info (const_tree name)
return static_cast <prange_storage *> (mem)->ptr_info;
}
+/* Defined below. */
+static struct ptr_info_def *get_ptr_info (tree);
+
+/* Return the points-to solution for ssa-name NAME. Return NULL if it has
+ none or is a non pointer types. */
+
+const pt_solution *
+ssa_name_pt_solution (const_tree name)
+{
+ struct ptr_info_def *pi = ssa_name_ptr_info (name);
+ return pi ? &pi->pt : NULL;
+}
+
+/* Make PT the points-to solution for NAME, which must have pointer type. */
+
+void
+set_ssa_name_pt_solution (tree name, const pt_solution &pt)
+{
+ /* get_ptr_info asserts NAME is a pointer type. */
+ get_ptr_info (name)->pt = pt;
+}
+
/* Return the global range for NAME in R. */
inline void
@@ -142,7 +164,7 @@ range_info_set_range (tree name, const vrange &r)
// Aliasing info belongs to NAME, not to the prange storage object which
// might get reallocated. ptr_info_def addresses may be cached
// elsewhere, so save and copy it back after any reallocation.
- ptr_info_def *pi = SSA_NAME_PTR_INFO (name);
+ ptr_info_def *pi = ssa_name_ptr_info (name);
if (range_info_p (name))
range_info_free (name);
@@ -754,7 +776,7 @@ bool
get_ptr_info_alignment (const_tree name, unsigned int *alignp,
unsigned int *misalignp)
{
- struct ptr_info_def *pi = SSA_NAME_PTR_INFO (name);
+ struct ptr_info_def *pi = ssa_name_ptr_info (name);
if (pi && pi->align)
{
@@ -773,7 +795,7 @@ get_ptr_info_alignment (const_tree name, unsigned int *alignp,
void
mark_ptr_info_alignment_unknown (tree name)
{
- struct ptr_info_def *pi = SSA_NAME_PTR_INFO (name);
+ struct ptr_info_def *pi = ssa_name_ptr_info (name);
if (pi)
{
@@ -817,14 +839,14 @@ set_ssa_name_ptr_info (tree name, struct ptr_info_def *pi)
/* Return the alias information associated with pointer T. It creates a
new instance if none existed. */
-struct ptr_info_def *
+static struct ptr_info_def *
get_ptr_info (tree t)
{
struct ptr_info_def *pi;
gcc_assert (POINTER_TYPE_P (TREE_TYPE (t)));
- pi = SSA_NAME_PTR_INFO (t);
+ pi = ssa_name_ptr_info (t);
if (pi == NULL)
{
// The cleared allocation leaves align and misalign zero, which is
@@ -858,24 +880,24 @@ copy_ssa_name_fn (struct function *fn, tree name, gimple *stmt)
}
-/* Creates a duplicate of the ptr_info_def at PTR_INFO for use by
- the SSA name NAME. */
+/* Give DEST its own copy of the points-to and alignment information of
+ the SSA name SRC. SRC may be NULL_TREE or carry no information, in
+ which case DEST is left alone. */
void
-duplicate_ssa_name_ptr_info (tree name, struct ptr_info_def *ptr_info)
+duplicate_ssa_name_ptr_info (tree dest, tree src)
{
- struct ptr_info_def *new_ptr_info;
-
- gcc_assert (POINTER_TYPE_P (TREE_TYPE (name)));
- gcc_assert (!SSA_NAME_PTR_INFO (name));
+ gcc_assert (POINTER_TYPE_P (TREE_TYPE (dest)));
+ gcc_assert (!ssa_name_ptr_info (dest));
+ struct ptr_info_def *ptr_info = (src ? ssa_name_ptr_info (src) : NULL);
if (!ptr_info)
return;
- new_ptr_info = ggc_alloc<ptr_info_def> ();
+ struct ptr_info_def *new_ptr_info = ggc_alloc<ptr_info_def> ();
*new_ptr_info = *ptr_info;
- set_ssa_name_ptr_info (name, new_ptr_info);
+ set_ssa_name_ptr_info (dest, new_ptr_info);
}
/* Copy any global range and aliasing information from SRC to NAME. */
@@ -895,7 +917,7 @@ duplicate_ssa_name_range_info (tree name, tree src)
/* For a pointer the aliasing info lives in the storage just created,
so it has to be copied as part of the same operation. */
if (POINTER_TYPE_P (TREE_TYPE (src)))
- duplicate_ssa_name_ptr_info (name, SSA_NAME_PTR_INFO (src));
+ duplicate_ssa_name_ptr_info (name, src);
}
/* For a SSA copy DEST = SRC duplicate SSA info present on DEST to SRC
@@ -937,7 +959,7 @@ void
reset_flow_sensitive_info (tree name)
{
/* Aliasing info is not flow sensitive, so preserve it if present. */
- ptr_info_def *pi = SSA_NAME_PTR_INFO (name);
+ ptr_info_def *pi = ssa_name_ptr_info (name);
SSA_NAME_RANGE_INFO (name) = NULL;
if (pi)
{
@@ -1101,7 +1123,7 @@ flow_sensitive_info_storage::save (tree name)
align = 0;
misalign = 0;
}
- auto ptr_info = SSA_NAME_PTR_INFO (name);
+ auto ptr_info = ssa_name_ptr_info (name);
null = ptr_info ? ptr_info->pt.null : true;
}
@@ -1118,7 +1140,7 @@ flow_sensitive_info_storage::restore (tree name)
return;
}
gcc_assert (state == -1);
- auto ptr_info = SSA_NAME_PTR_INFO (name);
+ auto ptr_info = ssa_name_ptr_info (name);
/* If there was no flow sensitive info on the pointer
just return, there is nothing to restore to. */
if (!ptr_info)
@@ -1127,7 +1149,7 @@ flow_sensitive_info_storage::restore (tree name)
set_ptr_info_alignment (name, align, misalign);
else
mark_ptr_info_alignment_unknown (name);
- SSA_NAME_PTR_INFO (name)->pt.null = null;
+ ssa_name_ptr_info (name)->pt.null = null;
}
/* Save off the flow sensitive info from NAME.
diff --git a/gcc/tree-ssanames.h b/gcc/tree-ssanames.h
index 311c4c2a161..fa066f7f8ea 100644
--- a/gcc/tree-ssanames.h
+++ b/gcc/tree-ssanames.h
@@ -46,9 +46,12 @@ struct GTY(()) ptr_info_def
unsigned int misalign;
};
-/* Aliasing attributes for SSA_NAMEs for pointer-type variables. */
-struct ptr_info_def *ssa_name_ptr_info (const_tree name);
-#define SSA_NAME_PTR_INFO(N) (ssa_name_ptr_info (N))
+/* Return NAME's points-to solution, or NULL if it has none. Returns NULL
+ for a non pointer type. */
+extern const pt_solution *ssa_name_pt_solution (const_tree name);
+
+/* Make PT the points-to solution for NAME, which must have pointer type. */
+extern void set_ssa_name_pt_solution (tree name, const pt_solution &pt);
#define SSANAMES(fun) (fun)->gimple_df->ssa_names
#define DEFAULT_DEFS(fun) (fun)->gimple_df->default_defs
@@ -78,12 +81,11 @@ extern bool get_ptr_info_alignment (const_tree, unsigned int *,
unsigned int *);
extern void mark_ptr_info_alignment_unknown (tree);
extern void set_ptr_info_alignment (tree, unsigned int, unsigned int);
-extern struct ptr_info_def *get_ptr_info (tree);
extern void set_ptr_nonnull (tree);
extern tree copy_ssa_name_fn (struct function *, tree, gimple *);
extern tree duplicate_ssa_name_fn (struct function *, tree, gimple *);
-extern void duplicate_ssa_name_ptr_info (tree, struct ptr_info_def *);
+extern void duplicate_ssa_name_ptr_info (tree dest, tree src);
extern void duplicate_ssa_name_range_info (tree dest, tree src);
extern void maybe_duplicate_ssa_info_at_copy (tree dest, tree src);
extern void reset_flow_sensitive_info (tree);
diff --git a/gcc/tree-vect-data-refs.cc b/gcc/tree-vect-data-refs.cc
index b1ec1878c2c..6e37ce35d14 100644
--- a/gcc/tree-vect-data-refs.cc
+++ b/gcc/tree-vect-data-refs.cc
@@ -5548,22 +5548,23 @@ vect_get_new_ssa_name (tree type, enum vect_var_kind var_kind, const char *name)
static void
vect_duplicate_ssa_name_ptr_info (tree name, dr_vec_info *dr_info)
{
- if (DR_PTR_INFO (dr_info->dr))
+ if (DR_PTR_NAME (dr_info->dr))
{
- duplicate_ssa_name_ptr_info (name, DR_PTR_INFO (dr_info->dr));
- /* DR_PTR_INFO is for a base SSA name, not including constant or
+ duplicate_ssa_name_ptr_info (name, DR_PTR_NAME (dr_info->dr));
+ /* DR_PTR_NAME is a base SSA name, not including constant or
variable offsets in the ref so its alignment info does not apply. */
mark_ptr_info_alignment_unknown (name);
}
- else if (!SSA_NAME_PTR_INFO (name))
+ else if (!ssa_name_pt_solution (name))
{
tree base = get_base_address (dr_info->dr->ref);
if (VAR_P (base)
|| TREE_CODE (base) == PARM_DECL
|| TREE_CODE (base) == RESULT_DECL)
{
- struct ptr_info_def *pi = get_ptr_info (name);
- pt_solution_set_var (&pi->pt, base);
+ pt_solution pt;
+ pt_solution_set_var (&pt, base);
+ set_ssa_name_pt_solution (name, pt);
}
}
}
@@ -5686,7 +5687,7 @@ vect_create_addr_base_for_vector_ref (vec_info *vinfo, stmt_vec_info stmt_info,
/* We should only duplicate pointer info to newly created SSA names. */
&& SSA_NAME_VAR (addr_base) == dest)
{
- gcc_assert (!SSA_NAME_PTR_INFO (addr_base));
+ gcc_assert (!ssa_name_pt_solution (addr_base));
vect_duplicate_ssa_name_ptr_info (addr_base, dr_info);
}
@@ -6021,7 +6022,7 @@ bump_vector_ptr (vec_info *vinfo,
}
/* Copy the points-to information if it exists. */
- duplicate_ssa_name_ptr_info (new_dataref_ptr, DR_PTR_INFO (dr));
+ duplicate_ssa_name_ptr_info (new_dataref_ptr, DR_PTR_NAME (dr));
return new_dataref_ptr;
}
diff --git a/gcc/value-query.cc b/gcc/value-query.cc
index 3e64f431fd2..e5290075243 100644
--- a/gcc/value-query.cc
+++ b/gcc/value-query.cc
@@ -592,14 +592,14 @@ get_ssa_name_range_info (vrange &r, const_tree name)
r.set_varying (type);
}
-// Return nonnull attribute of pointer NAME from SSA_NAME_PTR_INFO.
+// 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)));
- struct ptr_info_def *pi = SSA_NAME_PTR_INFO (name);
- if (pi == NULL)
+ 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)
@@ -609,7 +609,7 @@ get_ssa_name_ptr_info_nonnull (const_tree name)
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 !pi->pt.null;
+ return !pt->null;
}
// Update the global range for NAME into the SSA_RANGE_NAME_INFO and
diff --git a/gcc/value-range-storage.h b/gcc/value-range-storage.h
index 9eb03fc8e73..46e98684360 100644
--- a/gcc/value-range-storage.h
+++ b/gcc/value-range-storage.h
@@ -126,7 +126,8 @@ public:
bool fits_p (const prange &r) const;
void dump () const;
- // Pointer aliasing information. Managed seperately via SSA_NAME_PTR_INFO.
+ // Pointer aliasing information. Managed separately, and reached only
+ // through the accessors in tree-ssanames.h.
struct ptr_info_def *ptr_info;
private:
--
2.56.0
