|
GCC Middle and Back End API Reference
|
#include "addresses.h"
Data Structures | |
| struct | set_of_data |
| struct | for_each_inc_dec_ops |
| struct | parms_set_data |
Variables | |
| static int | non_rtx_starting_operands [NUM_RTX_CODE] |
| static unsigned int | num_sign_bit_copies_in_rep [MAX_MODE_INT+1][MAX_MODE_INT+1] |
| void add_reg_note | ( | ) |
Add register note with kind KIND and datum DATUM to INSN.
References alloc_reg_note().
| int address_cost | ( | ) |
Return cost of address expression X. Expect that X is properly formed address reference. SPEED parameter specify whether costs optimized for speed or size should be returned.
References memory_address_addr_space_p(), and targetm.
| rtx alloc_reg_note | ( | ) |
Allocate a register note with kind KIND and datum DATUM. LIST is stored as the pointer to the next register note.
References alloc_EXPR_LIST(), and alloc_INSN_LIST().
| int auto_inc_p | ( | ) |
Return 1 if X is an autoincrement side effect and the register is not the stack pointer.
|
static |
Evaluate the likelihood of X being a base or index value, returning positive if it is likely to be a base, negative if it is likely to be an index, and 0 if we can't tell. Make the magnitude of the return value reflect the amount of confidence we have in the answer. MODE, AS, OUTER_CODE and INDEX_CODE are as for ok_for_base_p_1.
References must_be_base_p(), must_be_index_p(), and ok_for_base_p_1().
Referenced by decompose_normal_address().
|
static |
The function cached_nonzero_bits is a wrapper around nonzero_bits1. It avoids exponential behavior in nonzero_bits1 when X has identical subexpressions on the first or the second level.
References nonzero_bits1().
Referenced by nonzero_bits(), and nonzero_bits1().
|
static |
See the macro definition above.
The function cached_num_sign_bit_copies is a wrapper around num_sign_bit_copies1. It avoids exponential behavior in num_sign_bit_copies1 when X has identical subexpressions on the first or the second level.
References num_sign_bit_copies1().
Referenced by num_sign_bit_copies(), and num_sign_bit_copies1().
| rtx canonicalize_condition | ( | rtx | insn, |
| rtx | cond, | ||
| int | reverse, | ||
| rtx * | earliest, | ||
| rtx | want_reg, | ||
| int | allow_cc_mode, | ||
| int | valid_at_insn_p | ||
| ) |
Given an insn INSN and condition COND, return the condition in a
canonical form to simplify testing by callers. Specifically:
(1) The code will always be a comparison operation (EQ, NE, GT, etc.).
(2) Both operands will be machine operands; (cc0) will have been replaced.
(3) If an operand is a constant, it will be the second operand.
(4) (LE x const) will be replaced with (LT x <const+1>) and similarly
for GE, GEU, and LEU.
If the condition cannot be understood, or is an inequality floating-point
comparison which needs to be reversed, 0 will be returned.
If REVERSE is nonzero, then reverse the condition prior to canonizing it.
If EARLIEST is nonzero, it is a pointer to a place where the earliest
insn used in locating the condition was found. If a replacement test
of the condition is desired, it should be placed in front of that
insn and we will be sure that the inputs are still valid.
If WANT_REG is nonzero, we wish the condition to be relative to that
register, if possible. Therefore, do not canonicalize the condition
further. If ALLOW_CC_MODE is nonzero, allow the condition returned
to be a compare to a CC mode register.
If VALID_AT_INSN_P, the condition must be valid at both *EARLIEST
and at INSN.
References cc0_rtx, const_val, gen_int_mode(), HOST_BITS_PER_WIDE_INT, HOST_WIDE_INT, modified_between_p(), modified_in_p(), prev_nonnote_insn(), prev_nonnote_nondebug_insn(), reg_set_p(), reversed_comparison_code(), RTX_COMM_COMPARE, RTX_COMPARE, rtx_equal_p(), SET, set_of(), swap_condition(), and val_signbit_known_set_p().
Referenced by get_condition(), noce_get_alt_condition(), and noce_get_condition().
| int commutative_operand_precedence | ( | ) |
Return a value indicating whether OP, an operand of a commutative operation, is preferred as the first or second operand. The higher the value, the stronger the preference for being the first operand. We use negative values to indicate a preference for the first operand and positive values for the second operand.
References avoid_constant_pool_reference(), RTX_BIN_ARITH, RTX_COMM_ARITH, RTX_CONST_OBJ, RTX_EXTRA, RTX_OBJ, and RTX_UNARY.
| int computed_jump_p | ( | ) |
Return nonzero if INSN is an indirect jump (aka computed jump). Tablejumps and casesi insns are not considered indirect jumps; we can recognize them by a (use (label_ref)).
References computed_jump_p_1(), len, set_of_data::pat, pc_rtx, and SET.
|
static |
Referenced by computed_jump_p(), and computed_jump_p_1().
|
static |
A subroutine of computed_jump_p, return 1 if X contains a REG or MEM or constant that is not in the constant pool and not in the condition of an IF_THEN_ELSE.
References computed_jump_p_1().
| bool constant_pool_constant_p | ( | ) |
Check whether this is a constant pool constant.
References avoid_constant_pool_reference().
| int count_occurrences | ( | ) |
Return the number of places FIND appears within X. If COUNT_DEST is zero, we do not count occurrences inside the destination of a SET.
References count, count_occurrences(), find(), rtx_equal_p(), and SET.
|
static |
Referenced by covers_regno_p().
|
static |
Return TRUE iff DEST is a register or subreg of a register and doesn't change the number of words of the inner register, and any part of the register is TEST_REGNO.
|
static |
Referenced by dead_or_set_regno_p().
|
static |
Like covers_regno_no_parallel_p, but also handles PARALLELs where any member matches the covers_regno_no_parallel_p criteria.
References covers_regno_no_parallel_p().
| int dead_or_set_p | ( | ) |
Return nonzero if X's old contents don't survive after INSN. This will be true if X is (cc0) or if X is a register and X dies in INSN or because INSN entirely sets X. "Entirely set" means set directly and not through a SUBREG, or ZERO_EXTRACT, so no trace of the old contents remains. Likewise, REG_INC does not count. REG may be a hard or pseudo reg. Renumbering is not taken into account, but for this use that makes no difference, since regs don't overlap during their lifetimes. Therefore, this function may be used at any time after deaths have been computed. If REG is a hard reg that occupies multiple machine registers, this function will only return 1 if each of those registers will be replaced by INSN.
References dead_or_set_regno_p().
| int dead_or_set_regno_p | ( | ) |
Utility function for dead_or_set_p to check an individual register.
References covers_regno_p(), find_regno_fusage(), find_regno_note(), and SET.
| void decompose_address | ( | struct address_info * | info, |
| rtx * | loc, | ||
| enum machine_mode | mode, | ||
| addr_space_t | as, | ||
| enum rtx_code | outer_code | ||
| ) |
Describe address *LOC in *INFO. MODE is the mode of the addressed value, or VOIDmode if not known. AS is the address space associated with LOC. OUTER_CODE is MEM if *LOC is a MEM address and ADDRESS otherwise.
References address_info::addr_outer_code, address_info::as, address_info::base_outer_code, decompose_automod_address(), decompose_incdec_address(), decompose_normal_address(), address_info::inner, memset(), address_info::mode, address_info::outer, and strip_address_mutations().
Referenced by decompose_lea_address(), decompose_mem_address(), and update_address().
|
static |
INFO->INNER describes a {PRE,POST}_MODIFY address. Set up the rest
of INFO accordingly.
References address_info::autoinc_p, address_info::base, address_info::base_term, address_info::base_term2, address_info::inner, rtx_equal_p(), set_address_base(), set_address_disp(), set_address_index(), and strip_address_mutations().
Referenced by decompose_address().
|
static |
INFO->INNER describes a {PRE,POST}_{INC,DEC} address. Set up the
rest of INFO accordingly.
References address_info::autoinc_p, address_info::base, address_info::base_term, address_info::inner, address_info::mode, and set_address_base().
Referenced by decompose_address().
| void decompose_lea_address | ( | ) |
Describe address operand LOC in INFO.
References decompose_address().
| void decompose_mem_address | ( | ) |
Describe the address of MEM X in INFO.
References decompose_address().
|
static |
INFO->INNER describes a normal, non-automodified address. Fill in the rest of INFO accordingly.
References address_info::as, address_info::base_outer_code, baseness(), extract_plus_operands(), address_info::inner, address_info::mode, must_be_index_p(), set_address_base(), set_address_disp(), set_address_index(), set_address_segment(), and strip_address_mutations().
Referenced by decompose_address().
| int default_address_cost | ( | ) |
If the target doesn't override, compute the cost as with arithmetic.
References rtx_cost().
|
static |
Treat *LOC as a tree of PLUS operands and store pointers to the summed values in [PTR, END). Return a pointer to the end of the used array.
Referenced by decompose_normal_address().
| void find_all_hard_reg_sets | ( | ) |
Examine INSN, and compute the set of hard registers written by it. Store it in *PSET. Should only be called after reload.
References note_stores(), and record_hard_reg_sets().
| rtx find_constant_src | ( | ) |
Check whether INSN is a single_set whose source is known to be equivalent to a constant. Return that constant if so, otherwise return null.
References avoid_constant_pool_reference(), and find_reg_equal_equiv_note().
| rtx find_first_parameter_load | ( | ) |
Look backward for first parameter to be loaded. Note that loads of all parameters will not necessarily be found if CSE has eliminated some of them (e.g., an argument to the outer function is passed down as a parameter). Do not skip BOUNDARY.
References note_stores(), parms_set_data::nregs, parms_set(), and parms_set_data::regs.
| rtx find_last_value | ( | ) |
Return the last thing that X was assigned from before *PINSN. If VALID_TO is not NULL_RTX then verify that the object is not modified up to VALID_TO. If the object was modified, if we hit a partial assignment to X, or hit a CODE_LABEL first, return X. If we found an assignment, update *PINSN to point to it. ALLOW_HWREG is set to 1 if hardware registers are allowed to be the src.
References find_reg_note(), modified_between_p(), reg_set_p(), and rtx_equal_p().
| rtx find_reg_equal_equiv_note | ( | ) |
Return a REG_EQUIV or REG_EQUAL note if insn has only a single set and has such a note.
References multiple_sets().
| int find_reg_fusage | ( | ) |
Return true if DATUM, or any overlap of DATUM, of kind CODE is found in the CALL_INSN_FUNCTION_USAGE information of INSN.
References find_regno_fusage(), and rtx_equal_p().
| rtx find_reg_note | ( | ) |
Return the reg-note of kind KIND in insn INSN, if there is one. If DATUM is nonzero, look for one whose datum is DATUM.
| int find_regno_fusage | ( | ) |
Return true if REGNO, or any overlap of REGNO, of kind CODE is found in the CALL_INSN_FUNCTION_USAGE information of INSN.
| rtx find_regno_note | ( | ) |
Return the reg-note of kind KIND in insn INSN which applies to register number REGNO, if any. Return 0 if there is no such reg-note. Note that the REGNO of this NOTE need not be REGNO if REGNO is a hard register; it might be the case that the note overlaps REGNO.
| int for_each_inc_dec | ( | rtx * | x, |
| for_each_inc_dec_fn | fn, | ||
| void * | arg | ||
| ) |
Traverse *X looking for MEMs, and for autoinc operations within them. For each such autoinc operation found, call FN, passing it the innermost enclosing MEM, the operation itself, the RTX modified by the operation, two RTXs (the second may be NULL) that, once added, represent the value to be held by the modified RTX afterwards, and ARG. FN is to return -1 to skip looking for other autoinc operations within the visited operation, 0 to continue the traversal, or any other value to have it returned to the caller of for_each_inc_dec.
References for_each_inc_dec_ops::arg, for_each_inc_dec_ops::fn, for_each_inc_dec_find_mem(), for_each_rtx(), and for_each_inc_dec_ops::mem.
Referenced by check_for_inc_dec(), check_for_inc_dec_1(), and cselib_record_sets().
|
static |
Find PRE/POST-INC/DEC/MODIFY operations within *R, extract the operands of the equivalent add insn and pass the result to the operator specified by *D.
References for_each_inc_dec_ops::arg, for_each_inc_dec_ops::fn, for_each_inc_dec_find_mem(), gen_int_mode(), and for_each_inc_dec_ops::mem.
Referenced by for_each_inc_dec_find_mem().
|
static |
Referenced by for_each_inc_dec(), and for_each_inc_dec_find_inc_dec().
|
static |
If *R is a MEM, find PRE/POST-INC/DEC/MODIFY operations within its address, extract the operands of the equivalent add insn and pass the result to the operator specified by *D.
References for_each_inc_dec_find_inc_dec(), for_each_rtx(), and for_each_inc_dec_ops::mem.
| int for_each_rtx | ( | ) |
Traverse X via depth-first search, calling F for each sub-expression (including X itself). F is also passed the DATA. If F returns -1, do not traverse sub-expressions, but continue traversing the rest of the tree. If F ever returns any other nonzero value, stop the traversal, and return the value returned by F. Otherwise, return 0. This function does not traverse inside tree structure that contains RTX_EXPRs, or into sub-expressions whose format code is `0' since it is not known whether or not those codes are actually RTL. This routine is very general, and could (should?) be used to implement many of the other routines in this file.
References for_each_rtx_1(), and non_rtx_starting_operands.
|
static |
Optimized loop of for_each_rtx, trying to avoid useless recursive calls. Processes the subexpressions of EXP and passes them to F.
References non_rtx_starting_operands.
Referenced by for_each_rtx().
| enum machine_mode get_address_mode | ( | ) |
Return the mode of MEM's address.
References targetm.
| rtx get_condition | ( | ) |
Given a jump insn JUMP, return the condition that will cause it to branch to its JUMP_LABEL. If the condition cannot be understood, or is an inequality floating-point comparison which needs to be reversed, 0 will be returned. If EARLIEST is nonzero, it is a pointer to a place where the earliest insn used in locating the condition was found. If a replacement test of the condition is desired, it should be placed in front of that insn and we will be sure that the inputs are still valid. If EARLIEST is null, the returned condition will be valid at INSN. If ALLOW_CC_MODE is nonzero, allow the condition returned to be a compare CC mode register. VALID_AT_INSN_P is the same as for canonicalize_condition.
References any_condjump_p(), canonicalize_condition(), and pc_set().
| void get_full_rtx_cost | ( | rtx | x, |
| enum rtx_code | outer, | ||
| int | opno, | ||
| struct full_rtx_costs * | c | ||
| ) |
Fill in the structure C with information about both speed and size rtx costs for X, which is operand OPNO in an expression with code OUTER.
References rtx_cost(), full_rtx_costs::size, and full_rtx_costs::speed.
Referenced by get_full_set_rtx_cost(), and get_full_set_src_cost().
| enum rtx_code get_index_code | ( | ) |
Return the "index code" of INFO, in the form required by ok_for_base_p_1.
References address_info::disp, and address_info::index.
| HOST_WIDE_INT get_index_scale | ( | ) |
Return the scale applied to *INFO->INDEX_TERM, or 0 if the index is more complicated than that.
References HOST_WIDE_INT, address_info::index, and address_info::index_term.
| HOST_WIDE_INT get_integer_term | ( | ) |
Return the value of the integer term in X, if one is apparent; otherwise return 0. Only obvious integer terms are detected. This is used in cse.c with the `related_value' field.
| rtx get_related_value | ( | ) |
If X is a constant, return the value sans apparent integer term; otherwise return 0. Only obvious integer terms are detected.
| int in_expr_list_p | ( | ) |
Search LISTP (an EXPR_LIST) for an entry whose first operand is NODE and return 1 if it is found. A simple equality test is used to determine if NODE matches.
| int inequality_comparisons_p | ( | ) |
Return nonzero if X contains a comparison that is not either EQ or NE, i.e., an inequality.
References inequality_comparisons_p(), and len.
|
static |
Initialize the table NUM_SIGN_BIT_COPIES_IN_REP based on TARGET_MODE_REP_EXTENDED. Note that we assume that the property of TARGET_MODE_REP_EXTENDED(B, C) is sticky to the integral modes narrower than mode B. I.e., if A is a mode narrower than B then in order to be able to operate on it in mode B, mode A needs to satisfy the requirements set by the representation of mode B.
References num_sign_bit_copies_in_rep, and targetm.
Referenced by init_rtlanal().
| void init_rtlanal | ( | void | ) |
Initialize non_rtx_starting_operands, which is used to speed up for_each_rtx.
References first, init_num_sign_bit_copies_in_rep(), non_rtx_starting_operands, and NUM_RTX_CODE.
Referenced by backend_init().
| int insn_rtx_cost | ( | ) |
Calculate the rtx_cost of a single instruction. A return value of zero indicates an instruction pattern without a known cost.
References SET, and set_src_cost().
| bool keep_with_call_p | ( | ) |
Return true if we should avoid inserting code between INSN and preceding call instruction.
References general_operand(), i2, keep_with_call_p(), next_nonnote_insn(), and targetm.
| bool label_is_jump_target_p | ( | ) |
Return true if LABEL is a target of JUMP_INSN. This applies only to non-complex jumps. That is, direct unconditional, conditional, and tablejumps, but not computed jumps or returns. It also does not apply to the fallthru case of a conditional jump.
References find_reg_note(), and tablejump_p().
| int loc_mentioned_in_p | ( | ) |
Return nonzero if IN contains a piece of rtl that has the address LOC.
References loc_mentioned_in_p().
| int low_bitmask_len | ( | ) |
If M is a bitmask that selects a field of low-order bits within an item but not the entire word, return the length of the field. Return -1 otherwise. M is used in machine mode MODE.
References exact_log2(), and HOST_BITS_PER_WIDE_INT.
| int may_trap_or_fault_p | ( | ) |
Same as above, but additionally return nonzero if evaluating rtx X might
cause a fault. We define a fault for the purpose of this function as a
erroneous execution condition that cannot be encountered during the normal
execution of a valid program; the typical example is an unaligned memory
access on a strict alignment machine. The compiler guarantees that it
doesn't generate code that will fault from a valid program, but this
guarantee doesn't mean anything for individual instructions. Consider
the following example:
struct S { int d; union { char *cp; int *ip; }; };
int foo(struct S *s)
{
if (s->d == 1)
return *s->ip;
else
return *s->cp;
}
on a strict alignment machine. In a valid program, foo will never be
invoked on a structure for which d is equal to 1 and the underlying
unique field of the union not aligned on a 4-byte boundary, but the
expression *s->ip might cause a fault if considered individually.
At the RTL level, potentially problematic expressions will almost always
verify may_trap_p; for example, the above dereference can be emitted as
(mem:SI (reg:P)) and this expression is may_trap_p for a generic register.
However, suppose that foo is inlined in a caller that causes s->cp to
point to a local character variable and guarantees that s->d is not set
to 1; foo may have been effectively translated into pseudo-RTL as:
if ((reg:SI) == 1)
(set (reg:SI) (mem:SI (%fp - 7)))
else
(set (reg:QI) (mem:QI (%fp - 7)))
Now (mem:SI (%fp - 7)) is considered as not may_trap_p since it is a
memory reference to a stack slot, but it will certainly cause a fault
on a strict alignment machine.
References may_trap_p_1().
| int may_trap_p | ( | ) |
Return nonzero if evaluating rtx X might cause a trap.
References may_trap_p_1().
| int may_trap_p_1 | ( | ) |
Return nonzero if evaluating rtx X might cause a trap. FLAGS controls how to consider MEMs. A nonzero means the context of the access may have changed from the original, such that the address may have become invalid.
References HOST_WIDE_INT, may_trap_p_1(), rtx_addr_can_trap_p_1(), and targetm.
| int modified_between_p | ( | ) |
Similar to reg_set_between_p, but check all registers in X. Return 0 only if none of them are modified between START and END. Return 1 if X contains a MEM; this routine does use memory aliasing.
References memory_modified_in_insn_p(), modified_between_p(), and reg_set_between_p().
| int modified_in_p | ( | ) |
Similar to reg_set_p, but check all registers in X. Return 0 only if none of them are modified in INSN. Return 1 if X contains a MEM; this routine does use memory aliasing.
References memory_modified_in_insn_p(), modified_in_p(), and reg_set_p().
| int multiple_sets | ( | ) |
Given an INSN, return nonzero if it has more than one SET, else return zero.
References set_of_data::found, and SET.
|
static |
Return true if X must be a base rather than an index.
Referenced by baseness().
|
static |
Return true if X must be an index rather than a base.
Referenced by baseness(), and decompose_normal_address().
| int no_labels_between_p | ( | ) |
Return 1 if in between BEG and END, exclusive of BEG and END, there is no CODE_LABEL insn.
| bool nonzero_address_p | ( | ) |
Return true if X is an address that is known to not be zero.
References nonzero_address_p().
| unsigned HOST_WIDE_INT nonzero_bits | ( | ) |
References cached_nonzero_bits().
|
static |
Given an expression, X, compute which bits in X can be nonzero. We don't care about bits outside of those defined in MODE. For most X this is simply GET_MODE_MASK (GET_MODE (MODE)), but if X is an arithmetic operation, we can do better.
References cached_nonzero_bits(), count, floor_log2(), HOST_BITS_PER_WIDE_INT, HOST_WIDE_INT, HOST_WIDE_INT_M1U, num_sign_bit_copies(), ptr_mode, rtl_hooks::reg_nonzero_bits, target_default_pointer_address_modes_p(), and val_signbit_known_set_p().
Referenced by cached_nonzero_bits().
| int noop_move_p | ( | ) |
Return nonzero if an insn consists only of SETs, each of which only sets a value to itself.
References find_reg_note(), set_of_data::pat, SET, and set_noop_p().
Call FUN on each register or MEM that is stored into or clobbered by X. (X would be the pattern of an insn). DATA is an arbitrary pointer, ignored by note_stores, but passed to FUN. FUN receives three arguments: 1. the REG, MEM, CC0 or PC being stored in or clobbered, 2. the SET or CLOBBER rtx that does the store, 3. the pointer DATA provided to note_stores. If the item being stored in or clobbered is a SUBREG of a hard register, the SUBREG will be passed.
References note_stores(), and SET.
Referenced by add_with_sets(), adjust_insn(), assign_parm_setup_reg(), build_def_use(), calculate_loop_reg_pressure(), can_move_insns_across(), combine_instructions(), compute_defs_uses_and_gen(), compute_hash_table_work(), copyprop_hardreg_forward_1(), cselib_record_sets(), delete_trivially_dead_insns(), emit_inc_dec_insn_before(), emit_libcall_block_1(), emit_output_reload_insns(), expand_atomic_compare_and_swap(), find_all_hard_reg_sets(), find_first_parameter_load(), init_alias_analysis(), init_insn_reg_pressure_info(), insert_one_insn(), likely_spilled_retval_p(), load_killed_in_block_p(), mark_nonreg_stores(), mark_target_live_regs(), mem_write_insn_p(), memory_modified_in_insn_p(), note_stores(), notice_stack_pointer_modification(), optimize_mode_switching(), record_dead_and_set_regs(), record_last_mem_set_info(), record_opr_changes(), reg_dead_at_p(), reload(), reload_as_needed(), reload_combine(), reload_cse_move2add(), replace_read(), save_call_clobbered_regs(), set_of(), sets_likely_spilled(), setup_save_areas(), simplify_using_initial_values(), thread_prologue_and_epilogue_insns(), try_combine(), update_equiv_regs(), and validate_equiv_mem().
Like notes_stores, but call FUN for each expression that is being referenced in PBODY, a pointer to the PATTERN of an insn. We only call FUN for each expression, not any interior subexpressions. FUN receives a pointer to the expression and the DATA passed to this function. Note that this is not quite the same test as that done in reg_referenced_p since that considers something as being referenced if it is being partially set, while we do not.
References note_uses(), and SET.
Referenced by add_dependence(), add_with_sets(), adjust_insn(), bypass_block(), combine_instructions(), copyprop_hardreg_forward_1(), cprop_insn(), insert_one_insn(), local_cprop_pass(), mem_read_insn_p(), note_uses(), scan_insn(), thread_prologue_and_epilogue_insns(), and validate_replace_src_group().
| unsigned int num_sign_bit_copies | ( | ) |
References cached_num_sign_bit_copies().
|
static |
Return the number of bits at the high-order end of X that are known to be equal to the sign bit. X will be used in mode MODE; if MODE is VOIDmode, X will be used in its own mode. The returned value will always be between 1 and the number of bits in MODE.
References cached_num_sign_bit_copies(), floor_log2(), HOST_BITS_PER_WIDE_INT, HOST_WIDE_INT, nonzero_bits(), paradoxical_subreg_p(), ptr_mode, rtl_hooks::reg_num_sign_bit_copies, and target_default_pointer_address_modes_p().
Referenced by cached_num_sign_bit_copies().
| bool offset_within_block_p | ( | ) |
Return true if SYMBOL is a SYMBOL_REF and OFFSET + SYMBOL points to somewhere in the same object or object_block as SYMBOL.
References get_pool_mode(), HOST_WIDE_INT, and int_size_in_bytes().
Referenced by find_first_parameter_load().
|
static |
Helper function for noticing stores to parameter registers.
References parms_set_data::nregs, and parms_set_data::regs.
| void record_hard_reg_sets | ( | ) |
This function, called through note_stores, collects sets and clobbers of hard registers in a HARD_REG_SET, which is pointed to by DATA.
References add_to_hard_reg_set().
| void record_hard_reg_uses | ( | ) |
Like record_hard_reg_sets, but called through note_uses.
References for_each_rtx(), and record_hard_reg_uses_1().
|
static |
A for_each_rtx subroutine of record_hard_reg_uses.
Referenced by record_hard_reg_uses().
Return nonzero if register in range [REGNO, ENDREGNO) appears either explicitly or implicitly in X other than being stored into. References contained within the substructure at LOC do not count. LOC may be zero, meaning don't ignore anything.
References refers_to_regno_p(), SET, subreg_nregs(), and subreg_regno().
Referenced by compute_defs_uses_and_gen(), delete_output_reload(), df_get_call_refs(), distribute_notes(), link_btr_uses(), refers_to_regno_p(), reg_overlap_mentioned_p(), remove_invalid_refs(), remove_invalid_subreg_refs(), and sched_analyze_insn().
| int reg_mentioned_p | ( | ) |
Nonzero if register REG appears somewhere within IN. Also works if REG is not a register; in this case it checks for a subexpression of IN that is Lisp "equal" to REG.
References reg_mentioned_p(), and rtx_equal_p().
| int reg_overlap_mentioned_p | ( | ) |
Nonzero if modifying X will affect IN. If X is a register or a SUBREG, we check if any register number in X conflicts with the relevant register numbers. If X is a constant, return 0. If X is a MEM, return 1 iff IN contains a MEM (we don't bother checking for memory addresses that can't conflict because we expect this to be a rare case.
References refers_to_regno_p(), reg_mentioned_p(), reg_overlap_mentioned_p(), subreg_nregs(), and subreg_regno().
| int reg_referenced_p | ( | ) |
Nonzero if the old value of X, a register, is referenced in BODY. If X is entirely replaced by a new value and the only use is as a SET_DEST, we do not consider it a reference.
References reg_overlap_mentioned_p(), reg_referenced_p(), and SET.
| int reg_set_between_p | ( | ) |
Nonzero if register REG is set or clobbered in an insn between FROM_INSN and TO_INSN (exclusive of those two).
References reg_set_p().
| int reg_set_p | ( | ) |
Internals of reg_set_between_p.
References find_reg_fusage(), overlaps_hard_reg_set_p(), and set_of().
| int reg_used_between_p | ( | ) |
Nonzero if register REG is used in an insn between FROM_INSN and TO_INSN (exclusive of those two).
References find_reg_fusage(), and reg_overlap_mentioned_p().
| rtx regno_use_in | ( | ) |
Searches X for any reference to REGNO, returning the rtx of the reference found if any. Otherwise, returns NULL_RTX.
References regno_use_in().
| void remove_node_from_expr_list | ( | ) |
Search LISTP (an EXPR_LIST) for an entry whose first operand is NODE and remove that entry from the list if it is found. A simple equality test is used to determine if NODE matches.
| void remove_note | ( | ) |
Remove register note NOTE from the REG_NOTES of INSN.
References df_notes_rescan().
| void remove_reg_equal_equiv_notes | ( | ) |
Remove REG_EQUAL and/or REG_EQUIV notes if INSN has such notes.
| void remove_reg_equal_equiv_notes_for_regno | ( | ) |
Remove all REG_EQUAL and REG_EQUIV notes referring to REGNO.
References df, find_reg_equal_equiv_note(), and remove_note().
| int replace_label | ( | ) |
Replace occurrences of the old label in *X with the new one. DATA is a REPLACE_LABEL_DATA containing the old and new labels.
References copy_rtx(), for_each_rtx(), force_const_mem(), get_pool_constant(), get_pool_mode(), replace_label(), replace_rtx(), rtx_referenced_p(), and replace_label_data::update_label_nuses.
| rtx replace_rtx | ( | ) |
Replace any occurrence of FROM in X with TO. The function does not enter into CONST_DOUBLE for the replace. Note that copying is not done so X must not be shared unless all copies are to be modified.
References replace_rtx(), simplify_subreg(), and simplify_unary_operation().
| int rtx_addr_can_trap_p | ( | ) |
Return nonzero if the use of X as an address in a MEM can cause a trap.
References rtx_addr_can_trap_p_1().
|
static |
Return nonzero if the use of X as an address in a MEM can cause a trap. MODE is the mode of the MEM (not that of X) and UNALIGNED_MEMS controls whether nonzero is returned for unaligned memory accesses on strict alignment machines.
References host_integerp(), HOST_WIDE_INT, int_size_in_bytes(), offset, and tree_low_cst().
Referenced by may_trap_p_1(), and rtx_addr_can_trap_p().
| bool rtx_addr_varies_p | ( | ) |
Return 1 if X refers to a memory location whose address cannot be compared reliably with constant addresses, or if X refers to a BLKmode memory object. FOR_ALIAS is nonzero if we are called from alias analysis; if it is zero, we are slightly more conservative.
References rtx_addr_varies_p(), and rtx_varies_p().
| int rtx_cost | ( | ) |
Return an estimate of the cost of computing rtx X. One use is in cse, to decide which expression to keep in the hash table. Another is in rtl generation, to pick the cheapest way to multiply. Other uses like the latter are expected in the future. X appears as operand OPNO in an expression with code OUTER_CODE. SPEED specifies whether costs optimized for speed or size should be returned.
References rtx_cost(), SET, and targetm.
| int rtx_referenced_p | ( | ) |
Return true if X is referenced in BODY.
References for_each_rtx(), and rtx_referenced_p_1().
|
static |
Referenced by rtx_referenced_p().
|
static |
When *BODY is equal to X or X is directly referenced by *BODY return nonzero, thus FOR_EACH_RTX stops traversing and returns nonzero too, otherwise FOR_EACH_RTX continues traversing *BODY.
References get_pool_constant(), rtx_equal_p(), and rtx_referenced_p().
| int rtx_unstable_p | ( | ) |
Return 1 if the value of X is unstable (would be different at a different point in the program). The frame pointer, arg pointer, etc. are considered stable (within one function) and so is anything marked `unchanging'.
References rtx_unstable_p().
| bool rtx_varies_p | ( | ) |
Return 1 if X has a value that can vary even between two executions of the program. 0 means X can be compared reliably against certain constants or near-constants. FOR_ALIAS is nonzero if we are called from alias analysis; if it is zero, we are slightly more conservative. The frame pointer and the arg pointer are considered constant.
References rtx_varies_p().
|
static |
Set the base part of address INFO to LOC, given that INNER is the unmutated value.
References address_info::base, address_info::base_term, and strip_address_mutations().
Referenced by decompose_automod_address(), decompose_incdec_address(), and decompose_normal_address().
|
static |
Set the displacement part of address INFO to LOC, given that INNER is the constant term.
References address_info::disp, and address_info::disp_term.
Referenced by decompose_automod_address(), and decompose_normal_address().
|
static |
Set the index part of address INFO to LOC, given that INNER is the unmutated value.
References address_info::index, address_info::index_term, and strip_address_mutations().
Referenced by decompose_automod_address(), and decompose_normal_address().
|
static |
Set the segment part of address INFO to LOC, given that INNER is the unmutated value.
References address_info::segment, and address_info::segment_term.
Referenced by decompose_normal_address().
| int set_noop_p | ( | ) |
Return nonzero if the destination of SET equals the source and there are no side effects.
References pc_rtx, rtx_equal_p(), and side_effects_p().
| const_rtx set_of | ( | ) |
Give an INSN, return a SET or CLOBBER expression that does modify PAT (either directly or via STRICT_LOW_PART and similar modifiers).
References set_of_data::found, note_stores(), set_of_data::pat, and set_of_1().
@verbatim Analyze RTL for GNU compiler.
Copyright (C) 1987-2013 Free Software Foundation, Inc.
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/.
Forward declarations
Referenced by set_of().
|
static |
References set_of_data::found, set_of_data::pat, reg_overlap_mentioned_p(), and rtx_equal_p().
| int side_effects_p | ( | ) |
Similar to above, except that it also rejects register pre- and post- incrementing.
References side_effects_p().
| int simplify_subreg_regno | ( | unsigned int | xregno, |
| enum machine_mode | xmode, | ||
| unsigned int | offset, | ||
| enum machine_mode | ymode | ||
| ) |
Return the number of a YMODE register to which
(subreg:YMODE (reg:XMODE XREGNO) OFFSET)
can be simplified. Return -1 if the subreg can't be simplified.
XREGNO is a hard register number.
References lra_in_progress, subreg_info::offset, reload_completed, subreg_info::representable_p, and subreg_get_info().
Referenced by can_decompose_p(), curr_insn_transform(), find_reloads(), process_single_reg_class_operands(), simplify_operand_subreg(), and simplify_subreg().
| rtx single_set_2 | ( | ) |
Given an INSN, return a SET expression if this insn has only a single SET. It may also have CLOBBERs, USEs, or SET whose output will not be used, which we ignore.
References find_reg_note(), SET, and side_effects_p().
| void split_const | ( | ) |
Split X into a base and a constant offset, storing them in *BASE_OUT and *OFFSET_OUT respectively.
| void split_double | ( | ) |
Split up a CONST_DOUBLE or integer constant rtx into two rtx's for single words, storing in *FIRST the word that comes first in memory in the target and in *SECOND the other.
References HOST_BITS_PER_LONG, HOST_BITS_PER_WIDE_INT, and HOST_WIDE_INT.
| rtx* strip_address_mutations | ( | ) |
Strip outer address "mutations" from LOC and return a pointer to the inner value. If OUTER_CODE is nonnull, store the code of the innermost stripped expression there. "Mutations" either convert between modes or apply some kind of alignment.
References RTX_UNARY, and subreg_lowpart_p().
| void subreg_get_info | ( | unsigned int | xregno, |
| enum machine_mode | xmode, | ||
| unsigned int | offset, | ||
| enum machine_mode | ymode, | ||
| struct subreg_info * | info | ||
| ) |
Fill in information about a subreg of a hard register. xregno - A regno of an inner hard subreg_reg (or what will become one). xmode - The mode of xregno. offset - The byte offset. ymode - The mode of a top level SUBREG (or what may become one). info - Pointer to structure to fill in.
References HOST_WIDE_INT, mode_for_size(), subreg_info::nregs, offset, subreg_info::offset, subreg_info::representable_p, and subreg_lowpart_offset().
Referenced by rtx_renumbered_equal_p(), simplify_subreg_regno(), subreg_nregs_with_regno(), subreg_offset_representable_p(), subreg_regno_offset(), and true_regnum().
| unsigned int subreg_lsb | ( | ) |
Given a subreg X, return the bit offset where the subreg begins (counting from the least significant bit of the reg).
References subreg_lsb_1().
| unsigned int subreg_lsb_1 | ( | enum machine_mode | outer_mode, |
| enum machine_mode | inner_mode, | ||
| unsigned int | subreg_byte | ||
| ) |
Helper function for subreg_lsb. Given a subreg's OUTER_MODE, INNER_MODE, and SUBREG_BYTE, return the bit offset where the subreg begins (counting from the least significant bit of the operand).
Referenced by simplify_subreg(), and subreg_lsb().
| unsigned int subreg_nregs | ( | ) |
Return the number of registers that a subreg expression refers to.
References subreg_nregs_with_regno().
| unsigned int subreg_nregs_with_regno | ( | ) |
Return the number of registers that a subreg REG with REGNO expression refers to. This is a copy of the rtlanal.c:subreg_nregs changed so that the regno can be passed in.
References subreg_info::nregs, and subreg_get_info().
| bool subreg_offset_representable_p | ( | unsigned int | xregno, |
| enum machine_mode | xmode, | ||
| unsigned int | offset, | ||
| enum machine_mode | ymode | ||
| ) |
This function returns true when the offset is representable via subreg_offset in the given regno. xregno - A regno of an inner hard subreg_reg (or what will become one). xmode - The mode of xregno. offset - The byte offset. ymode - The mode of a top level SUBREG (or what may become one). RETURN - Whether the offset is representable.
References subreg_info::representable_p, and subreg_get_info().
Referenced by validate_subreg().
| unsigned int subreg_regno | ( | ) |
Return the final regno that a subreg expression refers to.
References subreg_regno_offset().
| unsigned int subreg_regno_offset | ( | unsigned int | xregno, |
| enum machine_mode | xmode, | ||
| unsigned int | offset, | ||
| enum machine_mode | ymode | ||
| ) |
This function returns the regno offset of a subreg expression. xregno - A regno of an inner hard subreg_reg (or what will become one). xmode - The mode of xregno. offset - The byte offset. ymode - The mode of a top level SUBREG (or what may become one). RETURN - The regno offset which would be used.
References subreg_info::offset, and subreg_get_info().
Referenced by add_stored_regs(), choose_reload_regs(), constrain_operands(), df_ref_record(), find_dummy_reload(), find_reloads(), find_reloads_address_1(), get_hard_regno(), get_true_reg(), go_through_subreg(), maybe_mode_change(), move2add_valid_value_p(), operands_match_p(), push_reload(), reg_overlap_mentioned_for_reload_p(), reload_combine_note_store(), subreg_regno(), and var_lowpart().
| bool swap_commutative_operands_p | ( | ) |
Return 1 iff it is necessary to swap operands of commutative operation in order to canonicalize expression.
References commutative_operand_precedence().
| bool tablejump_p | ( | ) |
If INSN is a tablejump return true and store the label (before jump table) to *LABELP and the jump table to *TABLEP. LABELP and TABLEP may be NULL.
References next_active_insn(), and table.
| bool truncated_to_mode | ( | ) |
Suppose that truncation from the machine mode of X to MODE is not a no-op. See if there is anything special about X so that we can assume it already contains a truncated value of MODE.
References num_sign_bit_copies(), num_sign_bit_copies_in_rep, and rtl_hooks::reg_truncated_to_mode.
| bool unsigned_reg_p | ( | ) |
Return TRUE if OP is a register or subreg of a register that holds an unsigned quantity. Otherwise, return FALSE.
| void update_address | ( | ) |
Update INFO after a change to the address it describes.
References address_info::addr_outer_code, address_info::as, decompose_address(), address_info::mode, and address_info::outer.
| int volatile_insn_p | ( | ) |
Nonzero if X contains any volatile instructions. These are instructions which may cause unpredictable machine state instructions, and thus no instructions or register uses should be moved or combined across them. This includes only volatile asms and UNSPEC_VOLATILE instructions.
References volatile_insn_p().
| int volatile_refs_p | ( | ) |
Nonzero if X contains any volatile memory references UNSPEC_VOLATILE operations or volatile ASM_OPERANDS expressions.
References volatile_refs_p().
|
static |
Offset of the first 'e', 'E' or 'V' operand for each rtx code, or -1 if a code has no such operand.
Referenced by for_each_rtx(), for_each_rtx_1(), and init_rtlanal().
|
static |
Truncation narrows the mode from SOURCE mode to DESTINATION mode. If TARGET_MODE_REP_EXTENDED (DESTINATION, DESTINATION_REP) is SIGN_EXTEND then while narrowing we also have to enforce the representation and sign-extend the value to mode DESTINATION_REP. If the value is already sign-extended to DESTINATION_REP mode we can just switch to DESTINATION mode on it. For each pair of integral modes SOURCE and DESTINATION, when truncating from SOURCE to DESTINATION, NUM_SIGN_BIT_COPIES_IN_REP[SOURCE][DESTINATION] contains the number of high-order bits in SOURCE that have to be copies of the sign-bit so that we can do this mode-switch to DESTINATION.
Referenced by init_num_sign_bit_copies_in_rep(), and truncated_to_mode().
1.8.1.1