GCC Middle and Back End API Reference
tree-ssa-alias.cc File Reference
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "backend.h"
#include "target.h"
#include "rtl.h"
#include "tree.h"
#include "gimple.h"
#include "timevar.h"
#include "ssa.h"
#include "cgraph.h"
#include "tree-pretty-print.h"
#include "alias.h"
#include "fold-const.h"
#include "langhooks.h"
#include "dumpfile.h"
#include "tree-eh.h"
#include "tree-dfa.h"
#include "ipa-reference.h"
#include "varasm.h"
#include "ipa-modref-tree.h"
#include "ipa-modref.h"
#include "attr-fnspec.h"
#include "errors.h"
#include "dbgcnt.h"
#include "gimple-pretty-print.h"
#include "print-tree.h"
#include "tree-ssa-alias-compare.h"
#include "builtins.h"
#include "internal-fn.h"
#include "sync-builtins.def"
Include dependency graph for tree-ssa-alias.cc:

Macros

#define DEF_SYNC_BUILTIN(ENUM, NAME, TYPE, ATTRS)   case ENUM:
 

Functions

static int nonoverlapping_refs_since_match_p (tree, tree, tree, tree, bool)
 
static bool nonoverlapping_component_refs_p (const_tree, const_tree)
 
void dump_alias_stats (FILE *s)
 
bool ptr_deref_may_alias_global_p (tree ptr, bool escaped_local_p)
 
static bool ptr_deref_may_alias_decl_p (tree ptr, tree decl)
 
bool ptr_derefs_may_alias_p (tree ptr1, tree ptr2)
 
static bool ptr_deref_may_alias_ref_p_1 (tree ptr, ao_ref *ref)
 
bool ptrs_compare_unequal (tree ptr1, tree ptr2)
 
static bool ref_may_alias_global_p_1 (tree base, bool escaped_local_p)
 
bool ref_may_alias_global_p (ao_ref *ref, bool escaped_local_p)
 
bool ref_may_alias_global_p (tree ref, bool escaped_local_p)
 
bool stmt_may_clobber_global_p (gimple *stmt, bool escaped_local_p)
 
void dump_alias_info (FILE *file)
 
DEBUG_FUNCTION void debug_alias_info (void)
 
void dump_points_to_solution (FILE *file, struct pt_solution *pt)
 
DEBUG_FUNCTION void debug (pt_solution &ref)
 
DEBUG_FUNCTION void debug (pt_solution *ptr)
 
void dump_points_to_info_for (FILE *file, tree ptr)
 
DEBUG_FUNCTION void debug_points_to_info_for (tree var)
 
void ao_ref_init (ao_ref *r, tree ref)
 
tree ao_ref_base (ao_ref *ref)
 
alias_set_type ao_ref_base_alias_set (ao_ref *ref)
 
alias_set_type ao_ref_alias_set (ao_ref *ref)
 
tree ao_ref_base_alias_ptr_type (ao_ref *ref)
 
tree ao_ref_alias_ptr_type (ao_ref *ref)
 
bool ao_ref_alignment (ao_ref *ref, unsigned int *align, unsigned HOST_WIDE_INT *bitpos)
 
void ao_ref_init_from_ptr_and_range (ao_ref *ref, tree ptr, bool range_known, poly_int64 offset, poly_int64 size, poly_int64 max_size)
 
void ao_ref_init_from_ptr_and_size (ao_ref *ref, tree ptr, tree size)
 
static int compare_sizes (tree s1, tree s2)
 
static int compare_type_sizes (tree type1, tree type2)
 
static int same_type_for_tbaa (tree type1, tree type2)
 
static bool type_has_components_p (tree type)
 
static bool aliasing_matching_component_refs_p (tree match1, tree ref1, poly_int64 offset1, poly_int64 max_size1, tree match2, tree ref2, poly_int64 offset2, poly_int64 max_size2, bool partial_overlap)
 
static bool component_ref_to_zero_sized_trailing_array_p (tree ref)
 
static int aliasing_component_refs_walk (tree ref1, tree type1, tree base1, poly_int64 offset1, poly_int64 max_size1, tree end_struct_ref1, tree ref2, tree base2, poly_int64 offset2, poly_int64 max_size2, bool *maybe_match)
 
bool access_path_may_continue_p (tree ref_type1, bool end_struct_past_end1, alias_set_type ref1_alias_set, tree base_type2, tree end_struct_ref2, alias_set_type base2_alias_set)
 
static bool aliasing_component_refs_p (tree ref1, alias_set_type ref1_alias_set, alias_set_type base1_alias_set, poly_int64 offset1, poly_int64 max_size1, tree ref2, alias_set_type ref2_alias_set, alias_set_type base2_alias_set, poly_int64 offset2, poly_int64 max_size2)
 
static int nonoverlapping_component_refs_p_1 (const_tree field1, const_tree field2)
 
static tree cheap_array_ref_low_bound (tree ref)
 
int nonoverlapping_array_refs_p (tree ref1, tree ref2)
 
static int ncr_type_uid (const_tree field)
 
static int ncr_compar (const void *field1_, const void *field2_)
 
static bool decl_refs_may_alias_p (tree ref1, tree base1, poly_int64 offset1, poly_int64 max_size1, poly_int64 size1, tree ref2, tree base2, poly_int64 offset2, poly_int64 max_size2, poly_int64 size2)
 
bool view_converted_memref_p (tree base)
 
static bool indirect_ref_may_alias_decl_p (tree ref1, tree base1, poly_int64 offset1, poly_int64 max_size1, poly_int64 size1, alias_set_type ref1_alias_set, alias_set_type base1_alias_set, tree ref2, tree base2, poly_int64 offset2, poly_int64 max_size2, poly_int64 size2, alias_set_type ref2_alias_set, alias_set_type base2_alias_set, bool tbaa_p)
 
static bool indirect_refs_may_alias_p (tree ref1, tree base1, poly_int64 offset1, poly_int64 max_size1, poly_int64 size1, alias_set_type ref1_alias_set, alias_set_type base1_alias_set, tree ref2, tree base2, poly_int64 offset2, poly_int64 max_size2, poly_int64 size2, alias_set_type ref2_alias_set, alias_set_type base2_alias_set, bool tbaa_p)
 
static bool refs_may_alias_p_2 (ao_ref *ref1, ao_ref *ref2, bool tbaa_p)
 
