- Generated by
1.8.1.1
|
GCC Middle and Back End API Reference
|
Data Structures | |
| struct | alias_set_entry_d |
Typedefs | |
| typedef struct alias_set_entry_d * | alias_set_entry |
Variables | |
| static vec< rtx, va_gc > * | reg_base_value |
| static rtx * | new_reg_base_value |
| static rtx | arg_base_value |
| static int | unique_id |
| static vec< rtx, va_gc > * | old_reg_base_value |
| static vec< rtx, va_gc > * | reg_known_value |
| static sbitmap | reg_known_equiv_p |
| static bool | copying_arguments |
| static vec< alias_set_entry, va_gc > * | alias_sets |
| static alias_set_type | varargs_set = -1 |
| static alias_set_type | frame_set = -1 |
| static sbitmap | reg_seen |
| static bool | memory_modified |
| typedef struct alias_set_entry_d* alias_set_entry |
|
static |
Return the address of the (N_REFS + 1)th memory reference to ADDR
where SIZE is the size in bytes of the memory reference. If ADDR
is not modified by the memory reference then ADDR is returned.
References canon_rtx(), and offset.
Referenced by memrefs_conflict_p().
|
static |
Walk up the COMPONENT_REF list in X and adjust *OFFSET to compensate for the offset of the field reference. *KNOWN_P says whether the offset is known.
References component_ref_field_offset(), host_integerp(), and tree_low_cst().
Referenced by nonoverlapping_memrefs_p().
| bool alias_set_subset_of | ( | ) |
Return true if the first alias set is a subset of the second.
References alias_set_entry_d::children, get_alias_set_entry(), and alias_set_entry_d::has_zero_child.
Referenced by aliasing_component_refs_p().
| int alias_sets_conflict_p | ( | ) |
Return 1 if the two specified alias sets may conflict.
References alias_sets_must_conflict_p(), alias_set_entry_d::children, get_alias_set_entry(), and alias_set_entry_d::has_zero_child.
Referenced by gimplify_init_ctor_preeval_1(), indirect_ref_may_alias_decl_p(), indirect_refs_may_alias_p(), mems_in_disjoint_alias_sets_p(), refs_may_alias_p_1(), safe_from_p(), set_mem_alias_set(), vect_create_data_ref_ptr(), vectorizable_load(), and vectorizable_store().
| int alias_sets_must_conflict_p | ( | ) |
Return 1 if the two specified alias sets will always conflict.
Referenced by alias_sets_conflict_p(), and objects_must_conflict_p().
| int anti_dependence | ( | ) |
Anti dependence: X is written after read in MEM takes place.
References write_dependence_p().
Referenced by load_kills_store(), memory_modified_1(), sched_analyze_1(), and validate_equiv_mem_from_store().
|
static |
Build a decomposed reference object for querying the alias-oracle from the MEM rtx and store it in *REF. Returns false if MEM is not suitable for the alias-oracle.
References ao_ref_base(), ao_ref_init(), cfun, gimple_df::decls_to_pointers, get_spill_slot_decl(), function::gimple_df, host_integerp(), is_global_var(), and pointer_map_contains().
Referenced by rtx_refs_may_alias_p().
|
static |
Return 0 if the addresses X and Y are known to point to different objects, 1 if they might be pointers to the same object.
References canon_rtx(), find_base_term(), rtx_equal_p(), and unique_base_value_p().
Referenced by may_alias_p(), true_dependence_1(), and write_dependence_p().
| int canon_anti_dependence | ( | const_rtx | mem, |
| bool | mem_canonicalized, | ||
| const_rtx | x, | ||
| enum machine_mode | x_mode, | ||
| rtx | x_addr | ||
| ) |
Likewise, but we already have a canonicalized MEM, and X_ADDR for X. Also, consider X in X_MODE (which might be from an enclosing STRICT_LOW_PART / ZERO_EXTRACT). If MEM_CANONICALIZED is true, MEM is canonicalized.
References write_dependence_p().
Referenced by check_dependence(), and cselib_invalidate_mem().
| rtx canon_rtx | ( | ) |
Returns a canonical version of X, from the point of view alias analysis. (For example, if X is a MEM whose address is a register, and the register has a known value (say a SYMBOL_REF), then a MEM whose address is the SYMBOL_REF is returned.)
References get_reg_known_value(), plus_constant(), and replace_equiv_address_nv().
Referenced by add_insn_mem_dependence(), addr_side_effect_eval(), base_alias_check(), canon_address(), canon_list_insert(), clobber_overlapping_mems(), compute_transp(), cse_insn(), cselib_invalidate_mem(), debug_mem_addr_value(), get_addr_from_global_cache(), get_group_info(), invalidate(), may_alias_p(), memrefs_conflict_p(), record_store(), rtx_equal_for_memref_p(), sched_analyze_1(), sched_analyze_2(), true_dependence_1(), vt_canonicalize_addr(), and write_dependence_p().
| int canon_true_dependence | ( | const_rtx | mem, |
| enum machine_mode | mem_mode, | ||
| rtx | mem_addr, | ||
| const_rtx | x, | ||
| rtx | x_addr | ||
| ) |
Canonical true dependence: X is read after store in MEM takes place. Variant of true_dependence which assumes MEM has already been canonicalized (hence we no longer do that here). The mem_addr argument has been added, since true_dependence_1 computed this value prior to canonicalizing.
References true_dependence_1().
Referenced by check_mem_read_rtx(), compute_transp(), record_store(), scan_reads_nospill(), and vt_canon_true_dep().
| bool component_uses_parent_alias_set | ( | ) |
Return true if all nested component references handled by get_inner_reference in T are such that we should use the alias set provided by the object at the heart of T. This is true for non-addressable components (which don't have their own alias set), as well as components of objects in alias set zero. This later point is a special case wherein we wish to override the alias set used by the component, but we don't have per-FIELD_DECL assignable alias sets.
References get_alias_set(), and handled_component_p().
Referenced by get_alias_set(), and set_mem_attributes_minus_bitpos().
Referenced by nonoverlapping_memrefs_p().
|
static |
Look at the bottom of the COMPONENT_REF list for a DECL, and return it.
| void end_alias_analysis | ( | void | ) |
References reg_base_value, reg_known_equiv_p, reg_known_value, sbitmap_free(), and vec_free().
Referenced by cse_main(), dse_step7(), gcse_after_reload_main(), one_code_hoisting_pass(), one_pre_gcse_pass(), one_store_motion_pass(), reload_cse_regs_1(), sched_finish(), and update_equiv_regs().
|
static |
Referenced by find_base_value(), and record_set().
|
static |
Inside SRC, the source of a SET, find a base address.
References arg_base_value, copying_arguments, find_base_value(), known_base_value_p(), target_default_pointer_address_modes_p(), and vec_safe_length().
| rtx get_addr | ( | ) |
Convert the address X into something we can use. This is done by returning it unchanged unless it is a value; in the latter case we call cselib to get a more useful rtx.
References canonical_cselib_val(), cselib_have_permanent_equivalences(), elt_loc_list::loc, cselib_val_struct::locs, elt_loc_list::next, refs_newer_value_p(), and cselib_val_struct::val_rtx.
Referenced by canon_list_insert(), compute_transp(), cselib_invalidate_mem(), debug_mem_addr_value(), get_addr_from_global_cache(), invalidate(), may_alias_p(), memrefs_conflict_p(), true_dependence_1(), and write_dependence_p().
| alias_set_type get_alias_set | ( | ) |
Return the alias set for T, which may be either a type or an expression. Call language-specific routine for help, if needed.
References component_uses_parent_alias_set(), lang_hooks::get_alias_set, get_deref_alias_set(), get_deref_alias_set_1(), handled_component_p(), new_alias_set(), and record_component_aliases().
Referenced by ao_ref_alias_set(), ao_ref_base_alias_set(), ao_ref_init_from_vn_reference(), assign_stack_temp_for_type(), component_uses_parent_alias_set(), expand_assignment(), expand_builtin_va_copy(), free_lang_data(), get_deref_alias_set(), gimple_get_alias_set(), gimplify_init_constructor(), gimplify_init_ctor_preeval_1(), hash_tree(), indirect_ref_may_alias_decl_p(), objects_must_conflict_p(), pack_ts_type_common_value_fields(), record_component_aliases(), safe_from_p(), same_type_for_tbaa(), set_mem_attributes_minus_bitpos(), store_constructor(), vect_create_data_ref_ptr(), vectorizable_load(), vectorizable_store(), vn_reference_insert(), vn_reference_lookup(), and vn_reference_lookup_3().
|
static |
Referenced by alias_set_subset_of(), alias_sets_conflict_p(), and record_alias_subset().
|
inlinestatic |
Returns a pointer to the alias set entry for ALIAS_SET, if there is such an entry, or NULL otherwise.
References alias_sets.
| alias_set_type get_deref_alias_set | ( | ) |
Return the alias set for the memory pointed to by T, which may be either a type or an expression.
References get_alias_set(), and get_deref_alias_set_1().
Referenced by ao_ref_init_from_vn_reference(), get_alias_set(), indirect_ref_may_alias_decl_p(), and indirect_refs_may_alias_p().
|
static |
Return the alias set for the memory pointed to by T, which may be either a type or an expression. Return -1 if there is nothing special about dereferencing T.
Referenced by get_alias_set(), and get_deref_alias_set().
| alias_set_type get_frame_alias_set | ( | void | ) |
References frame_set, and new_alias_set().
Referenced by gen_frame_mem(), gen_tmp_stack_mem(), and setup_save_areas().
| rtx get_reg_base_value | ( | ) |
Return REG_BASE_VALUE for REGNO. Selective scheduler uses this to avoid using hard registers with non-null REG_BASE_VALUE for renaming.
Referenced by init_regs_for_mode().
| bool get_reg_known_equiv_p | ( | ) |
Similarly for reg_known_equiv_p.
References bitmap_bit_p(), reg_known_equiv_p, reg_known_value, and vec_safe_length().
Referenced by sched_analyze_reg().
| rtx get_reg_known_value | ( | ) |
If a value is known for REGNO, return it.
References reg_known_value, and vec_safe_length().
Referenced by canon_rtx(), deps_may_trap_p(), init_alias_analysis(), and sched_analyze_reg().
| alias_set_type get_varargs_alias_set | ( | void | ) |
References new_alias_set(), and varargs_set.
| void init_alias_analysis | ( | void | ) |
Initialize the aliasing machinery. Initialize the REG_KNOWN_VALUE array.
References bitmap_clear(), changed, copying_arguments, find_reg_equal_equiv_note(), find_reg_note(), free(), get_reg_known_value(), max_reg_num(), memcpy(), memset(), note_stores(), old_reg_base_value, plus_constant(), pre_and_rev_post_order_compute(), prologue_epilogue_contains(), record_set(), reg_known_equiv_p, reg_known_value, reg_overlap_mentioned_p(), reg_seen, regno_reg_rtx, reload_completed, rtx_equal_p(), rtx_varies_p(), sbitmap_alloc(), sbitmap_free(), SET, set_reg_known_equiv_p(), set_reg_known_value(), timevar_pop(), timevar_push(), ui, and vec_safe_grow_cleared().
Referenced by cse_main(), dse_step0(), gcse_after_reload_main(), one_code_hoisting_pass(), one_pre_gcse_pass(), one_store_motion_pass(), reload_cse_regs_1(), sched_init(), and update_equiv_regs().
| void init_alias_target | ( | void | ) |
References arg_base_value, memset(), and unique_base_value().
Referenced by backend_init_target().
|
static |
Referenced by record_alias_subset().
|
static |
Insert the NODE into the splay tree given by DATA. Used by record_alias_subset via splay_tree_foreach.
|
static |
Return true if X is known to be a base value.
Referenced by find_base_term(), and find_base_value().
| int may_alias_p | ( | ) |
Check whether X may be aliased with MEM. Don't do offset-based memory disambiguation & TBAA.
References base_alias_check(), canon_rtx(), find_base_term(), get_addr(), nonoverlapping_memrefs_p(), reg_mentioned_p(), and rtx_refs_may_alias_p().
Referenced by walk_mems_2().
| bool may_be_sp_based_p | ( | ) |
Return true if accesses to address X may alias accesses based on the stack pointer.
References find_base_term().
Referenced by record_store(), and store_killed_in_insn().
Referenced by memory_modified_in_insn_p().
|
static |
References anti_dependence(), memory_modified, and output_dependence().
| bool memory_modified_in_insn_p | ( | ) |
Return true when INSN possibly modify memory contents of MEM (i.e. address can be modified).
References memory_modified, memory_modified_1(), and note_stores().
Referenced by modified_between_p(), and modified_in_p().
| bool memory_must_be_modified_in_insn_p | ( | ) |
Like memory_modified_in_insn_p, but return TRUE if INSN will *DEFINITELY* modify the memory contents of MEM.
References SET, and set_dest_equal_p().
Referenced by noce_can_store_speculate_p().
|
static |
Referenced by memrefs_conflict_p(), true_dependence_1(), and write_dependence_p().
|
static |
Return one if X and Y (memory addresses) reference the same location in memory or if the references overlap. Return zero if they do not overlap, else return minus one in which case they still might reference the same location. C is an offset accumulator. When C is nonzero, we are testing aliases between X and Y + C. XSIZE is the size in bytes of the X reference, similarly YSIZE is the size in bytes for Y. Expect that canon_rtx has been already called for X and Y. If XSIZE or YSIZE is zero, we do not know the amount of memory being referenced (the reference was BLKmode), so make the most pessimistic assumptions. If XSIZE or YSIZE is negative, we may access memory outside the object being referenced as a side effect. This can happen when using AND to align memory references, as is done on the Alpha. Nice to notice that varying addresses cannot conflict with fp if no local variables had their addresses taken, but that's too hard now. ??? Contrary to the tree alias oracle this does not return one for X + non-constant and Y + non-constant when X and Y are equal. If that is fixed the TBAA hack for union type-punning can be removed.
References addr_side_effect_eval(), canon_rtx(), canonical_cselib_val(), get_addr(), elt_loc_list::loc, memrefs_conflict_p(), elt_loc_list::next, offset_overlap_p(), rtx_equal_for_memref_p(), sc, and uc.
Referenced by true_dependence_1().
|
inlinestatic |
Returns nonzero if the alias sets for MEM1 and MEM2 are such that the two MEMs cannot alias each other.
Perform a basic sanity check. Namely, that there are no alias sets if we're not using strict aliasing. This helps to catch bugs whereby someone uses PUT_CODE, but doesn't clear MEM_ALIAS_SET, or where a MEM is allocated in some way other than by the use of gen_rtx_MEM, and the MEM_ALIAS_SET is not cleared. If we begin to use alias sets to indicate that spilled registers cannot alias each other, we might need to remove this check.
References alias_sets_conflict_p().
| alias_set_type new_alias_set | ( | void | ) |
Return a brand-new alias set.
References alias_sets, and vec_safe_push().
Referenced by asan_init_shadow_ptr_types(), expand_builtin_longjmp(), expand_builtin_setjmp_setup(), get_alias_set(), get_frame_alias_set(), get_spill_slot_decl(), get_varargs_alias_set(), and init_varasm_once().
Referenced by true_dependence_1().
|
static |
Return true if we can determine that the fields referenced cannot overlap for any pair of objects.
| int nonoverlapping_memrefs_p | ( | ) |
Return nonzero if we can determine the exprs corresponding to memrefs X and Y and they do not overlap. If LOOP_VARIANT is set, skip offset-based disambiguation
References adjust_offset_for_component_ref(), decl_for_component_ref(), get_spill_slot_decl(), and rtx_equal_p().
Referenced by cse_insn(), may_alias_p(), true_dependence_1(), and write_dependence_p().
| int objects_must_conflict_p | ( | ) |
Return 1 if any MEM object of type T1 will always conflict (using the dependency routines in this file) with any MEM object of type T2. This is used when allocating temporary storage. If T1 and/or T2 are NULL_TREE, it means we know nothing about the storage.
References alias_sets_must_conflict_p(), and get_alias_set().
Referenced by assign_stack_temp_for_type().
|
inlinestatic |
Return TRUE if an object X sized at XSIZE bytes and another object Y sized at YSIZE bytes, starting C bytes after X, may overlap. If any of the sizes is zero, assume an overlap, otherwise use the absolute value of the sizes as the actual sizes.
Referenced by memrefs_conflict_p().
| int output_dependence | ( | ) |
Output dependence: X is written after store in MEM takes place.
References write_dependence_p().
Referenced by memory_modified_1(), sched_analyze_1(), and store_killed_in_pat().
| int read_dependence | ( | ) |
Functions to compute memory dependencies. Since we process the insns in execution order, we can build tables to keep track of what registers are fixed (and not aliased), what registers are varying in known ways, and what registers are varying in unknown ways. If both memory references are volatile, then there must always be a dependence between the two references, since their order can not be changed. A volatile and non-volatile reference can be interchanged though. We also must allow AND addresses, because they may generate accesses outside the object being referenced. This is used to generate aligned addresses from unaligned addresses, for instance, the alpha storeqi_unaligned pattern.
Read dependence: X is read after read in MEM takes place. There can only be a dependence here if both reads are volatile, or if either is an explicit barrier.
Referenced by sched_analyze_2().
| void record_alias_subset | ( | ) |
Indicate that things in SUBSET can alias things in SUPERSET, but that not everything that aliases SUPERSET also aliases SUBSET. For example, in C, a store to an `int' can alias a load of a structure containing an `int', and vice versa. But it can't alias a load of a 'double' member of the same structure. Here, the structure would be the SUPERSET and `int' the SUBSET. This relationship is also described in the comment at the beginning of this file. This function should be called only once per SUPERSET/SUBSET pair. It is illegal for SUPERSET to be zero; everything is implicitly a subset of alias set zero.
References alias_set_entry_d::alias_set, alias_set_entry_d::children, get_alias_set_entry(), alias_set_entry_d::has_zero_child, and insert_subset_children().
Referenced by record_component_aliases().
| void record_component_aliases | ( | ) |
Record that component types of TYPE, if any, are part of that type for aliasing purposes. For record types, we only record component types for fields that are not marked non-addressable. For array types, we only record the component type if it is not marked non-aliased.
References get_alias_set(), and record_alias_subset().
Referenced by get_alias_set().
Referenced by init_alias_analysis().
|
static |
References bitmap_bit_p(), bitmap_set_bit(), find_base_value(), reg_seen, and unique_base_value().
|
static |
Callback for for_each_rtx, that returns 1 upon encountering a VALUE whose UID is greater than the int uid that D points to.
Referenced by refs_newer_value_p().
|
static |
Return TRUE if EXPR refers to a VALUE whose uid is greater than that of V.
References for_each_rtx(), and refs_newer_value_cb().
Referenced by get_addr().
Referenced by memrefs_conflict_p(), and rtx_equal_for_memref_p().
|
static |
Return 1 if X and Y are identical-looking rtx's. Expect that X and Y has been already canonicalized. We use the data in reg_known_value above to see if two registers with different numbers are, in fact, equivalent.
References canon_rtx(), rtx_equal_for_memref_p(), and rtx_equal_p().
|
static |
Query the alias-oracle on whether the two memory rtx X and MEM may alias. If TBAA_P is set also apply TBAA. Returns true if the two rtxen may alias, false otherwise.
References ao_ref_from_mem(), and refs_may_alias_p_1().
Referenced by may_alias_p(), true_dependence_1(), and write_dependence_p().
|
inlinestatic |
Return TRUE if the destination of a set is rtx identical to ITEM.
References rtx_equal_p().
Referenced by memory_must_be_modified_in_insn_p().
|
static |
References bitmap_clear_bit(), bitmap_set_bit(), reg_known_equiv_p, reg_known_value, and vec_safe_length().
Referenced by init_alias_analysis().
|
static |
| int true_dependence | ( | ) |
True dependence: X is read after store in MEM takes place.
References true_dependence_1().
Referenced by find_mem_conflicts(), load_kills_store(), memref_referenced_p(), mems_conflict_for_gcse_p(), safe_from_p(), and sched_analyze_2().
|
static |
Helper for true_dependence and canon_true_dependence. Checks for true dependence: X is read after store in MEM takes place. If MEM_CANONICALIZED is FALSE, then X_ADDR and MEM_ADDR should be NULL_RTX, and the canonical addresses of MEM and X are both computed here. If MEM_CANONICALIZED, then MEM must be already canonicalized. If X_ADDR is non-NULL, it is used in preference of XEXP (x, 0). Returns 1 if there is a true dependence, 0 otherwise.
References base_alias_check(), canon_rtx(), find_base_term(), get_addr(), memrefs_conflict_p(), mems_in_disjoint_alias_sets_p(), nonoverlapping_component_refs_p(), nonoverlapping_memrefs_p(), reg_mentioned_p(), and rtx_refs_may_alias_p().
Referenced by canon_true_dependence(), and true_dependence().
|
static |
Create a new, unique base with id ID.
Referenced by init_alias_target(), and record_set().
|
static |
Return true if accesses based on any other base value cannot alias those based on X.
Referenced by base_alias_check().
| void vt_equate_reg_base_value | ( | ) |
Equate REG_BASE_VALUE (reg1) to REG_BASE_VALUE (reg2). Special API for var-tracking pass purposes.
Referenced by vt_init_cfa_base().
|
static |
Returns nonzero if a write to X might alias a previous read from (or, if WRITEP is true, a write to) MEM. If X_CANONCALIZED is true, then X_ADDR is the canonicalized address of X, and X_MODE the mode for that access. If MEM_CANONICALIZED is true, MEM is canonicalized.
References base_alias_check(), canon_rtx(), find_base_term(), get_addr(), memrefs_conflict_p(), nonoverlapping_memrefs_p(), reg_mentioned_p(), and rtx_refs_may_alias_p().
Referenced by anti_dependence(), canon_anti_dependence(), and output_dependence().
|
static |
The splay-tree used to store the various alias set entries.
Referenced by get_alias_set_entry(), and new_alias_set().
|
static |
The single VOIDmode ADDRESS that represents all argument bases. It has id 0.
Referenced by find_base_value(), and init_alias_target().
|
static |
True when scanning insns from the start of the rtl to the NOTE_INSN_FUNCTION_BEG note.
Referenced by find_base_value(), and init_alias_analysis().
|
static |
Likewise, but used for the fixed portions of the frame, e.g., register save areas.
Referenced by get_frame_alias_set().
|
static |
Set MEMORY_MODIFIED when X modifies DATA (that is assumed to be memory reference.
Referenced by memory_modified_1(), and memory_modified_in_insn_p().
|
static |
We preserve the copy of old array around to avoid amount of garbage produced. About 8% of garbage produced were attributed to this array.
Referenced by init_alias_analysis().
reg_base_value[N] gives an address to which register N is related.
If all sets after the first add or subtract to the current value
or otherwise modify it so it does not point to a different top level
object, reg_base_value[N] is equal to the address part of the source
of the first set.
A base address can be an ADDRESS, SYMBOL_REF, or LABEL_REF. ADDRESS
expressions represent three types of base:
1. incoming arguments. There is just one ADDRESS to represent all
arguments, since we do not know at this level whether accesses
based on different arguments can alias. The ADDRESS has id 0.
2. stack_pointer_rtx, frame_pointer_rtx, hard_frame_pointer_rtx
(if distinct from frame_pointer_rtx) and arg_pointer_rtx.
Each of these rtxes has a separate ADDRESS associated with it,
each with a negative id.
GCC is (and is required to be) precise in which register it
chooses to access a particular region of stack. We can therefore
assume that accesses based on one of these rtxes do not alias
accesses based on another of these rtxes.
3. bases that are derived from malloc()ed memory (REG_NOALIAS).
Each such piece of memory has a separate ADDRESS associated
with it, each with an id greater than 0.
Accesses based on one ADDRESS do not alias accesses based on other
ADDRESSes. Accesses based on ADDRESSes in groups (2) and (3) do not
alias globals either; the ADDRESSes have Pmode to indicate this.
The ADDRESS in group (1) _may_ alias globals; it has VOIDmode to
indicate this.
Referenced by end_alias_analysis().
|
static |
Vector recording for each reg_known_value whether it is due to a REG_EQUIV note. Future passes (viz., reload) may replace the pseudo with the equivalent expression and so we account for the dependences that would be introduced if that happens. The REG_EQUIV notes created in assign_parms may mention the arg pointer, and there are explicit insns in the RTL that modify the arg pointer. Thus we must ensure that such insns don't get scheduled across each other because that would invalidate the REG_EQUIV notes. One could argue that the REG_EQUIV notes are wrong, but solving the problem in the scheduler will likely give better code, so we do it here.
Referenced by end_alias_analysis(), get_reg_known_equiv_p(), init_alias_analysis(), and set_reg_known_equiv_p().
Vector indexed by N giving the initial (unchanging) value known for pseudo-register N. This vector is initialized in init_alias_analysis, and does not change until end_alias_analysis is called.
Referenced by end_alias_analysis(), get_reg_known_equiv_p(), get_reg_known_value(), init_alias_analysis(), set_reg_known_equiv_p(), and set_reg_known_value().
|
static |
Called from init_alias_analysis indirectly through note_stores, or directly if DEST is a register with a REG_NOALIAS note attached. SET is null in the latter case.
While scanning insns to find base values, reg_seen[N] is nonzero if register N has been set in this function.
Referenced by init_alias_analysis(), and record_set().
|
static |
Used to allocate unique ids to each REG_NOALIAS ADDRESS.
|
static |
Allocate an alias set for use in storing and reading from the varargs spill area.
Referenced by get_varargs_alias_set().
1.8.1.1