#include "addresses.h"

Include dependency graph for rtlanal.c:

Data Structures
struct	set_of_data
struct	for_each_inc_dec_ops
struct	parms_set_data

Functions
static void	set_of_1 (rtx, const_rtx, void *)
static bool	covers_regno_p (const_rtx, unsigned int)
static bool	covers_regno_no_parallel_p (const_rtx, unsigned int)
static int	rtx_referenced_p_1 (rtx , void )
static int	computed_jump_p_1 (const_rtx)
static void	parms_set (rtx, const_rtx, void *)
static unsigned HOST_WIDE_INT	cached_nonzero_bits (const_rtx, enum machine_mode, const_rtx, enum machine_mode, unsigned HOST_WIDE_INT)
static unsigned HOST_WIDE_INT	nonzero_bits1 (const_rtx, enum machine_mode, const_rtx, enum machine_mode, unsigned HOST_WIDE_INT)
static unsigned int	cached_num_sign_bit_copies (const_rtx, enum machine_mode, const_rtx, enum machine_mode, unsigned int)
static unsigned int	num_sign_bit_copies1 (const_rtx, enum machine_mode, const_rtx, enum machine_mode, unsigned int)
int	rtx_unstable_p ()
bool	rtx_varies_p ()
static int	rtx_addr_can_trap_p_1 (const_rtx x, HOST_WIDE_INT offset, HOST_WIDE_INT size, enum machine_mode mode, bool unaligned_mems)
int	rtx_addr_can_trap_p ()
bool	nonzero_address_p ()
bool	rtx_addr_varies_p ()
rtx	get_call_rtx_from ()
HOST_WIDE_INT	get_integer_term ()
rtx	get_related_value ()
bool	offset_within_block_p ()
void	split_const ()
int	count_occurrences ()
bool	unsigned_reg_p ()
int	reg_mentioned_p ()
int	no_labels_between_p ()
int	reg_used_between_p ()
int	reg_referenced_p ()
int	reg_set_between_p ()
int	reg_set_p ()
int	modified_between_p ()
int	modified_in_p ()
static void	set_of_1 ()
const_rtx	set_of ()
void	record_hard_reg_sets ()
void	find_all_hard_reg_sets ()
static int	record_hard_reg_uses_1 ()
void	record_hard_reg_uses ()
rtx	single_set_2 ()
int	multiple_sets ()
int	set_noop_p ()
int	noop_move_p ()
rtx	find_last_value ()
int	refers_to_regno_p (unsigned int regno, unsigned int endregno, const_rtx x, rtx *loc)
int	reg_overlap_mentioned_p ()
void	note_stores (const_rtx x, void(fun)(rtx, const_rtx, void ), void *data)
void	note_uses (rtx pbody, void(fun)(rtx , void ), void *data)
int	dead_or_set_p ()
static bool	covers_regno_no_parallel_p ()
static bool	covers_regno_p ()
int	dead_or_set_regno_p ()
rtx	find_reg_note ()
rtx	find_regno_note ()
rtx	find_reg_equal_equiv_note ()
rtx	find_constant_src ()
int	find_reg_fusage ()
int	find_regno_fusage ()
rtx	alloc_reg_note ()
void	add_reg_note ()
void	remove_note ()
void	remove_reg_equal_equiv_notes ()
void	remove_reg_equal_equiv_notes_for_regno ()
int	in_expr_list_p ()
void	remove_node_from_expr_list ()
int	volatile_insn_p ()
int	volatile_refs_p ()
int	side_effects_p ()
int	may_trap_p_1 ()
int	may_trap_p ()
int	may_trap_or_fault_p ()
int	inequality_comparisons_p ()
rtx	replace_rtx ()
int	replace_label ()
static int	rtx_referenced_p_1 ()
int	rtx_referenced_p ()
bool	tablejump_p ()
static int	computed_jump_p_1 ()
int	computed_jump_p ()
static int	for_each_rtx_1 ()
int	for_each_rtx ()
static int	for_each_inc_dec_find_mem (rtx r, void d)
static int	for_each_inc_dec_find_inc_dec ()
static int	for_each_inc_dec_find_mem ()
int	for_each_inc_dec (rtx x, for_each_inc_dec_fn fn, void arg)
rtx	regno_use_in ()
int	commutative_operand_precedence ()
bool	swap_commutative_operands_p ()
int	auto_inc_p ()
int	loc_mentioned_in_p ()
unsigned int	subreg_lsb_1 (enum machine_mode outer_mode, enum machine_mode inner_mode, unsigned int subreg_byte)
unsigned int	subreg_lsb ()
void	subreg_get_info (unsigned int xregno, enum machine_mode xmode, unsigned int offset, enum machine_mode ymode, struct subreg_info *info)
unsigned int	subreg_regno_offset (unsigned int xregno, enum machine_mode xmode, unsigned int offset, enum machine_mode ymode)
bool	subreg_offset_representable_p (unsigned int xregno, enum machine_mode xmode, unsigned int offset, enum machine_mode ymode)
int	simplify_subreg_regno (unsigned int xregno, enum machine_mode xmode, unsigned int offset, enum machine_mode ymode)
unsigned int	subreg_regno ()
unsigned int	subreg_nregs ()
unsigned int	subreg_nregs_with_regno ()
static void	parms_set ()
rtx	find_first_parameter_load ()
bool	keep_with_call_p ()
bool	label_is_jump_target_p ()
int	rtx_cost ()
void	get_full_rtx_cost (rtx x, enum rtx_code outer, int opno, struct full_rtx_costs *c)
int	address_cost ()
int	default_address_cost ()
unsigned HOST_WIDE_INT	nonzero_bits ()
unsigned int	num_sign_bit_copies ()
int	insn_rtx_cost ()
rtx	canonicalize_condition (rtx insn, rtx cond, int reverse, rtx *earliest, rtx want_reg, int allow_cc_mode, int valid_at_insn_p)
rtx	get_condition ()
static void	init_num_sign_bit_copies_in_rep ()
bool	truncated_to_mode ()
void	init_rtlanal ()
bool	constant_pool_constant_p ()
int	low_bitmask_len ()
enum machine_mode	get_address_mode ()
void	split_double ()
rtx *	strip_address_mutations ()
static bool	must_be_base_p ()
static bool	must_be_index_p ()
static void	set_address_segment ()
static void	set_address_base ()
static void	set_address_index ()
static void	set_address_disp ()
static void	decompose_incdec_address ()
static void	decompose_automod_address ()
static rtx **	extract_plus_operands ()
static int	baseness (rtx x, enum machine_mode mode, addr_space_t as, enum rtx_code outer_code, enum rtx_code index_code)
static void	decompose_normal_address ()
void	decompose_address (struct address_info info, rtx loc, enum machine_mode mode, addr_space_t as, enum rtx_code outer_code)
void	decompose_lea_address ()
void	decompose_mem_address ()
void	update_address ()
HOST_WIDE_INT	get_index_scale ()
enum rtx_code	get_index_code ()

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]