bool refs_may_alias_p_1 (ao_ref *ref1, ao_ref *ref2, bool tbaa_p)
 
static bool refs_may_alias_p (tree ref1, ao_ref *ref2, bool tbaa_p)
 
bool refs_may_alias_p (tree ref1, tree ref2, bool tbaa_p)
 
bool refs_anti_dependent_p (tree load, tree store)
 
bool refs_output_dependent_p (tree store1, tree store2)
 
static bool modref_may_conflict (const gcall *stmt, modref_tree< alias_set_type > *tt, ao_ref *ref, bool tbaa_p)
 
static int check_fnspec (gcall *call, ao_ref *ref, bool clobber)
 
static bool ref_maybe_used_by_call_p_1 (gcall *call, ao_ref *ref, bool tbaa_p)
 
static bool ref_maybe_used_by_call_p (gcall *call, ao_ref *ref, bool tbaa_p)
 
bool ref_maybe_used_by_stmt_p (gimple *stmt, ao_ref *ref, bool tbaa_p)
 
bool ref_maybe_used_by_stmt_p (gimple *stmt, tree ref, bool tbaa_p)
 
bool call_may_clobber_ref_p_1 (gcall *call, ao_ref *ref, bool tbaa_p)
 
bool call_may_clobber_ref_p (gcall *call, tree ref, bool tbaa_p)
 
bool stmt_may_clobber_ref_p_1 (gimple *stmt, ao_ref *ref, bool tbaa_p)
 
bool stmt_may_clobber_ref_p (gimple *stmt, tree ref, bool tbaa_p)
 
static bool same_addr_size_stores_p (tree base1, poly_int64 offset1, poly_int64 size1, poly_int64 max_size1, tree base2, poly_int64 offset2, poly_int64 size2, poly_int64 max_size2)
 
static bool store_kills_ref_p (tree base, poly_int64 offset, poly_int64 size, poly_int64 max_size, ao_ref *ref)
 
bool stmt_kills_ref_p (gimple *stmt, ao_ref *ref)
 
bool stmt_kills_ref_p (gimple *stmt, tree ref)
 
static bool maybe_skip_until (gimple *phi, tree &target, basic_block target_bb, ao_ref *ref, tree vuse, bool tbaa_p, unsigned int &limit, bitmap *visited, bool abort_on_visited, void *(*translate)(ao_ref *, tree, void *, translate_flags *), translate_flags disambiguate_only, void *data)
 
tree get_continuation_for_phi (gimple *phi, ao_ref *ref, bool tbaa_p, unsigned int &limit, bitmap *visited, bool abort_on_visited, void *(*translate)(ao_ref *, tree, void *, translate_flags *), void *data, translate_flags disambiguate_only)
 
void * walk_non_aliased_vuses (ao_ref *ref, tree vuse, bool tbaa_p, void *(*walker)(ao_ref *, tree, void *), void *(*translate)(ao_ref *, tree, void *, translate_flags *), tree(*valueize)(tree), unsigned &limit, void *data)
 
static int walk_aliased_vdefs_1 (ao_ref *ref, tree vdef, bool(*walker)(ao_ref *, tree, void *), void *data, bitmap *visited, unsigned int cnt, bool *function_entry_reached, unsigned limit)
 
int walk_aliased_vdefs (ao_ref *ref, tree vdef, bool(*walker)(ao_ref *, tree, void *), void *data, bitmap *visited, bool *function_entry_reached, unsigned int limit)
 
static bool types_equal_for_same_type_for_tbaa_p (tree type1, tree type2, bool lto_streaming_safe)
 

Variables

struct { 
 
   unsigned HOST_WIDE_INT   refs_may_alias_p_may_alias 
 
   unsigned HOST_WIDE_INT   refs_may_alias_p_no_alias 
 
   unsigned HOST_WIDE_INT   ref_maybe_used_by_call_p_may_alias 
 
   unsigned HOST_WIDE_INT   ref_maybe_used_by_call_p_no_alias 
 
   unsigned HOST_WIDE_INT   call_may_clobber_ref_p_may_alias 
 
   unsigned HOST_WIDE_INT   call_may_clobber_ref_p_no_alias 
 
   unsigned HOST_WIDE_INT   aliasing_component_refs_p_may_alias 
 
   unsigned HOST_WIDE_INT   aliasing_component_refs_p_no_alias 
 
   unsigned HOST_WIDE_INT   nonoverlapping_component_refs_p_may_alias 
 
   unsigned HOST_WIDE_INT   nonoverlapping_component_refs_p_no_alias 
 
   unsigned HOST_WIDE_INT   nonoverlapping_refs_since_match_p_may_alias 
 
   unsigned HOST_WIDE_INT   nonoverlapping_refs_since_match_p_must_overlap 
 
   unsigned HOST_WIDE_INT   nonoverlapping_refs_since_match_p_no_alias 
 
   unsigned HOST_WIDE_INT   stmt_kills_ref_p_no 
 
   unsigned HOST_WIDE_INT   stmt_kills_ref_p_yes 
 
   unsigned HOST_WIDE_INT   modref_use_may_alias 
 
   unsigned HOST_WIDE_INT   modref_use_no_alias 
 
   unsigned HOST_WIDE_INT   modref_clobber_may_alias 
 
   unsigned HOST_WIDE_INT   modref_clobber_no_alias 
 
   unsigned HOST_WIDE_INT   modref_kill_no 
 
   unsigned HOST_WIDE_INT   modref_kill_yes 
 
   unsigned HOST_WIDE_INT   modref_tests 
 
   unsigned HOST_WIDE_INT   modref_baseptr_tests 
 
alias_stats 
 

Macro Definition Documentation

◆ DEF_SYNC_BUILTIN

#define DEF_SYNC_BUILTIN ( ENUM,
NAME,
TYPE,
ATTRS )   case ENUM:

Function Documentation

◆ access_path_may_continue_p()

bool access_path_may_continue_p ( tree ref_type1,
bool end_struct_past_end1,
alias_set_type ref1_alias_set,
tree base_type2,
tree end_struct_ref2,
alias_set_type base2_alias_set )
Consider access path1 base1....ref1 and access path2 base2...ref2.
Return true if they can be composed to single access path
base1...ref1...base2...ref2.

REF_TYPE1 if type of REF1.  END_STRUCT_PAST_END1 is true if there is
a trailing array access after REF1 in the non-TBAA part of the access.
REF1_ALIAS_SET is the alias set of REF1.

