#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"
Macros | |
| #define | DEF_SYNC_BUILTIN(ENUM, NAME, TYPE, ATTRS) case ENUM: |
Macro Definition Documentation
◆ DEF_SYNC_BUILTIN
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(), ggc_alloc(), TREE_TYPE, and type_has_components_p().
Referenced by aliasing_component_refs_p().
◆ aliasing_component_refs_p()
|
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, ggc_alloc(), 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 |
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(), ggc_alloc(), 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 |
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(), ggc_alloc(), nonoverlapping_component_refs_p(), and nonoverlapping_refs_since_match_p().
Referenced by aliasing_component_refs_walk().
◆ ao_ref_alias_ptr_type()
Returns a type satisfying get_deref_alias_set (type) == ao_ref_alias_set (REF).
References ggc_alloc(), 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()
| alias_set_type ao_ref_alias_set | ( | ao_ref * | ref | ) |
Returns the reference alias set of the memory reference *REF.
References get_alias_set(), ao_ref::ref, and ao_ref::ref_alias_set.
Referenced by call_may_clobber_ref_p_1(), ao_compare::compare_ao_refs(), compute_avail(), dse_optimize_redundant_stores(), eliminate_dom_walker::eliminate_stmt(), gather_mem_refs_stmt(), ao_compare::hash_ao_ref(), modref_may_conflict(), ref_maybe_used_by_call_p_1(), refs_may_alias_p_2(), refs_same_for_tbaa_p(), visit_reference_op_store(), vn_reference_insert(), vn_reference_lookup(), and vn_reference_lookup_3().
◆ 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(), ggc_alloc(), poly_int< N, C >::is_constant(), offset, ao_ref::offset, and ao_ref::ref.
Referenced by compute_trims().
◆ ao_ref_base()
Returns the base object of the memory reference *REF.
References ao_ref::base, get_ref_base_and_extent(), ao_ref::max_size, ao_ref::offset, ao_ref::ref, and ao_ref::size.
Referenced by ao_ref_from_mem(), call_may_clobber_ref_p_1(), ao_compare::compare_ao_refs(), default_ref_may_alias_errno(), gather_mem_refs_stmt(), ao_compare::hash_ao_ref(), mark_aliased_reaching_defs_necessary_1(), maybe_warn_operand(), ptr_deref_may_alias_ref_p_1(), ref_may_alias_global_p(), ref_maybe_used_by_call_p_1(), ref_maybe_used_by_stmt_p(), refs_may_alias_p_2(), stmt_kills_ref_p(), valid_ao_ref_for_dse(), valid_ao_ref_kill_for_dse(), vn_reference_lookup(), vn_reference_lookup_2(), and vn_reference_lookup_3().
◆ ao_ref_base_alias_ptr_type()
Returns a type satisfying get_deref_alias_set (type) == ao_ref_base_alias_set (REF).
References ggc_alloc(), 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()
| alias_set_type ao_ref_base_alias_set | ( | ao_ref * | ref | ) |
Returns the base object alias set of the memory reference *REF.
References ao_ref::base_alias_set, get_alias_set(), ggc_alloc(), handled_component_p(), ao_ref::ref, TREE_CODE, and TREE_OPERAND.
Referenced by call_may_clobber_ref_p_1(), ao_compare::compare_ao_refs(), compute_avail(), dse_optimize_redundant_stores(), eliminate_dom_walker::eliminate_stmt(), gather_mem_refs_stmt(), ao_compare::hash_ao_ref(), modref_may_conflict(), ref_maybe_used_by_call_p_1(), refs_may_alias_p_2(), refs_same_for_tbaa_p(), visit_reference_op_store(), vn_reference_insert(), vn_reference_lookup(), and vn_reference_lookup_3().
◆ ao_ref_init()
Initializes the alias-oracle reference representation *R from REF.
References NULL_TREE, r, and TREE_THIS_VOLATILE.
Referenced by ao_ref_from_mem(), call_may_clobber_ref_p(), ipa_icf_gimple::func_checker::compare_operand(), compute_avail(), detect_type_change_from_memory_writes(), determine_known_aggregate_parts(), dse_classify_store(), dse_optimize_redundant_stores(), eliminate_dom_walker::eliminate_stmt(), pcom_worker::find_looparound_phi(), gather_mem_refs_stmt(), ipa_polymorphic_call_context::get_dynamic_type(), ipa_icf::sem_function::hash_stmt(), ifcvt_local_dce(), initialize_ao_ref_for_dse(), avail_exprs_stack::lookup_avail_expr(), mark_aliased_reaching_defs_necessary(), mem_ref_alloc(), oacc_entry_exit_ok_1(), param_change_prob(), parm_preserved_before_stmt_p(), parm_ref_data_preserved_p(), ref_maybe_used_by_call_p_1(), ref_maybe_used_by_stmt_p(), refs_anti_dependent_p(), refs_may_alias_p(), refs_may_alias_p(), refs_output_dependent_p(), refs_same_for_tbaa_p(), stmt_kills_ref_p(), stmt_may_clobber_ref_p(), stmt_may_clobber_ref_p_1(), unmodified_parm_1(), vect_slp_analyze_load_dependences(), vect_slp_analyze_store_dependences(), visit_reference_op_call(), visit_reference_op_store(), vn_reference_insert(), vn_reference_lookup(), vn_reference_lookup_3(), vn_walk_cb_data::vn_walk_cb_data(), vuse_semi_invariant_p(), and warn_uninitialized_vars().
◆ 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(), ggc_alloc(), 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, offset, ao_ref::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()
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(), ggc_alloc(), 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()
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()
If the call in statement CALL may clobber the memory reference REF return true, otherwise return false.
References alias_stats, ao_ref_alias_set(), ao_ref_base(), ao_ref_base_alias_set(), ao_ref_init_from_ptr_and_size(), ao_ref::base, bitmap_bit_p, check_fnspec(), CONSTANT_CLASS_P, DECL_P, dump_file, dump_flags, symtab_node::dump_name(), ECF_CONST, ECF_LOOPING_CONST_OR_PURE, ECF_NOVOPS, ECF_PURE, cgraph_node::get(), get_deref_alias_set(), get_modref_function_summary(), ggc_alloc(), gimple_call_arg(), gimple_call_clobber_set(), gimple_call_flags(), gimple_call_fndecl(), gimple_call_internal_fn(), gimple_call_internal_p(), internal_fn_stored_value_index(), ipa_reference_get_written_global(), ipa_reference_var_uid(), is_global_var(), may_be_aliased(), modref_may_conflict(), NULL_TREE, print_generic_expr(), print_gimple_stmt(), pt_solution_includes(), pt_solutions_intersect(), ao_ref::ref, refs_may_alias_p_1(), SSA_NAME_POINTS_TO_READONLY_MEMORY, SSA_NAME_PTR_INFO, targetm, TDF_DETAILS, TREE_CODE, TREE_OPERAND, TREE_READONLY, TREE_STATIC, TREE_TYPE, TYPE_SIZE_UNIT, VAR_P, and ao_ref::volatile_p.
Referenced by call_may_clobber_ref_p(), stmt_may_clobber_ref_p_1(), and vn_reference_lookup_3().
◆ cheap_array_ref_low_bound()
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 ggc_alloc(), 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()
Check if REF conflicts with call using "fn spec" attribute. If CLOBBER is true we are checking for writes, otherwise check loads. Return 0 if there are no conflicts (except for possible function call argument reads), 1 if there are conflicts and -1 if we can not decide by fn spec.
References ao_ref_init_from_ptr_and_range(), attr_fnspec::arg_access_size_given_by_type_p(), attr_fnspec::arg_max_access_size_given_by_arg_p(), attr_fnspec::arg_maybe_read_p(), attr_fnspec::arg_maybe_written_p(), attr_fnspec::arg_specified_p(), BUILT_IN_NORMAL, coeffs_in_range_p(), DECL_FUNCTION_CODE(), attr_fnspec::errno_maybe_written_p(), ggc_alloc(), gimple_call_arg(), gimple_call_builtin_p(), gimple_call_fndecl(), gimple_call_fnspec(), gimple_call_num_args(), attr_fnspec::global_memory_read_p(), attr_fnspec::global_memory_written_p(), HOST_WIDE_INT_MAX, i, attr_fnspec::known_p(), NULL_TREE, POINTER_TYPE_P, poly_int_tree_p(), refs_may_alias_p_1(), targetm, TREE_CHAIN, TREE_TYPE, TREE_VALUE, TYPE_ARG_TYPES, and TYPE_SIZE_UNIT.
Referenced by call_may_clobber_ref_p_1(), and ref_maybe_used_by_call_p_1().
◆ compare_sizes()
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 ggc_alloc(), known_lt, and poly_int_tree_p().
Referenced by compare_type_sizes(), and indirect_ref_may_alias_decl_p().
◆ compare_type_sizes()
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(), ggc_alloc(), 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()
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(), ggc_alloc(), 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(), and ggc_alloc().
◆ debug() [2/2]
| DEBUG_FUNCTION void debug | ( | pt_solution * | ptr | ) |
References debug, and ggc_alloc().
◆ debug_alias_info()
| DEBUG_FUNCTION void debug_alias_info | ( | void | ) |
Dump alias information on stderr.
References dump_alias_info(), and ggc_alloc().
◆ 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(), and ggc_alloc().
◆ decl_refs_may_alias_p()
|
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, ggc_alloc(), handled_component_p(), known_eq, nonoverlapping_refs_since_match_p(), and NULL.
Referenced by refs_may_alias_p_2().
◆ dump_alias_info()
Dump alias information on FILE.
References cfun, current_function_decl, lang_hooks::decl_printable_name, dump_points_to_info_for(), dump_points_to_solution(), dump_variable(), FOR_EACH_LOCAL_DECL, FOR_EACH_SSA_NAME, ggc_alloc(), i, may_be_aliased(), POINTER_TYPE_P, SSA_NAME_IN_FREE_LIST, SSA_NAME_PTR_INFO, and TREE_TYPE.
Referenced by compute_may_aliases(), and debug_alias_info().
◆ dump_alias_stats()
References alias_stats, dump_alias_stats_in_alias_c(), ggc_alloc(), and HOST_WIDE_INT_PRINT_DEC.
Referenced by dump_memory_report().
◆ dump_points_to_info_for()
Dump points-to information for SSA_NAME PTR into FILE.
References dump_flags, dump_points_to_solution(), ggc_alloc(), print_generic_expr(), and SSA_NAME_PTR_INFO.
Referenced by debug_points_to_info_for(), dump_alias_info(), and dump_variable().
◆ dump_points_to_solution()
| void dump_points_to_solution | ( | FILE * | file, |
| struct pt_solution * | pt ) |
Dump the points-to set *PT into FILE.
References pt_solution::anything, pt_solution::const_pool, dump_decl_set(), pt_solution::escaped, ggc_alloc(), pt_solution::ipa_escaped, pt_solution::nonlocal, pt_solution::null, ptr_info_def::pt, pt_solution::vars, pt_solution::vars_contains_escaped, pt_solution::vars_contains_escaped_heap, pt_solution::vars_contains_interposable, pt_solution::vars_contains_nonlocal, and pt_solution::vars_contains_restrict.
Referenced by debug(), dump_alias_info(), and dump_points_to_info_for().
◆ 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 *(*)(ao_ref *, tree, void *, translate_flags *) | translate, | ||
| 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(), ggc_alloc(), 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 |
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, ggc_alloc(), 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 |
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, ggc_alloc(), 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 |
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(), ggc_alloc(), 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()
|
static |
Returns true if and only if REF may alias any access stored in TT. IF TBAA_P is true, use TBAA oracle.
References alias_sets_conflict_p(), alias_stats, ao_ref_alias_set(), ao_ref_base_alias_set(), ao_ref::base, dbg_cnt(), ggc_alloc(), integer_zerop(), MODREF_GLOBAL_MEMORY_PARM, POINTER_TYPE_P, ptr_deref_may_alias_ref_p_1(), ao_ref::ref, ref_may_alias_global_p(), refs_may_alias_p_1(), and TREE_TYPE.
Referenced by call_may_clobber_ref_p_1(), and ref_maybe_used_by_call_p_1().
◆ ncr_compar()
qsort compare function to sort FIELD_DECLs after their DECL_FIELD_CONTEXT TYPE_UID.
References ggc_alloc(), and ncr_type_uid().
Referenced by nonoverlapping_component_refs_p().
◆ ncr_type_uid()
|
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()
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(), ggc_alloc(), 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 |
Return true if we can determine that the fields referenced cannot overlap for any pair of objects. This relies on TBAA.
References alias_stats, DECL_FIELD_CONTEXT, ends_tbaa_access_path_p(), ggc_alloc(), handled_component_p(), i, ncr_compar(), ncr_type_uid(), nonoverlapping_component_refs_p_1(), same_type_for_tbaa(), TREE_CODE, TREE_OPERAND, and y.
Referenced by aliasing_component_refs_p(), aliasing_matching_component_refs_p(), indirect_ref_may_alias_decl_p(), and indirect_refs_may_alias_p().
◆ nonoverlapping_component_refs_p_1()
|
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, ggc_alloc(), 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 |
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, ggc_alloc(), 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()
Return true if dereferencing PTR may alias DECL. The caller is responsible for applying TBAA to see if PTR may access DECL at all.
References compare_base_decls(), CONSTANT_CLASS_P, DECL_P, get_base_address(), ggc_alloc(), may_be_aliased(), POINTER_TYPE_P, pt_solution_includes(), ptr_deref_may_alias_decl_p(), SSA_NAME_PTR_INFO, STRIP_NOPS, TREE_CODE, TREE_OPERAND, TREE_TYPE, and VAR_P.
Referenced by indirect_ref_may_alias_decl_p(), ptr_deref_may_alias_decl_p(), ptr_deref_may_alias_ref_p_1(), and ptr_derefs_may_alias_p().
◆ ptr_deref_may_alias_global_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 ggc_alloc(), 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()
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, ggc_alloc(), 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()
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(), ggc_alloc(), POINTER_TYPE_P, 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()
Returns true if PTR1 and PTR2 compare unequal because of points-to.
References decl_binds_to_current_def_p(), DECL_EXTERNAL, varpool_node::get(), get_base_address(), ggc_alloc(), integer_zerop(), symtab_node::nonzero_address(), NULL_TREE, pt_solution_includes(), pt_solution_includes_const_pool(), pt_solutions_intersect(), SSA_NAME_PTR_INFO, TREE_CODE, TREE_OPERAND, TREE_STATIC, and VAR_P.
◆ ref_may_alias_global_p() [1/2]
References ao_ref_base(), ggc_alloc(), and ref_may_alias_global_p_1().
Referenced by dse_classify_store(), modref_may_conflict(), stmt_kills_ref_p(), and stmt_may_clobber_global_p().
◆ ref_may_alias_global_p() [2/2]
References get_base_address(), ggc_alloc(), and ref_may_alias_global_p_1().
◆ ref_may_alias_global_p_1()
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, ggc_alloc(), 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()
References alias_stats, and ref_maybe_used_by_call_p_1().
Referenced by ref_maybe_used_by_stmt_p().
◆ ref_maybe_used_by_call_p_1()
If the call CALL may use the memory reference REF return true, otherwise return false.
References alias_stats, ao_ref_alias_set(), ao_ref_base(), ao_ref_base_alias_set(), ao_ref_init(), ao_ref_init_from_ptr_and_size(), ao_ref::base, symtab_node::binds_to_current_def_p(), bitmap_bit_p, check_fnspec(), DECL_P, dump_file, dump_flags, symtab_node::dump_name(), EAF_NO_DIRECT_READ, EAF_UNUSED, ECF_CONST, ECF_NOVOPS, cgraph_node::get(), get_deref_alias_set(), get_modref_function_summary(), ggc_alloc(), gimple_call_arg(), gimple_call_arg_flags(), gimple_call_flags(), gimple_call_fndecl(), gimple_call_internal_fn(), gimple_call_internal_p(), gimple_call_lhs(), gimple_call_num_args(), gimple_call_use_set(), i, ipa_reference_get_read_global(), ipa_reference_var_uid(), is_gimple_min_invariant(), is_global_var(), may_be_aliased(), modref_may_conflict(), NULL_TREE, print_generic_expr(), print_gimple_stmt(), process_args(), pt_solution_includes(), pt_solutions_intersect(), r, ao_ref::ref, refs_may_alias_p_1(), SSA_NAME_PTR_INFO, TDF_DETAILS, TREE_CODE, TREE_OPERAND, TREE_STATIC, TREE_TYPE, TYPE_SIZE_UNIT, VAR_P, and ao_ref::volatile_p.
Referenced by ref_maybe_used_by_call_p(), and stmt_kills_ref_p().
◆ ref_maybe_used_by_stmt_p() [1/2]
If the statement STMT may use the memory reference REF return true, otherwise return false.
References ao_ref_base(), DECL_P, ggc_alloc(), gimple_assign_rhs1(), gimple_assign_rhs_code(), gimple_assign_single_p(), gimple_return_retval(), is_gimple_assign(), is_gimple_call(), is_gimple_min_invariant(), is_gimple_reg(), is_global_var(), ptr_deref_may_alias_global_p(), ref_maybe_used_by_call_p(), refs_may_alias_p(), TREE_CODE, and TREE_OPERAND.
Referenced by dest_safe_for_nrv_p(), dse_classify_store(), find_tail_calls(), propagate_with_phi(), ref_conflicts_with_region(), ref_indep_loop_p(), ref_maybe_used_by_stmt_p(), statement_sink_location(), and vect_slp_analyze_store_dependences().
◆ ref_maybe_used_by_stmt_p() [2/2]
References ao_ref_init(), r, and ref_maybe_used_by_stmt_p().
◆ refs_anti_dependent_p()
Returns true if there is a anti-dependence for the STORE that executes after the LOAD.
References ao_ref_init(), ggc_alloc(), and refs_may_alias_p_1().
Referenced by dr_may_alias_p().
◆ refs_may_alias_p() [1/2]
References ao_ref_init(), ggc_alloc(), and refs_may_alias_p_1().
Referenced by dr_may_alias_p(), expand_assignment(), and ref_maybe_used_by_stmt_p().
◆ refs_may_alias_p() [2/2]
References ao_ref_init(), ggc_alloc(), and refs_may_alias_p_1().
◆ refs_may_alias_p_1()
Return true, if the two memory references REF1 and REF2 may alias and update statistics.
References alias_stats, ggc_alloc(), and refs_may_alias_p_2().
Referenced by call_may_clobber_ref_p_1(), check_fnspec(), gimple_fold_builtin_memory_op(), mem_refs_may_alias_p(), modref_may_conflict(), ref_maybe_used_by_call_p_1(), refs_anti_dependent_p(), refs_may_alias_p(), refs_may_alias_p(), refs_output_dependent_p(), rtx_refs_may_alias_p(), stmt_may_clobber_ref_p_1(), and vn_reference_lookup_3().
◆ refs_may_alias_p_2()
Return true, if the two memory references REF1 and REF2 may alias.
References alias_sets_conflict_p(), ao_ref_alias_set(), ao_ref_base(), ao_ref_base_alias_set(), CONSTANT_CLASS_P, DECL_P, decl_refs_may_alias_p(), gcc_checking_assert, gcc_unreachable, ggc_alloc(), handled_component_p(), indirect_ref_may_alias_decl_p(), indirect_refs_may_alias_p(), MR_DEPENDENCE_BASE, MR_DEPENDENCE_CLIQUE, SSA_NAME_POINTS_TO_READONLY_MEMORY, TREE_CODE, and TREE_OPERAND.
Referenced by refs_may_alias_p_1().
◆ refs_output_dependent_p()
Returns true if there is a output dependence for the stores STORE1 and STORE2.
References ao_ref_init(), ggc_alloc(), and refs_may_alias_p_1().
Referenced by dr_may_alias_p().
◆ same_addr_size_stores_p()
|
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, ggc_alloc(), integer_zerop(), known_eq, NULL, poly_int_tree_p(), 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()
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(), ggc_alloc(), 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]
If STMT kills the memory reference REF return true, otherwise return false.
References alias_stats, ao_ref_base(), ao_ref_init_from_ptr_and_size(), array_ref_flexible_size_p(), ao_ref::base, symtab_node::binds_to_current_def_p(), BUILT_IN_NORMAL, cfun, dbg_cnt(), DECL_FUNCTION_CODE(), dump_file, dump_flags, symtab_node::dump_name(), fold_build2, cgraph_node::get(), get_modref_function_summary(), get_ref_base_and_extent(), ggc_alloc(), gimple_call_arg(), gimple_call_builtin_p(), gimple_call_fndecl(), gimple_call_lhs(), gimple_get_lhs(), gimple_has_lhs(), handled_component_p(), integer_zero_node, is_gimple_call(), kill, ao_ref::max_size_known_p(), NULL, NULL_TREE, OEP_ADDRESS_OF, OEP_MATCH_SIDE_EFFECTS, offset, operand_equal_p(), poly_int_tree_p(), print_generic_expr(), print_gimple_stmt(), ao_ref::ref, ref_may_alias_global_p(), ref_maybe_used_by_call_p_1(), stmt_can_throw_external(), stmt_can_throw_internal(), store_kills_ref_p(), TDF_DETAILS, TREE_CODE, TREE_OPERAND, TREE_TYPE, and TYPE_SIZE.
Referenced by check_defs(), dse_classify_store(), dse_optimize_redundant_stores(), statement_sink_location(), stmt_kills_ref_p(), and vn_reference_lookup_3().
◆ stmt_kills_ref_p() [2/2]
References ao_ref_init(), r, and stmt_kills_ref_p().
◆ stmt_may_clobber_global_p()
Return true whether STMT may clobber global memory. When ESCAPED_LOCAL_P is true escaped local memory is also considered global.
References ggc_alloc(), 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()
References ao_ref_init(), r, and stmt_may_clobber_ref_p_1().
Referenced by compute_avail(), find_local_vars_to_propagate(), and find_replaceable_in_bb().
◆ stmt_may_clobber_ref_p_1()
If the statement STMT may clobber the memory reference REF return true, otherwise return false.
References ao_ref_init(), call_may_clobber_ref_p_1(), ggc_alloc(), gimple_assign_lhs(), gimple_assign_single_p(), gimple_call_lhs(), is_gimple_call(), r, refs_may_alias_p_1(), and TREE_CODE.
Referenced by determine_known_aggregate_parts(), pcom_worker::find_looparound_phi(), maybe_invalidate(), maybe_skip_until(), ref_conflicts_with_region(), ref_indep_loop_p(), stmt_may_clobber_ref_p(), value_dies_in_block_x(), vect_slp_analyze_load_dependences(), vect_slp_analyze_store_dependences(), visit_reference_op_call(), vuse_semi_invariant_p(), walk_aliased_vdefs_1(), and walk_non_aliased_vuses().
◆ store_kills_ref_p()
|
static |
Return true if REF is killed by an store described by BASE, OFFSET, SIZE and MAX_SIZE.
References ao_ref::base, ggc_alloc(), known_eq, ao_ref::max_size, mem_ref_offset(), offset, ao_ref::offset, same_addr_size_stores_p(), ao_ref::size, TREE_CODE, tree_int_cst_equal(), and TREE_OPERAND.
Referenced by stmt_kills_ref_p().
◆ type_has_components_p()
Return true if TYPE is a composite type (i.e. we may apply one of handled components on it).
References AGGREGATE_TYPE_P, ggc_alloc(), TREE_CODE, and VECTOR_TYPE_P.
Referenced by access_path_may_continue_p().
◆ types_equal_for_same_type_for_tbaa_p()
|
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 ggc_alloc(), TYPE_CANONICAL, TYPE_MAIN_VARIANT, and TYPE_STRUCTURAL_EQUALITY_P.
Referenced by ao_compare::compare_ao_refs().
◆ view_converted_memref_p()
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 ggc_alloc(), 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()
| int walk_aliased_vdefs | ( | ao_ref * | ref, |
| tree | vdef, | ||
| bool(*)(ao_ref *, tree, void *) | walker, | ||
| void * | data, | ||
| bitmap * | visited, | ||
| bool * | function_entry_reached, | ||
| unsigned int | limit ) |
References BITMAP_FREE, ggc_alloc(), NULL, timevar_pop(), timevar_push(), visited, and walk_aliased_vdefs_1().
Referenced by detect_type_change_from_memory_writes(), ipa_polymorphic_call_context::get_dynamic_type(), mark_aliased_reaching_defs_necessary(), mark_all_reaching_defs_necessary(), maybe_warn_operand(), param_change_prob(), parm_preserved_before_stmt_p(), parm_ref_data_pass_through_p(), parm_ref_data_preserved_p(), and unmodified_parm_1().
◆ walk_aliased_vdefs_1()
|
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(), ggc_alloc(), 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 *(*)(ao_ref *, tree, void *) | walker, | ||
| void *(*)(ao_ref *, tree, void *, translate_flags *) | translate, | ||
| tree(*)(tree) | valueize, | ||
| 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(), ggc_alloc(), 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]
| struct { ... } alias_stats |
Query statistics for the different low-level disambiguators. A high-level query may trigger multiple of them.
Referenced by aliasing_component_refs_p(), aliasing_matching_component_refs_p(), call_may_clobber_ref_p(), call_may_clobber_ref_p_1(), dump_alias_stats(), modref_may_conflict(), nonoverlapping_component_refs_p(), nonoverlapping_refs_since_match_p(), ref_maybe_used_by_call_p(), ref_maybe_used_by_call_p_1(), refs_may_alias_p_1(), and stmt_kills_ref_p().
◆ 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 |