Function Documentation

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 int baseness	(	rtx	x,
		enum machine_mode	mode,
		addr_space_t	as,
		enum rtx_code	outer_code,
		enum rtx_code	index_code
	)

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 unsigned HOST_WIDE_INT cached_nonzero_bits	(	const_rtx	x,
		enum machine_mode	mode,
		const_rtx	known_x,
		enum machine_mode	known_mode,
		unsigned HOST_WIDE_INT	known_ret
	)

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 unsigned int cached_num_sign_bit_copies	(	const_rtx	x,
		enum machine_mode	mode,
		const_rtx	known_x,
		enum machine_mode	known_mode,
		unsigned int	known_ret
	)

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 int computed_jump_p_1 ( const_rtx )

static

Referenced by computed_jump_p(), and computed_jump_p_1().

static int 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 bool covers_regno_no_parallel_p	(	const_rtx	,
		unsigned	int
	)

static

Referenced by covers_regno_p().

static bool covers_regno_no_parallel_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 bool covers_regno_p	(	const_rtx	,
		unsigned	int
	)

static

Referenced by dead_or_set_regno_p().

static bool covers_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 void decompose_automod_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 void decompose_incdec_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 void decompose_normal_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 rtx** extract_plus_operands ( )

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 int for_each_inc_dec_find_inc_dec ( )

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 int for_each_inc_dec_find_mem	(	rtx *	r,
		void *	d
	)

static

Referenced by for_each_inc_dec(), and for_each_inc_dec_find_inc_dec().

static int for_each_inc_dec_find_mem ( )

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 int for_each_rtx_1 ( )

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_call_rtx_from ( )

Return the CALL in X if there is one.

References SET.

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 void init_num_sign_bit_copies_in_rep ( )

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 bool must_be_base_p ( )

static

Return true if X must be a base rather than an index.

Referenced by baseness().

static bool must_be_index_p ( )

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 unsigned HOST_WIDE_INT nonzero_bits1	(	const_rtx	x,
		enum machine_mode	mode,
		const_rtx	known_x,
		enum machine_mode	known_mode,
		unsigned HOST_WIDE_INT	known_ret
	)

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().

void note_stores	(	const_rtx	x,
		void()(rtx, const_rtx, void )	fun,
		void *	data
	)

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().

void note_uses	(	rtx *	pbody,
		void()(rtx , void *)	fun,
		void *	data
	)

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 unsigned int num_sign_bit_copies1	(	const_rtx	x,
		enum machine_mode	mode,
		const_rtx	known_x,
		enum machine_mode	known_mode,
		unsigned int	known_ret
	)

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().

static void parms_set	(	rtx	,
		const_rtx	,
		void *
	)

static

Referenced by find_first_parameter_load().

static void parms_set ( )

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 int record_hard_reg_uses_1 ( )

static

A for_each_rtx subroutine of record_hard_reg_uses.

Referenced by record_hard_reg_uses().

int refers_to_regno_p	(	unsigned int	regno,
		unsigned int	endregno,
		const_rtx	x,
		rtx *	loc
	)

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 int rtx_addr_can_trap_p_1	(	const_rtx	x,
		HOST_WIDE_INT	offset,
		HOST_WIDE_INT	size,
		enum machine_mode	mode,
		bool	unaligned_mems
	)

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 int rtx_referenced_p_1	(	rtx *	,
		void *
	)

static

Referenced by rtx_referenced_p().

static int rtx_referenced_p_1 ( )

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 void set_address_base ( )

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 void set_address_disp ( )

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 void set_address_index ( )

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 void set_address_segment ( )

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().

static void set_of_1	(	rtx	,
		const_rtx	,
		void *
	)

static

@verbatim Analyze RTL for GNU compiler.

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 void set_of_1 ( )

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().

Variable Documentation

int non_rtx_starting_operands[NUM_RTX_CODE]

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().

unsigned int num_sign_bit_copies_in_rep[MAX_MODE_INT+1][MAX_MODE_INT+1]

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().

Data Structures

Functions

Variables

Function Documentation

Variable Documentation