BASE_TYPE2 is type of base2.  END_STRUCT_REF2 is non-NULL if there is
a trailing array access in the TBAA part of access path2.
BASE2_ALIAS_SET is the alias set of base2.   

References alias_set_subset_of(), compare_type_sizes(), TREE_TYPE, and type_has_components_p().

Referenced by aliasing_component_refs_p().

◆ aliasing_component_refs_p()

static bool aliasing_component_refs_p ( tree ref1,
alias_set_type ref1_alias_set,
alias_set_type base1_alias_set,
poly_int64 offset1,
poly_int64 max_size1,
tree ref2,
alias_set_type ref2_alias_set,
alias_set_type base2_alias_set,
poly_int64 offset2,
poly_int64 max_size2 )
static
Determine if the two component references REF1 and REF2 which are
based on access types TYPE1 and TYPE2 and of which at least one is based
on an indirect reference may alias.  
REF1_ALIAS_SET, BASE1_ALIAS_SET, REF2_ALIAS_SET and BASE2_ALIAS_SET
are the respective alias sets.   

References access_path_may_continue_p(), alias_stats, aliasing_component_refs_walk(), compare_type_sizes(), component_ref_to_zero_sized_trailing_array_p(), ends_tbaa_access_path_p(), gcc_checking_assert, handled_component_p(), nonoverlapping_component_refs_p(), NULL, TREE_OPERAND, and TREE_TYPE.

Referenced by indirect_ref_may_alias_decl_p(), and indirect_refs_may_alias_p().

◆ aliasing_component_refs_walk()

static int aliasing_component_refs_walk ( tree ref1,
tree type1,
tree base1,
poly_int64 offset1,
poly_int64 max_size1,
tree end_struct_ref1,
tree ref2,
tree base2,
poly_int64 offset2,
poly_int64 max_size2,
bool * maybe_match )
static
Worker for aliasing_component_refs_p. Most parameters match parameters of
aliasing_component_refs_p.

Walk access path REF2 and try to find type matching TYPE1
(which is a start of possibly aliasing access path REF1).
If match is found, try to disambiguate.

Return 0 for sucessful disambiguation.
Return 1 if match was found but disambiguation failed
Return -1 if there is no match.
In this case MAYBE_MATCH is set to 0 if there is no type matching TYPE1
in access patch REF2 and -1 if we are not sure.   

References aliasing_matching_component_refs_p(), compare_type_sizes(), handled_component_p(), same_type_for_tbaa(), TREE_CODE, TREE_OPERAND, TREE_TYPE, and TYPE_SIZE.

Referenced by aliasing_component_refs_p().

◆ aliasing_matching_component_refs_p()

static bool aliasing_matching_component_refs_p ( tree match1,
tree ref1,
poly_int64 offset1,
poly_int64 max_size1,
tree match2,
tree ref2,
poly_int64 offset2,
poly_int64 max_size2,
bool partial_overlap )
static
MATCH1 and MATCH2 which are part of access path of REF1 and REF2
respectively are either pointing to same address or are completely
disjoint. If PARTIAL_OVERLAP is true, assume that outermost arrays may
just partly overlap.

Try to disambiguate using the access path starting from the match
and return false if there is no conflict.

Helper for aliasing_component_refs_p.   

References alias_stats, get_ref_base_and_extent(), nonoverlapping_component_refs_p(), and nonoverlapping_refs_since_match_p().

Referenced by aliasing_component_refs_walk().

◆ ao_ref_alias_ptr_type()

tree ao_ref_alias_ptr_type ( ao_ref * ref)
Returns a type satisfying
get_deref_alias_set (type) == ao_ref_alias_set (REF).   

References NULL_TREE, ao_ref::ref, and reference_alias_ptr_type().

Referenced by ao_compare::compare_ao_refs(), and ipa_icf::sem_function::hash_stmt().

◆ ao_ref_alias_set()

◆ ao_ref_alignment()

bool ao_ref_alignment ( ao_ref * ref,
unsigned int * align,
unsigned HOST_WIDE_INT * bitpos )
Return the alignment of the access *REF and store it in the *ALIGN
and *BITPOS pairs.  Returns false if no alignment could be determined.
See get_object_alignment_2 for details.   

References ptr_info_def::align, ao_ref::base, get_object_alignment_1(), get_object_alignment_2(), poly_int< N, C >::is_constant(), ao_ref::offset, offset, and ao_ref::ref.

Referenced by compute_trims().

◆ ao_ref_base()

◆ ao_ref_base_alias_ptr_type()

tree ao_ref_base_alias_ptr_type ( ao_ref * ref)
Returns a type satisfying
get_deref_alias_set (type) == ao_ref_base_alias_set (REF).   

References handled_component_p(), NULL_TREE, ao_ref::ref, reference_alias_ptr_type(), TREE_CODE, and TREE_OPERAND.

Referenced by ao_compare::compare_ao_refs(), and ipa_icf::sem_function::hash_stmt().

◆ ao_ref_base_alias_set()

◆ ao_ref_init()

◆ ao_ref_init_from_ptr_and_range()

void ao_ref_init_from_ptr_and_range ( ao_ref * ref,
tree ptr,
bool range_known,
poly_int64 offset,
poly_int64 size,
poly_int64 max_size )
Init an alias-oracle reference representation from a gimple pointer
PTR a range specified by OFFSET, SIZE and MAX_SIZE under the assumption
that RANGE_KNOWN is set.

The access is assumed to be only to or after of the pointer target adjusted
by the offset, not before it (even in the case RANGE_KNOWN is false).   

References ao_ref::base, ao_ref::base_alias_set, build2(), char_type_node, gcc_assert, get_addr_base_and_unit_offset(), get_base_address(), gimple_assign_rhs1(), gimple_assign_rhs2(), gimple_assign_rhs_code(), gimple_assign_single_p(), is_gimple_assign(), ao_ref::max_size, null_pointer_node, NULL_TREE, ao_ref::offset, offset, POINTER_TYPE_P, ptrdiff_tree_p(), ao_ref::ref, ao_ref::ref_alias_set, ao_ref::size, SSA_NAME_DEF_STMT, TREE_CODE, TREE_OPERAND, TREE_TYPE, and ao_ref::volatile_p.

Referenced by ao_ref_init_from_ptr_and_size(), check_fnspec(), and modref_access_node::get_ao_ref().

◆ ao_ref_init_from_ptr_and_size()

void ao_ref_init_from_ptr_and_size ( ao_ref * ref,
tree ptr,
tree size )
Init an alias-oracle reference representation from a gimple pointer
PTR and a gimple size SIZE in bytes.  If SIZE is NULL_TREE then the
size is assumed to be unknown.  The access is assumed to be only
to or after of the pointer target, not before it.   

References ao_ref_init_from_ptr_and_range(), coeffs_in_range_p(), HOST_WIDE_INT_MAX, and poly_int_tree_p().

Referenced by call_may_clobber_ref_p_1(), determine_known_aggregate_parts(), ipa_polymorphic_call_context::get_dynamic_type(), gimple_fold_builtin_memory_op(), initialize_ao_ref_for_dse(), maybe_invalidate(), maybe_warn_pass_by_reference(), parm_ref_data_pass_through_p(), ref_maybe_used_by_call_p_1(), stmt_kills_ref_p(), and vn_reference_lookup_3().

◆ call_may_clobber_ref_p()

bool call_may_clobber_ref_p ( gcall * call,
tree ref,
bool tbaa_p )
If the call in statement CALL may clobber the memory reference REF
return true, otherwise return false.   

References alias_stats, ao_ref_init(), call_may_clobber_ref_p_1(), and r.

Referenced by dest_safe_for_nrv_p(), and find_tail_calls().

◆ call_may_clobber_ref_p_1()

◆ cheap_array_ref_low_bound()

static tree cheap_array_ref_low_bound ( tree ref)
static
Return low bound of array. Do not produce new trees
and thus do not care about particular type of integer constant
and placeholder exprs.   

References integer_zero_node, TREE_OPERAND, TREE_TYPE, TYPE_DOMAIN, and TYPE_MIN_VALUE.

Referenced by nonoverlapping_array_refs_p(), and nonoverlapping_refs_since_match_p().

◆ check_fnspec()

◆ compare_sizes()

static int compare_sizes ( tree s1,
tree s2 )
static
S1 and S2 are TYPE_SIZE or DECL_SIZE.  Compare them:
Return -1 if S1 < S2
Return 1 if S1 > S2
Return 0 if equal or incomparable.   

References known_lt, and poly_int_tree_p().

Referenced by compare_type_sizes(), and indirect_ref_may_alias_decl_p().

◆ compare_type_sizes()

static int compare_type_sizes ( tree type1,
tree type2 )
static
Compare TYPE1 and TYPE2 by its size.
Return -1 if size of TYPE1 < size of TYPE2
Return 1 if size of TYPE1 > size of TYPE2
Return 0 if types are of equal sizes or we can not compare them.   

References compare_sizes(), TREE_CODE, TREE_TYPE, TYPE_SIZE, and VECTOR_TYPE_P.

Referenced by access_path_may_continue_p(), aliasing_component_refs_p(), and aliasing_component_refs_walk().

◆ component_ref_to_zero_sized_trailing_array_p()

static bool component_ref_to_zero_sized_trailing_array_p ( tree ref)
static
Return true if REF is reference to zero sized trailing array. I.e.
struct foo {int bar; int array[0];} *fooptr;
fooptr->array.   

References array_ref_flexible_size_p(), integer_zerop(), TREE_CODE, TREE_OPERAND, TREE_TYPE, and TYPE_SIZE.

Referenced by aliasing_component_refs_p(), and ao_compare::compare_ao_refs().

◆ debug() [1/2]

DEBUG_FUNCTION void debug ( pt_solution & ref)
Unified dump function for pt_solution.   

References dump_points_to_solution().

◆ debug() [2/2]

DEBUG_FUNCTION void debug ( pt_solution * ptr)

References debug.

◆ debug_alias_info()

DEBUG_FUNCTION void debug_alias_info ( void )
Dump alias information on stderr.   

References dump_alias_info().

◆ debug_points_to_info_for()

DEBUG_FUNCTION void debug_points_to_info_for ( tree var)
Dump points-to information for VAR into stderr.   

References dump_points_to_info_for().

◆ decl_refs_may_alias_p()

static bool decl_refs_may_alias_p ( tree ref1,
tree base1,
poly_int64 offset1,
poly_int64 max_size1,
poly_int64 size1,
tree ref2,
tree base2,
poly_int64 offset2,
poly_int64 max_size2,
poly_int64 size2 )
static
Return true if two memory references based on the variables BASE1
and BASE2 constrained to [OFFSET1, OFFSET1 + MAX_SIZE1) and
[OFFSET2, OFFSET2 + MAX_SIZE2) may alias.  REF1 and REF2
if non-NULL are the complete memory reference trees.   

References compare_base_decls(), DECL_P, gcc_checking_assert, handled_component_p(), known_eq, nonoverlapping_refs_since_match_p(), and NULL.

Referenced by refs_may_alias_p_2().

◆ dump_alias_info()

◆ dump_alias_stats()

void dump_alias_stats ( FILE * s)

◆ dump_points_to_info_for()

void dump_points_to_info_for ( FILE * file,
tree ptr )
Dump points-to information for SSA_NAME PTR into FILE.   

References dump_flags, dump_points_to_solution(), print_generic_expr(), ptr_info_def::pt, and SSA_NAME_PTR_INFO.

Referenced by debug_points_to_info_for(), dump_alias_info(), and dump_variable().

◆ dump_points_to_solution()

◆ get_continuation_for_phi()

tree get_continuation_for_phi ( gimple * phi,
ao_ref * ref,
bool tbaa_p,
unsigned int & limit,
bitmap * visited,
bool abort_on_visited,
void *(* translate )(ao_ref *, tree, void *, translate_flags *),
void * data,
translate_flags disambiguate_only )
Starting from a PHI node for the virtual operand of the memory reference
REF find a continuation virtual operand that allows to continue walking
statements dominating PHI skipping only statements that cannot possibly
clobber REF.  Decrements LIMIT for each alias disambiguation done
and aborts the walk, returning NULL_TREE if it reaches zero.
Returns NULL_TREE if no suitable virtual operand can be found.   

References CDI_DOMINATORS, dominated_by_p(), get_immediate_dominator(), gimple_bb(), gimple_phi_num_args(), i, maybe_skip_until(), NULL_TREE, PHI_ARG_DEF, SSA_NAME_DEF_STMT, SSA_NAME_IS_DEFAULT_DEF, TR_DISAMBIGUATE, and visited.

Referenced by determine_known_aggregate_parts(), maybe_skip_until(), translate_vuse_through_block(), and walk_non_aliased_vuses().

◆ indirect_ref_may_alias_decl_p()

static bool indirect_ref_may_alias_decl_p ( tree ref1,
tree base1,
poly_int64 offset1,
poly_int64 max_size1,
poly_int64 size1,
alias_set_type ref1_alias_set,
alias_set_type base1_alias_set,
tree ref2,
tree base2,
poly_int64 offset2,
poly_int64 max_size2,
poly_int64 size2,
alias_set_type ref2_alias_set,
alias_set_type base2_alias_set,
bool tbaa_p )
static
Return true if an indirect reference based on *PTR1 constrained
to [OFFSET1, OFFSET1 + MAX_SIZE1) may alias a variable based on BASE2
constrained to [OFFSET2, OFFSET2 + MAX_SIZE2).  *PTR1 and BASE2 have
the alias sets BASE1_ALIAS_SET and BASE2_ALIAS_SET which can be -1
in which case they are computed on-demand.  REF1 and REF2
if non-NULL are the complete memory reference trees.   

References alias_sets_conflict_p(), aliasing_component_refs_p(), compare_sizes(), DECL_P, DECL_SIZE, gcc_checking_assert, handled_component_p(), known_eq, known_lt, mem_ref_offset(), nonoverlapping_component_refs_p(), nonoverlapping_refs_since_match_p(), poly_int_tree_p(), ptr_deref_may_alias_decl_p(), same_type_for_tbaa(), TMR_INDEX, TMR_INDEX2, TREE_CODE, TREE_OPERAND, TREE_TYPE, and TYPE_SIZE.

Referenced by refs_may_alias_p_2().

◆ indirect_refs_may_alias_p()

static bool indirect_refs_may_alias_p ( tree ref1,
tree base1,
poly_int64 offset1,
poly_int64 max_size1,
poly_int64 size1,
alias_set_type ref1_alias_set,
alias_set_type base1_alias_set,
tree ref2,
tree base2,
poly_int64 offset2,
poly_int64 max_size2,
poly_int64 size2,
alias_set_type ref2_alias_set,
alias_set_type base2_alias_set,
bool tbaa_p )
static
Return true if two indirect references based on *PTR1
and *PTR2 constrained to [OFFSET1, OFFSET1 + MAX_SIZE1) and
[OFFSET2, OFFSET2 + MAX_SIZE2) may alias.  *PTR1 and *PTR2 have
the alias sets BASE1_ALIAS_SET and BASE2_ALIAS_SET which can be -1
in which case they are computed on-demand.  REF1 and REF2
if non-NULL are the complete memory reference trees.  

References alias_sets_conflict_p(), aliasing_component_refs_p(), cfun, gcc_checking_assert, gimple_in_ssa_p(), handled_component_p(), known_eq, mem_ref_offset(), nonoverlapping_component_refs_p(), nonoverlapping_refs_since_match_p(), NULL, operand_equal_p(), ptr_derefs_may_alias_p(), same_type_for_tbaa(), TMR_INDEX, TMR_INDEX2, TMR_STEP, TREE_CODE, TREE_OPERAND, and TREE_TYPE.

Referenced by refs_may_alias_p_2().

◆ maybe_skip_until()

static bool maybe_skip_until ( gimple * phi,
tree & target,
basic_block target_bb,
ao_ref * ref,
tree vuse,
bool tbaa_p,
unsigned int & limit,
bitmap * visited,
bool abort_on_visited,
void *(* translate )(ao_ref *, tree, void *, translate_flags *),
translate_flags disambiguate_only,
void * data )
static
Walk the virtual use-def chain of VUSE until hitting the virtual operand
TARGET or a statement clobbering the memory reference REF in which
case false is returned.  The walk starts with VUSE, one argument of PHI.   

References BITMAP_ALLOC, bitmap_bit_p, bitmap_set_bit, bitmap_tree_view(), CDI_DOMINATORS, dominated_by_p(), get_continuation_for_phi(), gimple_bb(), gimple_nop_p(), gimple_vuse(), NULL, PHI_RESULT, SSA_NAME_DEF_STMT, SSA_NAME_VERSION, stmt_may_clobber_ref_p_1(), and visited.

Referenced by get_continuation_for_phi().

◆ modref_may_conflict()

◆ ncr_compar()

static int ncr_compar ( const void * field1_,
const void * field2_ )
inlinestatic
qsort compare function to sort FIELD_DECLs after their
DECL_FIELD_CONTEXT TYPE_UID.   

References ncr_type_uid().

Referenced by nonoverlapping_component_refs_p().

◆ ncr_type_uid()

static int ncr_type_uid ( const_tree field)
inlinestatic
Return TYPE_UID which can be used to match record types we consider
same for TBAA purposes.   

References DECL_FIELD_CONTEXT, TYPE_CANONICAL, and TYPE_UID.

Referenced by ncr_compar(), and nonoverlapping_component_refs_p().

◆ nonoverlapping_array_refs_p()

int nonoverlapping_array_refs_p ( tree ref1,
tree ref2 )
REF1 and REF2 are ARRAY_REFs with either same base address or which are
completely disjoint.

Return 1 if the refs are non-overlapping.
Return 0 if they are possibly overlapping but if so the overlap again
starts on the same address.
Return -1 otherwise.   

References cheap_array_ref_low_bound(), NULL, operand_equal_p(), TREE_CODE, tree_int_cst_equal(), TREE_OPERAND, TREE_TYPE, TYPE_ALIGN, and TYPE_SIZE_UNIT.

Referenced by nonoverlapping_refs_since_match_p().

◆ nonoverlapping_component_refs_p()

static bool nonoverlapping_component_refs_p ( const_tree x,
const_tree y )
static

◆ nonoverlapping_component_refs_p_1()

static int nonoverlapping_component_refs_p_1 ( const_tree field1,
const_tree field2 )
static
FIELD1 and FIELD2 are two fields of component refs.  We assume
that bases of both component refs are either equivalent or nonoverlapping.
We do not assume that the containers of FIELD1 and FIELD2 are of the
same type or size.

Return 0 in case the base address of component_refs are same then 
FIELD1 and FIELD2 have same address. Note that FIELD1 and FIELD2
may not be of same type or size.

Return 1 if FIELD1 and FIELD2 are non-overlapping.

Return -1 otherwise.

Main difference between 0 and -1 is to let
nonoverlapping_component_refs_since_match_p discover the semantically
equivalent part of the access path.

Note that this function is used even with -fno-strict-aliasing
and makes use of no TBAA assumptions.   

References DECL_BIT_FIELD, DECL_BIT_FIELD_REPRESENTATIVE, DECL_CONTEXT, DECL_FIELD_BIT_OFFSET, DECL_FIELD_OFFSET, DECL_SIZE, known_eq, poly_int_tree_p(), TREE_CODE, and tree_int_cst_equal().

Referenced by nonoverlapping_component_refs_p(), and nonoverlapping_refs_since_match_p().

◆ nonoverlapping_refs_since_match_p()

static int nonoverlapping_refs_since_match_p ( tree match1,
tree ref1,
tree match2,
tree ref2,
bool partial_overlap )
static
Alias analysis for trees.
   Copyright (C) 2004-2024 Free Software Foundation, Inc.
   Contributed by Diego Novillo <dnovillo@redhat.com>

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.

GCC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.   
Broad overview of how alias analysis on gimple works:

Statements clobbering or using memory are linked through the
virtual operand factored use-def chain.  The virtual operand
is unique per function, its symbol is accessible via gimple_vop (cfun).
Virtual operands are used for efficiently walking memory statements
in the gimple IL and are useful for things like value-numbering as
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
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
related disambiguations.

This file contains functions for disambiguating memory references,
the so called alias-oracle and tools for walking of the gimple IL.

The main alias-oracle entry-points are

bool stmt_may_clobber_ref_p (gimple *, tree)

  This function queries if a statement may invalidate (parts of)
  the memory designated by the reference tree argument.

bool ref_maybe_used_by_stmt_p (gimple *, tree)

  This function queries if a statement may need (parts of) the
  memory designated by the reference tree argument.

There are variants of these functions that only handle the call
part of a statement, call_may_clobber_ref_p and ref_maybe_used_by_call_p.
Note that these do not disambiguate against a possible call lhs.

bool refs_may_alias_p (tree, tree)

  This function tries to disambiguate two reference trees.

bool ptr_deref_may_alias_global_p (tree, bool)

  This function queries if dereferencing a pointer variable may
  alias global memory.  If bool argument is true, global memory
  is considered to also include function local memory that escaped.

More low-level disambiguators are available and documented in
this file.  Low-level disambiguators dealing with points-to
information are in tree-ssa-structalias.cc.   
Try to disambiguate REF1 and REF2 under the assumption that MATCH1 and
MATCH2 either point to the same address or are disjoint.
MATCH1 and MATCH2 are assumed to be ref in the access path of REF1 and REF2
respectively or NULL in the case we established equivalence of bases.
If PARTIAL_OVERLAP is true assume that the toplevel arrays may actually
overlap by exact multiply of their element size.

This test works by matching the initial segment of the access path
and does not rely on TBAA thus is safe for !flag_strict_aliasing if
match was determined without use of TBAA oracle.

Return 1 if we can determine that component references REF1 and REF2,
that are within a common DECL, cannot overlap.

Return 0 if paths are same and thus there is nothing to disambiguate more
(i.e. there is must alias assuming there is must alias between MATCH1 and
MATCH2)

Return -1 if we can not determine 0 or 1 - this happens when we met
non-matching types was met in the path.
In this case it may make sense to continue by other disambiguation
oracles.   

References alias_stats, cheap_array_ref_low_bound(), DECL_CONTEXT, ends_tbaa_access_path_p(), gcc_checking_assert, handled_component_p(), i, integer_zerop(), nonoverlapping_array_refs_p(), nonoverlapping_component_refs_p_1(), operand_equal_p(), RECORD_OR_UNION_TYPE_P, TREE_CODE, tree_int_cst_equal(), TREE_OPERAND, TREE_TYPE, and TYPE_SIZE.

Referenced by aliasing_matching_component_refs_p(), decl_refs_may_alias_p(), indirect_ref_may_alias_decl_p(), and indirect_refs_may_alias_p().

◆ ptr_deref_may_alias_decl_p()

static bool ptr_deref_may_alias_decl_p ( tree ptr,
tree decl )
static

◆ ptr_deref_may_alias_global_p()

bool ptr_deref_may_alias_global_p ( tree ptr,
bool escaped_local_p )
Return true, if dereferencing PTR may alias with a global variable.
When ESCAPED_LOCAL_P is true escaped local memory is also considered
global.   

References ptr_info_def::pt, pt_solution_includes_global(), SSA_NAME_PTR_INFO, and TREE_CODE.

Referenced by points_to_local_or_readonly_memory_p(), ref_may_alias_global_p_1(), ref_maybe_used_by_stmt_p(), and thread_private_new_memory().

◆ ptr_deref_may_alias_ref_p_1()

static bool ptr_deref_may_alias_ref_p_1 ( tree ptr,
ao_ref * ref )
static
Return true if dereferencing PTR may alias *REF.
The caller is responsible for applying TBAA to see if PTR
may access *REF at all.   

References ao_ref_base(), DECL_P, ptr_deref_may_alias_decl_p(), ptr_derefs_may_alias_p(), TREE_CODE, and TREE_OPERAND.

Referenced by modref_may_conflict().

◆ ptr_derefs_may_alias_p()

bool ptr_derefs_may_alias_p ( tree ptr1,
tree ptr2 )
Return true if dereferenced PTR1 and PTR2 may alias.
The caller is responsible for applying TBAA to see if accesses
through PTR1 and PTR2 may conflict at all.   

References CONSTANT_CLASS_P, DECL_P, get_base_address(), POINTER_TYPE_P, ptr_info_def::pt, pt_solutions_intersect(), ptr_deref_may_alias_decl_p(), ptr_derefs_may_alias_p(), SSA_NAME_PTR_INFO, STRIP_NOPS, TREE_CODE, TREE_OPERAND, and TREE_TYPE.

Referenced by dr_may_alias_p(), generate_memcpy_builtin(), indirect_refs_may_alias_p(), ptr_deref_may_alias_ref_p_1(), and ptr_derefs_may_alias_p().

◆ ptrs_compare_unequal()

◆ ref_may_alias_global_p() [1/2]

bool ref_may_alias_global_p ( ao_ref * ref,
bool escaped_local_p )

◆ ref_may_alias_global_p() [2/2]

bool ref_may_alias_global_p ( tree ref,
bool escaped_local_p )

◆ ref_may_alias_global_p_1()

static bool ref_may_alias_global_p_1 ( tree base,
bool escaped_local_p )
static
Returns whether reference REF to BASE may refer to global memory.
When ESCAPED_LOCAL_P is true escaped local memory is also considered
global.   

References cfun, DECL_P, is_global_var(), pt_solution_includes(), ptr_deref_may_alias_global_p(), TREE_CODE, and TREE_OPERAND.

Referenced by ref_may_alias_global_p(), and ref_may_alias_global_p().

◆ ref_maybe_used_by_call_p()

static bool ref_maybe_used_by_call_p ( gcall * call,
ao_ref * ref,
bool tbaa_p )
static

◆ ref_maybe_used_by_call_p_1()

◆ ref_maybe_used_by_stmt_p() [1/2]

◆ ref_maybe_used_by_stmt_p() [2/2]

bool ref_maybe_used_by_stmt_p ( gimple * stmt,
tree ref,
bool tbaa_p )

◆ refs_anti_dependent_p()

bool refs_anti_dependent_p ( tree load,
tree store )
Returns true if there is a anti-dependence for the STORE that
executes after the LOAD.   

References ao_ref_init(), and refs_may_alias_p_1().

Referenced by dr_may_alias_p().

◆ refs_may_alias_p() [1/2]

static bool refs_may_alias_p ( tree ref1,
ao_ref * ref2,
bool tbaa_p )
static

◆ refs_may_alias_p() [2/2]

bool refs_may_alias_p ( tree ref1,
tree ref2,
bool tbaa_p )

◆ refs_may_alias_p_1()

◆ refs_may_alias_p_2()

◆ refs_output_dependent_p()

bool refs_output_dependent_p ( tree store1,
tree store2 )
Returns true if there is a output dependence for the stores
STORE1 and STORE2.   

References ao_ref_init(), and refs_may_alias_p_1().

Referenced by dr_may_alias_p().

◆ same_addr_size_stores_p()

static bool same_addr_size_stores_p ( tree base1,
poly_int64 offset1,
poly_int64 size1,
poly_int64 max_size1,
tree base2,
poly_int64 offset2,
poly_int64 size2,
poly_int64 max_size2 )
static
Return true if store1 and store2 described by corresponding tuples
<BASE, OFFSET, SIZE, MAX_SIZE> have the same size and store to the same
address.   

References cfun, DECL_PT_UID, DECL_SIZE, integer_zerop(), known_eq, NULL, pt_solution::null, poly_int_tree_p(), ptr_info_def::pt, pt_solution_singleton_or_null_p(), SSA_NAME_PTR_INFO, SSA_VAR_P, wi::to_poly_offset(), TREE_CODE, and TREE_OPERAND.

Referenced by store_kills_ref_p().

◆ same_type_for_tbaa()

static int same_type_for_tbaa ( tree type1,
tree type2 )
inlinestatic
Return 1 if TYPE1 and TYPE2 are to be considered equivalent for the
purpose of TBAA.  Return 0 if they are distinct and -1 if we cannot
decide.   

References alias_sets_conflict_p(), get_alias_set(), POINTER_TYPE_P, TREE_CODE, TYPE_CANONICAL, TYPE_MAIN_VARIANT, and TYPE_STRUCTURAL_EQUALITY_P.

Referenced by aliasing_component_refs_walk(), ao_compare::compare_ao_refs(), indirect_ref_may_alias_decl_p(), indirect_refs_may_alias_p(), nonoverlapping_component_refs_p(), and view_converted_memref_p().

◆ stmt_kills_ref_p() [1/2]

◆ stmt_kills_ref_p() [2/2]

bool stmt_kills_ref_p ( gimple * stmt,
tree ref )

References ao_ref_init(), r, and stmt_kills_ref_p().

◆ stmt_may_clobber_global_p()

bool stmt_may_clobber_global_p ( gimple * stmt,
bool escaped_local_p )
Return true whether STMT may clobber global memory.
When ESCAPED_LOCAL_P is true escaped local memory is also considered
global.   

References gimple_assign_lhs(), gimple_vdef(), ref_may_alias_global_p(), and TREE_CODE.

Referenced by mark_stmt_if_obviously_necessary().

◆ stmt_may_clobber_ref_p()

bool stmt_may_clobber_ref_p ( gimple * stmt,
tree ref,
bool tbaa_p )

◆ stmt_may_clobber_ref_p_1()

◆ store_kills_ref_p()

static bool store_kills_ref_p ( tree base,
poly_int64 offset,
poly_int64 size,
poly_int64 max_size,
ao_ref * ref )
static
Return true if REF is killed by an store described by
BASE, OFFSET, SIZE and MAX_SIZE.   

References ao_ref::base, known_eq, ao_ref::max_size, mem_ref_offset(), ao_ref::offset, offset, same_addr_size_stores_p(), ao_ref::size, poly_int< N, C >::to_shwi(), TREE_CODE, tree_int_cst_equal(), and TREE_OPERAND.

Referenced by stmt_kills_ref_p().

◆ type_has_components_p()

static bool type_has_components_p ( tree type)
static
Return true if TYPE is a composite type (i.e. we may apply one of handled
components on it).   

References AGGREGATE_TYPE_P, TREE_CODE, and VECTOR_TYPE_P.

Referenced by access_path_may_continue_p().

◆ types_equal_for_same_type_for_tbaa_p()

static bool types_equal_for_same_type_for_tbaa_p ( tree type1,
tree type2,
bool lto_streaming_safe )
static
Return ture if TYPE1 and TYPE2 will always give the same answer
when compared wit hother types using same_type_for_tbaa_p.   

References TYPE_CANONICAL, TYPE_MAIN_VARIANT, and TYPE_STRUCTURAL_EQUALITY_P.

Referenced by ao_compare::compare_ao_refs().

◆ view_converted_memref_p()

bool view_converted_memref_p ( tree base)
Return true if access with BASE is view converted.
Base must not be stripped from inner MEM_REF (&decl)
which is done by ao_ref_base and thus one extra walk
of handled components is needed.   

References same_type_for_tbaa(), TREE_CODE, TREE_OPERAND, and TREE_TYPE.

Referenced by ao_compare::compare_ao_refs(), and reference_alias_ptr_type_1().

◆ walk_aliased_vdefs()

◆ walk_aliased_vdefs_1()

static int walk_aliased_vdefs_1 ( ao_ref * ref,
tree vdef,
bool(* walker )(ao_ref *, tree, void *),
void * data,
bitmap * visited,
unsigned int cnt,
bool * function_entry_reached,
unsigned limit )
static
Based on the memory reference REF call WALKER for each vdef whose
defining statement may clobber REF, starting with VDEF.  If REF
is NULL_TREE, each defining statement is visited.

WALKER is called with REF, the current vdef and DATA.  If WALKER
returns true the walk is stopped, otherwise it continues.

If function entry is reached, FUNCTION_ENTRY_REACHED is set to true.
The pointer may be NULL and then we do not track this information.

At PHI nodes walk_aliased_vdefs forks into one walk for each
PHI argument (but only one walk continues at merge points), the
return value is true if any of the walks was successful.

The function returns the number of statements walked or -1 if
LIMIT stmts were walked and the walk was aborted at this point.
If LIMIT is zero the walk is not aborted.   

References BITMAP_ALLOC, bitmap_set_bit, bitmap_tree_view(), gimple_nop_p(), gimple_phi_arg_def(), gimple_phi_num_args(), gimple_vuse(), i, NULL, SSA_NAME_DEF_STMT, SSA_NAME_VERSION, stmt_may_clobber_ref_p_1(), visited, and walk_aliased_vdefs_1().

Referenced by walk_aliased_vdefs(), and walk_aliased_vdefs_1().

◆ walk_non_aliased_vuses()

void * walk_non_aliased_vuses ( ao_ref * ref,
tree vuse,
bool tbaa_p,
void *(* walker )(ao_ref *, tree, void *),
void *(* translate )(ao_ref *, tree, void *, translate_flags *),
tree(* valueize )(tree),
unsigned & limit,
void * data )
Based on the memory reference REF and its virtual use VUSE call
WALKER for each virtual use that is equivalent to VUSE, including VUSE
itself.  That is, for each virtual use for which its defining statement
does not clobber REF.

WALKER is called with REF, the current virtual use and DATA.  If
WALKER returns non-NULL the walk stops and its result is returned.
At the end of a non-successful walk NULL is returned.

TRANSLATE if non-NULL is called with a pointer to REF, the virtual
use which definition is a statement that may clobber REF and DATA.
If TRANSLATE returns (void *)-1 the walk stops and NULL is returned.
If TRANSLATE returns non-NULL the walk stops and its result is returned.
If TRANSLATE returns NULL the walk continues and TRANSLATE is supposed
to adjust REF and *DATA to make that valid.

VALUEIZE if non-NULL is called with the next VUSE that is considered
and return value is substituted for that.  This can be used to
implement optimistic value-numbering for example.  Note that the
VUSE argument is assumed to be valueized already.

LIMIT specifies the number of alias queries we are allowed to do,
the walk stops when it reaches zero and NULL is returned.  LIMIT
is decremented by the number of alias queries (plus adjustments
done by the callbacks) upon return.

TODO: Cache the vector of equivalent vuses per ref, vuse pair.   

References BITMAP_FREE, get_continuation_for_phi(), gimple_nop_p(), gimple_vuse(), NULL, SSA_NAME_DEF_STMT, stmt_may_clobber_ref_p_1(), timevar_pop(), timevar_push(), TR_TRANSLATE, and visited.

Referenced by avail_exprs_stack::lookup_avail_expr(), vn_reference_lookup(), and vn_reference_lookup_pieces().

Variable Documentation

◆ [struct]

◆ aliasing_component_refs_p_may_alias

unsigned HOST_WIDE_INT aliasing_component_refs_p_may_alias

◆ aliasing_component_refs_p_no_alias

unsigned HOST_WIDE_INT aliasing_component_refs_p_no_alias

◆ call_may_clobber_ref_p_may_alias

unsigned HOST_WIDE_INT call_may_clobber_ref_p_may_alias

◆ call_may_clobber_ref_p_no_alias

unsigned HOST_WIDE_INT call_may_clobber_ref_p_no_alias

◆ modref_baseptr_tests

unsigned HOST_WIDE_INT modref_baseptr_tests

◆ modref_clobber_may_alias

unsigned HOST_WIDE_INT modref_clobber_may_alias

◆ modref_clobber_no_alias

unsigned HOST_WIDE_INT modref_clobber_no_alias

◆ modref_kill_no

unsigned HOST_WIDE_INT modref_kill_no

◆ modref_kill_yes

unsigned HOST_WIDE_INT modref_kill_yes

◆ modref_tests

unsigned HOST_WIDE_INT modref_tests

◆ modref_use_may_alias

unsigned HOST_WIDE_INT modref_use_may_alias

◆ modref_use_no_alias

unsigned HOST_WIDE_INT modref_use_no_alias

◆ nonoverlapping_component_refs_p_may_alias

unsigned HOST_WIDE_INT nonoverlapping_component_refs_p_may_alias

◆ nonoverlapping_component_refs_p_no_alias

unsigned HOST_WIDE_INT nonoverlapping_component_refs_p_no_alias

◆ nonoverlapping_refs_since_match_p_may_alias

unsigned HOST_WIDE_INT nonoverlapping_refs_since_match_p_may_alias

◆ nonoverlapping_refs_since_match_p_must_overlap

unsigned HOST_WIDE_INT nonoverlapping_refs_since_match_p_must_overlap

◆ nonoverlapping_refs_since_match_p_no_alias

unsigned HOST_WIDE_INT nonoverlapping_refs_since_match_p_no_alias

◆ ref_maybe_used_by_call_p_may_alias

unsigned HOST_WIDE_INT ref_maybe_used_by_call_p_may_alias

◆ ref_maybe_used_by_call_p_no_alias

unsigned HOST_WIDE_INT ref_maybe_used_by_call_p_no_alias

◆ refs_may_alias_p_may_alias

unsigned HOST_WIDE_INT refs_may_alias_p_may_alias

◆ refs_may_alias_p_no_alias

unsigned HOST_WIDE_INT refs_may_alias_p_no_alias

◆ stmt_kills_ref_p_no

unsigned HOST_WIDE_INT stmt_kills_ref_p_no

◆ stmt_kills_ref_p_yes

unsigned HOST_WIDE_INT stmt_kills_ref_p_yes