Data Structures
struct	expr_history_def_1

struct	_expr

struct	_def

struct	_bnd

struct	_fence

struct	flist_tail_def

struct	_list_node

struct	_list_iterator

struct	idata_def

struct	vinsn_def

struct	transformed_insns

class	_sel_insn_data

struct	sel_global_bb_info_def

struct	sel_region_bb_info_def

struct	succ_iterator

struct	succs_info

Macros
#define	_LIST_NEXT(L) ((L)->next)

#define	_XLIST_X(L) ((L)->u.x)

#define	_XLIST_NEXT(L) (_LIST_NEXT (L))

#define	ILIST_INSN(L) ((L)->u.insn)

#define	ILIST_NEXT(L) (_LIST_NEXT (L))

#define	EXPR_VINSN(EXPR) ((EXPR)->vinsn)

#define	EXPR_INSN_RTX(EXPR) (VINSN_INSN_RTX (EXPR_VINSN (EXPR)))

#define	EXPR_PATTERN(EXPR) (VINSN_PATTERN (EXPR_VINSN (EXPR)))

#define	EXPR_LHS(EXPR) (VINSN_LHS (EXPR_VINSN (EXPR)))

#define	EXPR_RHS(EXPR) (VINSN_RHS (EXPR_VINSN (EXPR)))

#define	EXPR_TYPE(EXPR) (VINSN_TYPE (EXPR_VINSN (EXPR)))

#define	EXPR_SEPARABLE_P(EXPR) (VINSN_SEPARABLE_P (EXPR_VINSN (EXPR)))

#define	EXPR_SPEC(EXPR) ((EXPR)->spec)

#define	EXPR_USEFULNESS(EXPR) ((EXPR)->usefulness)

#define	EXPR_PRIORITY(EXPR) ((EXPR)->priority)

#define	EXPR_PRIORITY_ADJ(EXPR) ((EXPR)->priority_adj)

#define	EXPR_SCHED_TIMES(EXPR) ((EXPR)->sched_times)

#define	EXPR_ORIG_BB_INDEX(EXPR) ((EXPR)->orig_bb_index)

#define	EXPR_ORIG_SCHED_CYCLE(EXPR) ((EXPR)->orig_sched_cycle)

#define	EXPR_SPEC_DONE_DS(EXPR) ((EXPR)->spec_done_ds)

#define	EXPR_SPEC_TO_CHECK_DS(EXPR) ((EXPR)->spec_to_check_ds)

#define	EXPR_HISTORY_OF_CHANGES(EXPR) ((EXPR)->history_of_changes)

#define	EXPR_TARGET_AVAILABLE(EXPR) ((EXPR)->target_available)

#define	EXPR_NEEDS_SPEC_CHECK_P(EXPR) ((EXPR)->needs_spec_check_p)

#define	EXPR_WAS_SUBSTITUTED(EXPR) ((EXPR)->was_substituted)

#define	EXPR_WAS_RENAMED(EXPR) ((EXPR)->was_renamed)

#define	EXPR_CANT_MOVE(EXPR) ((EXPR)->cant_move)

#define	_AV_SET_EXPR(L) (&(L)->u.expr)

#define	_AV_SET_NEXT(L) (_LIST_NEXT (L))

#define	BND_TO(B) ((B)->to)

#define	BND_PTR(B) ((B)->ptr)

#define	BND_AV(B) ((B)->av)

#define	BND_AV1(B) ((B)->av1)

#define	BND_DC(B) ((B)->dc)

#define	BLIST_BND(L) (&(L)->u.bnd)

#define	BLIST_NEXT(L) (_LIST_NEXT (L))

#define	FENCE_INSN(F) ((F)->insn)

#define	FENCE_STATE(F) ((F)->state)

#define	FENCE_BNDS(F) ((F)->bnds)

#define	FENCE_PROCESSED_P(F) ((F)->processed_p)

#define	FENCE_SCHEDULED_P(F) ((F)->scheduled_p)

#define	FENCE_ISSUED_INSNS(F) ((F)->cycle_issued_insns)

#define	FENCE_CYCLE(F) ((F)->cycle)

#define	FENCE_STARTS_CYCLE_P(F) ((F)->starts_cycle_p)

#define	FENCE_AFTER_STALL_P(F) ((F)->after_stall_p)

#define	FENCE_DC(F) ((F)->dc)

#define	FENCE_TC(F) ((F)->tc)

#define	FENCE_LAST_SCHEDULED_INSN(F) ((F)->last_scheduled_insn)

#define	FENCE_ISSUE_MORE(F) ((F)->issue_more)

#define	FENCE_EXECUTING_INSNS(F) ((F)->executing_insns)

#define	FENCE_READY_TICKS(F) ((F)->ready_ticks)

#define	FENCE_READY_TICKS_SIZE(F) ((F)->ready_ticks_size)

#define	FENCE_SCHED_NEXT(F) ((F)->sched_next)

#define	FLIST_FENCE(L) (&(L)->u.fence)

#define	FLIST_NEXT(L) (_LIST_NEXT (L))

#define	FLIST_TAIL_HEAD(L) ((L)->head)

#define	FLIST_TAIL_TAILP(L) ((L)->tailp)

#define	_FOR_EACH(TYPE, ELEM, I, L)

#define	_FOR_EACH_1(TYPE, ELEM, I, LP)

#define	_xlist_remove(LP) (_list_remove (LP))

#define	_xlist_clear(LP) (_list_clear (LP))

#define	_xlist_iter_remove(IP) (_list_iter_remove (IP))

#define	_FOR_EACH_X(X, I, L) _FOR_EACH (x, (X), (I), (L))

#define	_FOR_EACH_X_1(X, I, LP) _FOR_EACH_1 (x, (X), (I), (LP))

#define	ilist_remove(LP) (_list_remove (LP))

#define	ilist_clear(LP) (_list_clear (LP))

#define	ilist_iter_remove(IP) (_list_iter_remove (IP))

#define	FOR_EACH_INSN(INSN, I, L) _FOR_EACH (insn, (INSN), (I), (L))

#define	FOR_EACH_INSN_1(INSN, I, LP) _FOR_EACH_1 (insn, (INSN), (I), (LP))

#define	FOR_EACH_EXPR(EXPR, I, AV) _FOR_EACH (expr, (EXPR), (I), (AV))

#define	FOR_EACH_EXPR_1(EXPR, I, AV) _FOR_EACH_1 (expr, (EXPR), (I), (AV))

#define	DEF_LIST_NEXT(L) (_LIST_NEXT (L))

#define	DEF_LIST_DEF(L) (&(L)->u.def)

#define	FOR_EACH_DEF(DEF, I, DEF_LIST) _FOR_EACH (def, (DEF), (I), (DEF_LIST))

#define	IDATA_TYPE(ID) ((ID)->type)

#define	IDATA_LHS(ID) ((ID)->lhs)

#define	IDATA_RHS(ID) ((ID)->rhs)

#define	IDATA_REG_SETS(ID) ((ID)->reg_sets)

#define	IDATA_REG_USES(ID) ((ID)->reg_uses)

#define	IDATA_REG_CLOBBERS(ID) ((ID)->reg_clobbers)

#define	VINSN_INSN_RTX(VI) ((VI)->insn_rtx)

#define	VINSN_PATTERN(VI) (PATTERN (VINSN_INSN_RTX (VI)))

#define	VINSN_ID(VI) (&((VI)->id))

#define	VINSN_HASH(VI) ((VI)->hash)

#define	VINSN_HASH_RTX(VI) ((VI)->hash_rtx)

#define	VINSN_TYPE(VI) (IDATA_TYPE (VINSN_ID (VI)))

#define	VINSN_SEPARABLE_P(VI) (VINSN_TYPE (VI) == SET)

#define	VINSN_CLONABLE_P(VI) (VINSN_SEPARABLE_P (VI) \|\| VINSN_TYPE (VI) == USE)

#define	VINSN_UNIQUE_P(VI) (!VINSN_CLONABLE_P (VI))

#define	VINSN_LHS(VI) (IDATA_LHS (VINSN_ID (VI)))

#define	VINSN_RHS(VI) (IDATA_RHS (VINSN_ID (VI)))

#define	VINSN_REG_SETS(VI) (IDATA_REG_SETS (VINSN_ID (VI)))

#define	VINSN_REG_USES(VI) (IDATA_REG_USES (VINSN_ID (VI)))

#define	VINSN_REG_CLOBBERS(VI) (IDATA_REG_CLOBBERS (VINSN_ID (VI)))

#define	VINSN_COUNT(VI) ((VI)->count)

#define	VINSN_MAY_TRAP_P(VI) ((VI)->may_trap_p)

#define	SID(INSN) (&s_i_d[INSN_LUID (INSN)])

#define	SID_BY_UID(UID) (&s_i_d[LUID_BY_UID (UID)])

#define	INSN_ASM_P(INSN) (SID (INSN)->asm_p)

#define	INSN_SCHED_NEXT(INSN) (SID (INSN)->sched_next)

#define	INSN_ANALYZED_DEPS(INSN) (SID (INSN)->analyzed_deps)

#define	INSN_FOUND_DEPS(INSN) (SID (INSN)->found_deps)

#define	INSN_DEPS_CONTEXT(INSN) (SID (INSN)->deps_context)

#define	INSN_ORIGINATORS(INSN) (SID (INSN)->originators)

#define	INSN_ORIGINATORS_BY_UID(UID) (SID_BY_UID (UID)->originators)

#define	INSN_TRANSFORMED_INSNS(INSN) (SID (INSN)->transformed_insns)

#define	INSN_EXPR(INSN) (&SID (INSN)->expr)

#define	INSN_LIVE(INSN) (SID (INSN)->live)

#define	INSN_LIVE_VALID_P(INSN) (SID (INSN)->live_valid_p)

#define	INSN_VINSN(INSN) (EXPR_VINSN (INSN_EXPR (INSN)))

#define	INSN_TYPE(INSN) (VINSN_TYPE (INSN_VINSN (INSN)))

#define	INSN_SIMPLEJUMP_P(INSN) (INSN_TYPE (INSN) == PC)

#define	INSN_LHS(INSN) (VINSN_LHS (INSN_VINSN (INSN)))

#define	INSN_RHS(INSN) (VINSN_RHS (INSN_VINSN (INSN)))

#define	INSN_REG_SETS(INSN) (VINSN_REG_SETS (INSN_VINSN (INSN)))

#define	INSN_REG_CLOBBERS(INSN) (VINSN_REG_CLOBBERS (INSN_VINSN (INSN)))

#define	INSN_REG_USES(INSN) (VINSN_REG_USES (INSN_VINSN (INSN)))

#define	INSN_SCHED_TIMES(INSN) (EXPR_SCHED_TIMES (INSN_EXPR (INSN)))

#define	INSN_SEQNO(INSN) (SID (INSN)->seqno)

#define	INSN_AFTER_STALL_P(INSN) (SID (INSN)->after_stall_p)

#define	INSN_SCHED_CYCLE(INSN) (SID (INSN)->sched_cycle)

#define	INSN_READY_CYCLE(INSN) (SID (INSN)->ready_cycle)

#define	INSN_SPEC_CHECKED_DS(INSN) (SID (INSN)->spec_checked_ds)

#define	INSN_WS_LEVEL(INSN) (SID (INSN)->ws_level)

#define	AV_SET(INSN) (get_av_set (INSN))

#define	AV_LEVEL(INSN) (get_av_level (INSN))

#define	AV_SET_VALID_P(INSN) (AV_LEVEL (INSN) == global_level)

#define	INSN_INIT_TODO_LUID (1)

#define	INSN_INIT_TODO_SSID (2)

#define	INSN_INIT_TODO_SIMPLEJUMP (4)

#define	INSN_NOP_P(INSN) (PATTERN (INSN) == nop_pattern)

#define	INSN_IN_STREAM_P(INSN) (PREV_INSN (INSN) && NEXT_INSN (INSN))

#define	IN_CURRENT_FENCE_P(INSN) (flist_lookup (fences, INSN) != NULL)

#define	MARK_LOOP_FOR_PIPELINING(LOOP) ((LOOP)->aux = (void *)(size_t)(1))

#define	LOOP_MARKED_FOR_PIPELINING_P(LOOP) ((size_t)((LOOP)->aux))

#define	LOOP_PREHEADER_BLOCKS(LOOP)

#define	SET_LOOP_PREHEADER_BLOCKS(LOOP, BLOCKS)

#define	SEL_GLOBAL_BB_INFO(BB) (&sel_global_bb_info[(BB)->index])

#define	BB_LV_SET(BB) (SEL_GLOBAL_BB_INFO (BB)->lv_set)

#define	BB_LV_SET_VALID_P(BB) (SEL_GLOBAL_BB_INFO (BB)->lv_set_valid_p)

#define	SEL_REGION_BB_INFO(BB) (&sel_region_bb_info[(BB)->index])

#define	BB_NOTE_LIST(BB) (SEL_REGION_BB_INFO (BB)->note_list)

#define	BB_AV_SET(BB) (SEL_REGION_BB_INFO (BB)->av_set)

#define	BB_AV_LEVEL(BB) (SEL_REGION_BB_INFO (BB)->av_level)

#define	BB_AV_SET_VALID_P(BB) (BB_AV_LEVEL (BB) == global_level)

#define	MAX_WS (param_selsched_max_lookahead)

#define	SUCCS_NORMAL (1)

#define	SUCCS_BACK (2)

#define	SUCCS_OUT (4)

#define	SUCCS_SKIP_TO_LOOP_EXITS (8)

#define	SUCCS_ALL (SUCCS_NORMAL \| SUCCS_BACK \| SUCCS_OUT)

#define	FOR_EACH_SUCC_1(SUCC, ITER, INSN, FLAGS)

#define	FOR_EACH_SUCC(SUCC, ITER, INSN) FOR_EACH_SUCC_1 (SUCC, ITER, INSN, SUCCS_NORMAL)

#define	SUCC_ITER_EDGE(ITER) ((ITER)->e1)

Typedefs
typedef void *	tc_t

typedef struct _list_node *	_list_t

typedef struct idata_def *	idata_t

typedef struct vinsn_def *	vinsn_t

typedef _list_t	_xlist_t

typedef rtx_insn *	insn_t

typedef _list_t	ilist_t

typedef struct expr_history_def_1	expr_history_def

typedef struct _expr	expr_def

typedef expr_def *	expr_t

typedef struct _def *	def_t

typedef _list_t	av_set_t

typedef struct _bnd *	bnd_t

typedef _list_t	blist_t

typedef struct _fence *	fence_t

typedef _list_t	flist_t

typedef struct flist_tail_def *	flist_tail_t

typedef _list_iterator	_xlist_iterator

typedef _list_iterator	ilist_iterator

typedef _list_iterator	av_set_iterator

typedef _list_t	def_list_t

typedef _list_iterator	def_list_iterator

typedef class _sel_insn_data	sel_insn_data_def

typedef sel_insn_data_def *	sel_insn_data_t

typedef sel_global_bb_info_def *	sel_global_bb_info_t

typedef sel_region_bb_info_def *	sel_region_bb_info_t

Enumerations
enum	local_trans_type { TRANS_SUBSTITUTION , TRANS_SPECULATION }

enum	deps_where_t { DEPS_IN_INSN , DEPS_IN_LHS , DEPS_IN_RHS , DEPS_IN_NOWHERE }

Functions
_list_t	_list_alloc (void)

void	_list_add (_list_t *lp)

void	_list_remove_nofree (_list_t *lp)

void	_list_remove (_list_t *lp)

void	_list_clear (_list_t *l)

void	_list_iter_start (_list_iterator ip, _list_t lp, bool can_remove_p)

void	_list_iter_next (_list_iterator *ip)

void	_list_iter_remove (_list_iterator *ip)

void	_list_iter_remove_nofree (_list_iterator *ip)

void	_xlist_add (_xlist_t *lp, rtx x)

bool	_xlist_is_in_p (_xlist_t l, rtx x)

bool	_list_iter_cond_x (_xlist_t l, rtx *xp)

void	ilist_add (ilist_t *lp, insn_t insn)

bool	ilist_is_in_p (ilist_t l, insn_t insn)

bool	_list_iter_cond_insn (ilist_t l, insn_t *ip)

bool	_list_iter_cond_expr (av_set_t av, expr_t *exprp)

bool	_list_iter_cond_def (def_list_t def_list, def_t *def)

sel_insn_data_def	insn_sid (insn_t)

av_set_t	get_av_set (insn_t)

int	get_av_level (insn_t)

void	sel_extend_global_bb_info (void)

void	sel_finish_global_bb_info (void)

rtx_insn *	sel_bb_head (basic_block)

rtx_insn *	sel_bb_end (basic_block)

bool	sel_bb_empty_p (basic_block)

bool	in_current_region_p (basic_block)

bool	inner_loop_header_p (basic_block bb)

vec< edge >	get_loop_exit_edges_unique_dests (const class loop *loop)

bool	sel_bb_empty_or_nop_p (basic_block bb)

vec< edge >	get_all_loop_exits (basic_block bb)

succ_iterator	_succ_iter_start (insn_t *succp, insn_t insn, int flags)

bool	_succ_iter_cond (succ_iterator ip, insn_t succp, insn_t insn, bool check(edge, succ_iterator *))

void	_succ_iter_next (succ_iterator *ip)

bool	_eligible_successor_edge_p (edge e1, succ_iterator *ip)

basic_block	bb_next_bb (basic_block bb)

ilist_t	ilist_copy (ilist_t)

ilist_t	ilist_invert (ilist_t)

void	blist_add (blist_t *, insn_t, ilist_t, deps_t)

void	blist_remove (blist_t *)

void	flist_tail_init (flist_tail_t)

fence_t	flist_lookup (flist_t, insn_t)

void	flist_clear (flist_t *)

void	def_list_add (def_list_t *, insn_t, unsigned int)

tc_t	create_target_context (bool)

void	set_target_context (tc_t)

void	reset_target_context (tc_t, bool)

void	advance_deps_context (deps_t, insn_t)

void	init_fences (insn_t)

void	add_clean_fence_to_fences (flist_tail_t, insn_t, fence_t)

void	add_dirty_fence_to_fences (flist_tail_t, insn_t, fence_t)

void	move_fence_to_fences (flist_t, flist_tail_t)

regset	get_regset_from_pool (void)

regset	get_clear_regset_from_pool (void)

void	return_regset_to_pool (regset)

void	free_regset_pool (void)

insn_t	get_nop_from_pool (insn_t)

void	return_nop_to_pool (insn_t, bool)

void	free_nop_pool (void)

bool	vinsn_separable_p (vinsn_t)

bool	vinsn_cond_branch_p (vinsn_t)

void	recompute_vinsn_lhs_rhs (vinsn_t)

int	sel_vinsn_cost (vinsn_t)

insn_t	sel_gen_insn_from_rtx_after (rtx, expr_t, int, insn_t)

insn_t	sel_gen_recovery_insn_from_rtx_after (rtx, expr_t, int, insn_t)

insn_t	sel_gen_insn_from_expr_after (expr_t, vinsn_t, int, insn_t)

insn_t	sel_move_insn (expr_t, int, insn_t)

void	vinsn_attach (vinsn_t)

void	vinsn_detach (vinsn_t)

vinsn_t	vinsn_copy (vinsn_t, bool)

bool	vinsn_equal_p (vinsn_t, vinsn_t)

void	copy_expr (expr_t, expr_t)

void	copy_expr_onside (expr_t, expr_t)

void	merge_expr_data (expr_t, expr_t, insn_t)

void	merge_expr (expr_t, expr_t, insn_t)

void	clear_expr (expr_t)

unsigned	expr_dest_regno (expr_t)

rtx	expr_dest_reg (expr_t)

int	find_in_history_vect (vec< expr_history_def >, rtx, vinsn_t, bool)

void	insert_in_history_vect (vec< expr_history_def > *, unsigned, enum local_trans_type, vinsn_t, vinsn_t, ds_t)

void	mark_unavailable_targets (av_set_t, av_set_t, regset)

int	speculate_expr (expr_t, ds_t)

void	av_set_add (av_set_t *, expr_t)

void	av_set_iter_remove (av_set_iterator *)

expr_t	av_set_lookup (av_set_t, vinsn_t)

expr_t	merge_with_other_exprs (av_set_t , av_set_iterator , expr_t)

bool	av_set_is_in_p (av_set_t, vinsn_t)

av_set_t	av_set_copy (av_set_t)

void	av_set_union_and_clear (av_set_t , av_set_t , insn_t)

void	av_set_union_and_live (av_set_t , av_set_t , regset, regset, insn_t)

void	av_set_clear (av_set_t *)

void	av_set_leave_one_nonspec (av_set_t *)

expr_t	av_set_element (av_set_t, int)

void	av_set_substract_cond_branches (av_set_t *)

void	av_set_split_usefulness (av_set_t, int, int)

void	av_set_code_motion_filter (av_set_t *, av_set_t)

void	sel_save_haifa_priorities (void)

void	sel_init_global_and_expr (bb_vec_t)

void	sel_finish_global_and_expr (void)

regset	compute_live (insn_t)

bool	register_unavailable_p (regset, rtx)

void	sel_clear_has_dependence (void)

ds_t	has_dependence_p (expr_t, insn_t, ds_t **)

int	tick_check_p (expr_t, deps_t, fence_t)

bool	lhs_of_insn_equals_to_dest_p (insn_t, rtx)

bool	insn_eligible_for_subst_p (insn_t)

void	get_dest_and_mode (rtx, rtx , machine_mode )

bool	bookkeeping_can_be_created_if_moved_through_p (insn_t)

bool	sel_remove_insn (insn_t, bool, bool)

bool	bb_header_p (insn_t)

void	sel_init_invalid_data_sets (insn_t)

bool	insn_at_boundary_p (insn_t)

bool	sel_bb_head_p (insn_t)

bool	sel_bb_end_p (insn_t)

basic_block	fallthru_bb_of_jump (const rtx_insn *)

void	sel_init_bbs (bb_vec_t)

void	sel_finish_bbs (void)

struct succs_info *	compute_succs_info (insn_t, short)

void	free_succs_info (struct succs_info *)

bool	sel_insn_has_single_succ_p (insn_t, int)

bool	sel_num_cfg_preds_gt_1 (insn_t)

int	get_seqno_by_preds (rtx_insn *)

bool	bb_ends_ebb_p (basic_block)

bool	in_same_ebb_p (insn_t, insn_t)

bool	tidy_control_flow (basic_block, bool)

void	free_bb_note_pool (void)

void	purge_empty_blocks (void)

basic_block	sel_split_edge (edge)

basic_block	sel_create_recovery_block (insn_t)

bool	sel_redirect_edge_and_branch (edge, basic_block)

void	sel_redirect_edge_and_branch_force (edge, basic_block)

void	sel_init_pipelining (void)

void	sel_finish_pipelining (void)

void	sel_sched_region (int)

loop_p	get_loop_nest_for_rgn (unsigned int)

bool	considered_for_pipelining_p (class loop *)

void	make_region_from_loop_preheader (vec< basic_block > *&)

void	sel_add_loop_preheaders (bb_vec_t *)

bool	sel_is_loop_preheader_p (basic_block)

void	clear_outdated_rtx_info (basic_block)

void	free_data_sets (basic_block)

void	exchange_data_sets (basic_block, basic_block)

void	copy_data_sets (basic_block, basic_block)

void	sel_register_cfg_hooks (void)

void	sel_unregister_cfg_hooks (void)

rtx_insn *	create_insn_rtx_from_pattern (rtx, rtx)

vinsn_t	create_vinsn_from_insn_rtx (rtx_insn *, bool)

rtx_insn *	create_copy_of_insn_rtx (rtx)

void	change_vinsn_in_expr (expr_t, vinsn_t)

void	init_lv_sets (void)

void	free_lv_sets (void)

void	setup_nop_and_exit_insns (void)

void	free_nop_and_exit_insns (void)

void	free_data_for_scheduled_insn (insn_t)

void	setup_nop_vinsn (void)

void	free_nop_vinsn (void)

void	sel_set_sched_flags (void)

void	sel_setup_sched_infos (void)

void	alloc_sched_pools (void)

void	free_sched_pools (void)

Macro Definition Documentation

◆ _AV_SET_EXPR

#define _AV_SET_EXPR ( L ) (&(L)->u.expr)

Referenced by _list_iter_cond_expr().

◆ _AV_SET_NEXT

#define _AV_SET_NEXT ( L ) (_LIST_NEXT (L))

◆ _FOR_EACH

#define _FOR_EACH	(	TYPE,
		ELEM,
		I,
		L )

Value:

  for (_list_iter_start (&(I), &(L), false);                    \
       _list_iter_cond_##TYPE (*(I).lp, &(ELEM));               \
       _list_iter_next (&(I)))

General macros to traverse a list.  FOR_EACH_* interfaces are
implemented using these.

◆ _FOR_EACH_1

#define _FOR_EACH_1	(	TYPE,
		ELEM,
		I,
		LP )

Value:

  for (_list_iter_start (&(I), (LP), true);                         \
       _list_iter_cond_##TYPE (*(I).lp, &(ELEM));                   \
       _list_iter_next (&(I)))

◆ _FOR_EACH_X

#define _FOR_EACH_X	(	X,
		I,
		L ) _FOR_EACH (x, (X), (I), (L))

◆ _FOR_EACH_X_1

#define _FOR_EACH_X_1	(	X,
		I,
		LP ) _FOR_EACH_1 (x, (X), (I), (LP))

◆ _LIST_NEXT

#define _LIST_NEXT ( L ) ((L)->next)

Referenced by _list_add(), _list_iter_next(), _list_remove(), and _list_remove_nofree().

◆ _xlist_clear

#define _xlist_clear ( LP ) (_list_clear (LP))

◆ _xlist_iter_remove

#define _xlist_iter_remove ( IP ) (_list_iter_remove (IP))

◆ _XLIST_NEXT

#define _XLIST_NEXT ( L ) (_LIST_NEXT (L))

Referenced by _xlist_is_in_p().

◆ _xlist_remove

#define _xlist_remove ( LP ) (_list_remove (LP))

◆ _XLIST_X

#define _XLIST_X ( L ) ((L)->u.x)

Referenced by _list_iter_cond_x(), _xlist_add(), and _xlist_is_in_p().

◆ AV_LEVEL

#define AV_LEVEL ( INSN ) (get_av_level (INSN))

◆ AV_SET

#define AV_SET ( INSN ) (get_av_set (INSN))

◆ AV_SET_VALID_P

#define AV_SET_VALID_P ( INSN ) (AV_LEVEL (INSN) == global_level)

◆ BB_AV_LEVEL

#define BB_AV_LEVEL ( BB ) (SEL_REGION_BB_INFO (BB)->av_level)

◆ BB_AV_SET

#define BB_AV_SET ( BB ) (SEL_REGION_BB_INFO (BB)->av_set)

◆ BB_AV_SET_VALID_P

#define BB_AV_SET_VALID_P ( BB ) (BB_AV_LEVEL (BB) == global_level)

◆ BB_LV_SET

#define BB_LV_SET ( BB ) (SEL_GLOBAL_BB_INFO (BB)->lv_set)

Access macros.

◆ BB_LV_SET_VALID_P

#define BB_LV_SET_VALID_P ( BB ) (SEL_GLOBAL_BB_INFO (BB)->lv_set_valid_p)

◆ BB_NOTE_LIST

#define BB_NOTE_LIST ( BB ) (SEL_REGION_BB_INFO (BB)->note_list)

Get BB's note_list.
A note_list is a list of various notes that was scattered across BB
before scheduling, and will be appended at the beginning of BB after
scheduling is finished.

◆ BLIST_BND

#define BLIST_BND ( L ) (&(L)->u.bnd)

◆ BLIST_NEXT

#define BLIST_NEXT ( L ) (_LIST_NEXT (L))

◆ BND_AV

#define BND_AV ( B ) ((B)->av)

◆ BND_AV1

#define BND_AV1 ( B ) ((B)->av1)

◆ BND_DC

#define BND_DC ( B ) ((B)->dc)

◆ BND_PTR

#define BND_PTR ( B ) ((B)->ptr)

PTR stands not for pointer as you might think, but as a Path To Root of the
current instruction group from boundary B.

◆ BND_TO

#define BND_TO ( B ) ((B)->to)

◆ DEF_LIST_DEF

#define DEF_LIST_DEF ( L ) (&(L)->u.def)

Referenced by _list_iter_cond_def().

◆ DEF_LIST_NEXT

#define DEF_LIST_NEXT ( L ) (_LIST_NEXT (L))

◆ EXPR_CANT_MOVE

#define EXPR_CANT_MOVE ( EXPR ) ((EXPR)->cant_move)

◆ EXPR_HISTORY_OF_CHANGES

#define EXPR_HISTORY_OF_CHANGES ( EXPR ) ((EXPR)->history_of_changes)

◆ EXPR_INSN_RTX

#define EXPR_INSN_RTX ( EXPR ) (VINSN_INSN_RTX (EXPR_VINSN (EXPR)))

◆ EXPR_LHS

#define EXPR_LHS ( EXPR ) (VINSN_LHS (EXPR_VINSN (EXPR)))

◆ EXPR_NEEDS_SPEC_CHECK_P

#define EXPR_NEEDS_SPEC_CHECK_P ( EXPR ) ((EXPR)->needs_spec_check_p)

◆ EXPR_ORIG_BB_INDEX

#define EXPR_ORIG_BB_INDEX ( EXPR ) ((EXPR)->orig_bb_index)

◆ EXPR_ORIG_SCHED_CYCLE

#define EXPR_ORIG_SCHED_CYCLE ( EXPR ) ((EXPR)->orig_sched_cycle)

◆ EXPR_PATTERN

#define EXPR_PATTERN ( EXPR ) (VINSN_PATTERN (EXPR_VINSN (EXPR)))

◆ EXPR_PRIORITY

#define EXPR_PRIORITY ( EXPR ) ((EXPR)->priority)

◆ EXPR_PRIORITY_ADJ

#define EXPR_PRIORITY_ADJ ( EXPR ) ((EXPR)->priority_adj)

◆ EXPR_RHS

#define EXPR_RHS ( EXPR ) (VINSN_RHS (EXPR_VINSN (EXPR)))

◆ EXPR_SCHED_TIMES

#define EXPR_SCHED_TIMES ( EXPR ) ((EXPR)->sched_times)

◆ EXPR_SEPARABLE_P

#define EXPR_SEPARABLE_P ( EXPR ) (VINSN_SEPARABLE_P (EXPR_VINSN (EXPR)))

◆ EXPR_SPEC

#define EXPR_SPEC ( EXPR ) ((EXPR)->spec)

◆ EXPR_SPEC_DONE_DS

#define EXPR_SPEC_DONE_DS ( EXPR ) ((EXPR)->spec_done_ds)

◆ EXPR_SPEC_TO_CHECK_DS

#define EXPR_SPEC_TO_CHECK_DS ( EXPR ) ((EXPR)->spec_to_check_ds)

◆ EXPR_TARGET_AVAILABLE

#define EXPR_TARGET_AVAILABLE ( EXPR ) ((EXPR)->target_available)

◆ EXPR_TYPE

#define EXPR_TYPE ( EXPR ) (VINSN_TYPE (EXPR_VINSN (EXPR)))

◆ EXPR_USEFULNESS

#define EXPR_USEFULNESS ( EXPR ) ((EXPR)->usefulness)

◆ EXPR_VINSN

#define EXPR_VINSN ( EXPR ) ((EXPR)->vinsn)

◆ EXPR_WAS_RENAMED

#define EXPR_WAS_RENAMED ( EXPR ) ((EXPR)->was_renamed)

◆ EXPR_WAS_SUBSTITUTED

#define EXPR_WAS_SUBSTITUTED ( EXPR ) ((EXPR)->was_substituted)

◆ FENCE_AFTER_STALL_P

#define FENCE_AFTER_STALL_P ( F ) ((F)->after_stall_p)

◆ FENCE_BNDS

#define FENCE_BNDS ( F ) ((F)->bnds)

◆ FENCE_CYCLE

#define FENCE_CYCLE ( F ) ((F)->cycle)

◆ FENCE_DC

#define FENCE_DC ( F ) ((F)->dc)

◆ FENCE_EXECUTING_INSNS

#define FENCE_EXECUTING_INSNS ( F ) ((F)->executing_insns)

◆ FENCE_INSN

#define FENCE_INSN ( F ) ((F)->insn)

◆ FENCE_ISSUE_MORE

#define FENCE_ISSUE_MORE ( F ) ((F)->issue_more)

◆ FENCE_ISSUED_INSNS

#define FENCE_ISSUED_INSNS ( F ) ((F)->cycle_issued_insns)

◆ FENCE_LAST_SCHEDULED_INSN

#define FENCE_LAST_SCHEDULED_INSN ( F ) ((F)->last_scheduled_insn)

◆ FENCE_PROCESSED_P

#define FENCE_PROCESSED_P ( F ) ((F)->processed_p)

◆ FENCE_READY_TICKS

#define FENCE_READY_TICKS ( F ) ((F)->ready_ticks)

◆ FENCE_READY_TICKS_SIZE

#define FENCE_READY_TICKS_SIZE ( F ) ((F)->ready_ticks_size)

◆ FENCE_SCHED_NEXT

#define FENCE_SCHED_NEXT ( F ) ((F)->sched_next)

◆ FENCE_SCHEDULED_P

#define FENCE_SCHEDULED_P ( F ) ((F)->scheduled_p)

◆ FENCE_STARTS_CYCLE_P

#define FENCE_STARTS_CYCLE_P ( F ) ((F)->starts_cycle_p)

◆ FENCE_STATE

#define FENCE_STATE ( F ) ((F)->state)

◆ FENCE_TC

#define FENCE_TC ( F ) ((F)->tc)

◆ FLIST_FENCE

#define FLIST_FENCE ( L ) (&(L)->u.fence)

◆ FLIST_NEXT

#define FLIST_NEXT ( L ) (_LIST_NEXT (L))

◆ FLIST_TAIL_HEAD

#define FLIST_TAIL_HEAD ( L ) ((L)->head)

◆ FLIST_TAIL_TAILP

#define FLIST_TAIL_TAILP ( L ) ((L)->tailp)

◆ FOR_EACH_DEF

#define FOR_EACH_DEF	(	DEF,
		I,
		DEF_LIST ) _FOR_EACH (def, (DEF), (I), (DEF_LIST))

◆ FOR_EACH_EXPR

#define FOR_EACH_EXPR	(	EXPR,
		I,
		AV ) _FOR_EACH (expr, (EXPR), (I), (AV))

◆ FOR_EACH_EXPR_1

#define FOR_EACH_EXPR_1	(	EXPR,
		I,
		AV ) _FOR_EACH_1 (expr, (EXPR), (I), (AV))

◆ FOR_EACH_INSN

#define FOR_EACH_INSN	(	INSN,
		I,
		L ) _FOR_EACH (insn, (INSN), (I), (L))

◆ FOR_EACH_INSN_1

#define FOR_EACH_INSN_1	(	INSN,
		I,
		LP ) _FOR_EACH_1 (insn, (INSN), (I), (LP))

◆ FOR_EACH_SUCC

#define FOR_EACH_SUCC	(	SUCC,
		ITER,
		INSN ) FOR_EACH_SUCC_1 (SUCC, ITER, INSN, SUCCS_NORMAL)

◆ FOR_EACH_SUCC_1

#define FOR_EACH_SUCC_1	(	SUCC,
		ITER,
		INSN,
		FLAGS )

Value:

  for ((ITER) = _succ_iter_start (&(SUCC), (INSN), (FLAGS));            \
       _succ_iter_cond (&(ITER), &(SUCC), (INSN), _eligible_successor_edge_p); \
       _succ_iter_next (&(ITER)))

◆ IDATA_LHS

#define IDATA_LHS ( ID ) ((ID)->lhs)

◆ IDATA_REG_CLOBBERS

#define IDATA_REG_CLOBBERS ( ID ) ((ID)->reg_clobbers)

◆ IDATA_REG_SETS

#define IDATA_REG_SETS ( ID ) ((ID)->reg_sets)

◆ IDATA_REG_USES

#define IDATA_REG_USES ( ID ) ((ID)->reg_uses)

◆ IDATA_RHS

#define IDATA_RHS ( ID ) ((ID)->rhs)

◆ IDATA_TYPE

#define IDATA_TYPE ( ID ) ((ID)->type)

◆ ilist_clear

#define ilist_clear ( LP ) (_list_clear (LP))

◆ ILIST_INSN

#define ILIST_INSN ( L ) ((L)->u.insn)

Referenced by _list_iter_cond_insn(), ilist_add(), and ilist_is_in_p().

◆ ilist_iter_remove

#define ilist_iter_remove ( IP ) (_list_iter_remove (IP))

◆ ILIST_NEXT

#define ILIST_NEXT ( L ) (_LIST_NEXT (L))

Referenced by ilist_is_in_p().

◆ ilist_remove

#define ilist_remove ( LP ) (_list_remove (LP))

◆ IN_CURRENT_FENCE_P

#define IN_CURRENT_FENCE_P ( INSN ) (flist_lookup (fences, INSN) != NULL)

Return true if INSN is in current fence.

◆ INSN_AFTER_STALL_P

#define INSN_AFTER_STALL_P ( INSN ) (SID (INSN)->after_stall_p)

◆ INSN_ANALYZED_DEPS

#define INSN_ANALYZED_DEPS ( INSN ) (SID (INSN)->analyzed_deps)

◆ INSN_ASM_P

#define INSN_ASM_P ( INSN ) (SID (INSN)->asm_p)

◆ INSN_DEPS_CONTEXT

#define INSN_DEPS_CONTEXT ( INSN ) (SID (INSN)->deps_context)

◆ INSN_EXPR

#define INSN_EXPR ( INSN ) (&SID (INSN)->expr)

◆ INSN_FOUND_DEPS

#define INSN_FOUND_DEPS ( INSN ) (SID (INSN)->found_deps)

◆ INSN_IN_STREAM_P

#define INSN_IN_STREAM_P ( INSN ) (PREV_INSN (INSN) && NEXT_INSN (INSN))

Return true if INSN is linked into instruction stream.
NB: It is impossible for INSN to have one field null and the other not
null: gcc_assert ((PREV_INSN (INSN) == NULL_RTX)
== (NEXT_INSN (INSN) == NULL_RTX)) is valid.

◆ INSN_INIT_TODO_LUID

#define INSN_INIT_TODO_LUID (1)

Provide a separate luid for the insn.

◆ INSN_INIT_TODO_SIMPLEJUMP

#define INSN_INIT_TODO_SIMPLEJUMP (4)

Initialize data for simplejump.

◆ INSN_INIT_TODO_SSID

#define INSN_INIT_TODO_SSID (2)

Initialize s_s_i_d.

◆ INSN_LHS

#define INSN_LHS ( INSN ) (VINSN_LHS (INSN_VINSN (INSN)))

◆ INSN_LIVE

#define INSN_LIVE ( INSN ) (SID (INSN)->live)

◆ INSN_LIVE_VALID_P

#define INSN_LIVE_VALID_P ( INSN ) (SID (INSN)->live_valid_p)

◆ INSN_NOP_P

#define INSN_NOP_P ( INSN ) (PATTERN (INSN) == nop_pattern)

Return true if INSN is a local NOP.  The nop is local in the sense that
it was emitted by the scheduler as a temporary insn and will soon be
deleted.  These nops are identified by their pattern.

Referenced by sel_bb_empty_or_nop_p().

◆ INSN_ORIGINATORS

#define INSN_ORIGINATORS ( INSN ) (SID (INSN)->originators)

◆ INSN_ORIGINATORS_BY_UID

#define INSN_ORIGINATORS_BY_UID ( UID ) (SID_BY_UID (UID)->originators)

◆ INSN_READY_CYCLE

#define INSN_READY_CYCLE ( INSN ) (SID (INSN)->ready_cycle)

◆ INSN_REG_CLOBBERS

#define INSN_REG_CLOBBERS ( INSN ) (VINSN_REG_CLOBBERS (INSN_VINSN (INSN)))

◆ INSN_REG_SETS

#define INSN_REG_SETS ( INSN ) (VINSN_REG_SETS (INSN_VINSN (INSN)))

◆ INSN_REG_USES

#define INSN_REG_USES ( INSN ) (VINSN_REG_USES (INSN_VINSN (INSN)))

◆ INSN_RHS

#define INSN_RHS ( INSN ) (VINSN_RHS (INSN_VINSN (INSN)))

◆ INSN_SCHED_CYCLE

#define INSN_SCHED_CYCLE ( INSN ) (SID (INSN)->sched_cycle)

◆ INSN_SCHED_NEXT

#define INSN_SCHED_NEXT ( INSN ) (SID (INSN)->sched_next)

◆ INSN_SCHED_TIMES

#define INSN_SCHED_TIMES ( INSN ) (EXPR_SCHED_TIMES (INSN_EXPR (INSN)))

◆ INSN_SEQNO

#define INSN_SEQNO ( INSN ) (SID (INSN)->seqno)

◆ INSN_SIMPLEJUMP_P

#define INSN_SIMPLEJUMP_P ( INSN ) (INSN_TYPE (INSN) == PC)

◆ INSN_SPEC_CHECKED_DS

#define INSN_SPEC_CHECKED_DS ( INSN ) (SID (INSN)->spec_checked_ds)

◆ INSN_TRANSFORMED_INSNS

#define INSN_TRANSFORMED_INSNS ( INSN ) (SID (INSN)->transformed_insns)

◆ INSN_TYPE

#define INSN_TYPE ( INSN ) (VINSN_TYPE (INSN_VINSN (INSN)))

◆ INSN_VINSN

#define INSN_VINSN ( INSN ) (EXPR_VINSN (INSN_EXPR (INSN)))

◆ INSN_WS_LEVEL

#define INSN_WS_LEVEL ( INSN ) (SID (INSN)->ws_level)

◆ LOOP_MARKED_FOR_PIPELINING_P

#define LOOP_MARKED_FOR_PIPELINING_P ( LOOP ) ((size_t)((LOOP)->aux))

◆ LOOP_PREHEADER_BLOCKS

#define LOOP_PREHEADER_BLOCKS ( LOOP )

Value:

                                     ((size_t)((LOOP)->aux) == 1         \
                                     ? NULL                             \
                                     : ((vec<basic_block> *) (LOOP)->aux))

Saved loop preheader to transfer when scheduling the loop.

◆ MARK_LOOP_FOR_PIPELINING

#define MARK_LOOP_FOR_PIPELINING ( LOOP ) ((LOOP)->aux = (void *)(size_t)(1))

Marks loop as being considered for pipelining.

◆ MAX_WS

#define MAX_WS (param_selsched_max_lookahead)

Software lookahead window size.
According to the results in Nakatani and Ebcioglu [1993], window size of 16
is enough to extract most ILP in integer code.

◆ SEL_GLOBAL_BB_INFO

#define SEL_GLOBAL_BB_INFO ( BB ) (&sel_global_bb_info[(BB)->index])

Get data for BB.

◆ SEL_REGION_BB_INFO

#define SEL_REGION_BB_INFO ( BB ) (&sel_region_bb_info[(BB)->index])

Get data for BB.

◆ SET_LOOP_PREHEADER_BLOCKS

#define SET_LOOP_PREHEADER_BLOCKS	(		LOOP,
			BLOCKS )

Value:

                                                ((LOOP)->aux             \
                                                = (BLOCKS != NULL       \
                                                   ? BLOCKS             \
                                                   : (LOOP)->aux))

◆ SID

#define SID ( INSN ) (&s_i_d[INSN_LUID (INSN)])

Accessor macros for s_i_d.

◆ SID_BY_UID

#define SID_BY_UID ( UID ) (&s_i_d[LUID_BY_UID (UID)])

◆ SUCC_ITER_EDGE

#define SUCC_ITER_EDGE ( ITER ) ((ITER)->e1)

Return the current edge along which a successor was built.

◆ SUCCS_ALL

#define SUCCS_ALL (SUCCS_NORMAL | SUCCS_BACK | SUCCS_OUT)

Include all successors.

◆ SUCCS_BACK

#define SUCCS_BACK (2)

Include back-edge successors.

Referenced by _eligible_successor_edge_p().

◆ SUCCS_NORMAL

#define SUCCS_NORMAL (1)

Flags to pass to compute_succs_info and FOR_EACH_SUCC.
Any successor will fall into exactly one category.

Include normal successors.

Referenced by _eligible_successor_edge_p(), and _succ_iter_cond().

◆ SUCCS_OUT

#define SUCCS_OUT (4)

Include successors that are outside of the current region.

Referenced by _eligible_successor_edge_p().

◆ SUCCS_SKIP_TO_LOOP_EXITS

#define SUCCS_SKIP_TO_LOOP_EXITS (8)

When pipelining of the outer loops is enabled, skip innermost loops
to their exits.

Referenced by _eligible_successor_edge_p(), and _succ_iter_cond().

◆ VINSN_CLONABLE_P

#define VINSN_CLONABLE_P ( VI ) (VINSN_SEPARABLE_P (VI) || VINSN_TYPE (VI) == USE)

◆ VINSN_COUNT

#define VINSN_COUNT ( VI ) ((VI)->count)

◆ VINSN_HASH

#define VINSN_HASH ( VI ) ((VI)->hash)

◆ VINSN_HASH_RTX

#define VINSN_HASH_RTX ( VI ) ((VI)->hash_rtx)

◆ VINSN_ID

#define VINSN_ID ( VI ) (&((VI)->id))

◆ VINSN_INSN_RTX

#define VINSN_INSN_RTX ( VI ) ((VI)->insn_rtx)

◆ VINSN_LHS

#define VINSN_LHS ( VI ) (IDATA_LHS (VINSN_ID (VI)))

◆ VINSN_MAY_TRAP_P

#define VINSN_MAY_TRAP_P ( VI ) ((VI)->may_trap_p)

◆ VINSN_PATTERN

#define VINSN_PATTERN ( VI ) (PATTERN (VINSN_INSN_RTX (VI)))

◆ VINSN_REG_CLOBBERS

#define VINSN_REG_CLOBBERS ( VI ) (IDATA_REG_CLOBBERS (VINSN_ID (VI)))

◆ VINSN_REG_SETS

#define VINSN_REG_SETS ( VI ) (IDATA_REG_SETS (VINSN_ID (VI)))

◆ VINSN_REG_USES

#define VINSN_REG_USES ( VI ) (IDATA_REG_USES (VINSN_ID (VI)))

◆ VINSN_RHS

#define VINSN_RHS ( VI ) (IDATA_RHS (VINSN_ID (VI)))

◆ VINSN_SEPARABLE_P

#define VINSN_SEPARABLE_P ( VI ) (VINSN_TYPE (VI) == SET)

◆ VINSN_TYPE

#define VINSN_TYPE ( VI ) (IDATA_TYPE (VINSN_ID (VI)))

◆ VINSN_UNIQUE_P

#define VINSN_UNIQUE_P ( VI ) (!VINSN_CLONABLE_P (VI))

Typedef Documentation

◆ _list_t

typedef struct _list_node* _list_t

List backend.

◆ _xlist_iterator

typedef _list_iterator _xlist_iterator

◆ _xlist_t

typedef _list_t _xlist_t

RTX list.
This type is the backend for ilist.

◆ av_set_iterator

typedef _list_iterator av_set_iterator

Av set iterators.

◆ av_set_t

typedef _list_t av_set_t

Availability sets are sets of expressions we're scheduling.

◆ blist_t

typedef _list_t blist_t

List of boundaries.

◆ bnd_t

typedef struct _bnd* bnd_t

◆ def_list_iterator

typedef _list_iterator def_list_iterator

◆ def_list_t

typedef _list_t def_list_t

Def list iterators.

◆ def_t

typedef struct _def* def_t

◆ expr_def

typedef struct _expr expr_def

◆ expr_history_def

typedef struct expr_history_def_1 expr_history_def

◆ expr_t

typedef expr_def* expr_t

◆ fence_t

typedef struct _fence* fence_t

◆ flist_t

typedef _list_t flist_t

List of fences.

◆ flist_tail_t

typedef struct flist_tail_def* flist_tail_t

◆ idata_t

typedef struct idata_def* idata_t

◆ ilist_iterator

typedef _list_iterator ilist_iterator

◆ ilist_t

typedef _list_t ilist_t

List of insns.

◆ insn_t

typedef rtx_insn* insn_t

Instruction.

◆ sel_global_bb_info_t

typedef sel_global_bb_info_def* sel_global_bb_info_t

◆ sel_insn_data_def

typedef class _sel_insn_data sel_insn_data_def

◆ sel_insn_data_t

typedef sel_insn_data_def* sel_insn_data_t

◆ sel_region_bb_info_t

typedef sel_region_bb_info_def* sel_region_bb_info_t

◆ tc_t

typedef void* tc_t

Instruction scheduling pass.  This file contains definitions used
   internally in the scheduler.
   Copyright (C) 2006-2024 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/>.

For state_t.

For reg_note.

tc_t is a short for target context.  This is a state of the target
backend.

◆ vinsn_t

typedef struct vinsn_def* vinsn_t

Enumeration Type Documentation

◆ deps_where_t

enum deps_where_t

A variable to track which part of rtx we are scanning in
sched-deps.cc: sched_analyze_insn ().

Enumerator
DEPS_IN_INSN
DEPS_IN_LHS
DEPS_IN_RHS
DEPS_IN_NOWHERE

◆ local_trans_type

enum local_trans_type

This lists possible transformations that done locally, i.e. in
moveup_expr.

Enumerator
TRANS_SUBSTITUTION
TRANS_SPECULATION

Function Documentation

◆ _eligible_successor_edge_p()

bool _eligible_successor_edge_p	(	edge	e1,
		succ_iterator *	ip )

inline

Returns true when E1 is an eligible successor edge, possibly skipping
empty blocks.  When E2P is not null, the resulting edge is written there.
FLAGS are used to specify whether back edges and out-of-region edges
should be considered.

References EDGE_COUNT, EDGE_SUCC, gcc_assert, ggc_alloc(), in_current_region_p(), basic_block_def::index, basic_block_def::loop_father, pipelining_p, sel_bb_empty_or_nop_p(), sel_bb_empty_p(), basic_block_def::succs, SUCCS_BACK, SUCCS_NORMAL, SUCCS_OUT, and SUCCS_SKIP_TO_LOOP_EXITS.

◆ _list_add()

void _list_add ( _list_t * lp )

inline

References _list_alloc(), and _LIST_NEXT.

Referenced by _xlist_add(), and ilist_add().

◆ _list_alloc()

_list_t _list_alloc ( void )

inline

References sched_lists_pool.

Referenced by _list_add().

◆ _list_clear()

void _list_clear ( _list_t * l )

inline

References _list_remove().

◆ _list_iter_cond_def()

bool _list_iter_cond_def	(	def_list_t	def_list,
		def_t *	def )

inline

References DEF_LIST_DEF, and ggc_alloc().

◆ _list_iter_cond_expr()

bool _list_iter_cond_expr	(	av_set_t	av,
		expr_t *	exprp )

inline

References _AV_SET_EXPR, and ggc_alloc().

◆ _list_iter_cond_insn()

bool _list_iter_cond_insn	(	ilist_t	l,
		insn_t *	ip )

inline

Used through _FOR_EACH.

References ggc_alloc(), and ILIST_INSN.

◆ _list_iter_cond_x()

bool _list_iter_cond_x	(	_xlist_t	l,
		rtx *	xp )

inline

Used through _FOR_EACH.

References _XLIST_X, and ggc_alloc().

◆ _list_iter_next()

void _list_iter_next ( _list_iterator * ip )

inline

References _LIST_NEXT, and ggc_alloc().

◆ _list_iter_remove()

void _list_iter_remove ( _list_iterator * ip )

inline

References _list_remove(), gcc_assert, and ggc_alloc().

◆ _list_iter_remove_nofree()

void _list_iter_remove_nofree ( _list_iterator * ip )

inline

References _list_remove_nofree(), gcc_assert, and ggc_alloc().

◆ _list_iter_start()

void _list_iter_start	(	_list_iterator *	ip,
		_list_t *	lp,
		bool	can_remove_p )

inline

References ggc_alloc().

◆ _list_remove()

void _list_remove ( _list_t * lp )

inline

References _LIST_NEXT, and sched_lists_pool.

Referenced by _list_clear(), and _list_iter_remove().

◆ _list_remove_nofree()

void _list_remove_nofree ( _list_t * lp )

inline

References _LIST_NEXT.

Referenced by _list_iter_remove_nofree().

◆ _succ_iter_cond()

bool _succ_iter_cond	(	succ_iterator *	ip,
		insn_t *	succp,
		insn_t	insn,
		bool	checkedge, succ_iterator * )

inline

References after_recovery, bb_note(), BLOCK_FOR_INSN(), cfun, ei_cond(), ei_next(), EXIT_BLOCK_PTR_FOR_FN, exit_insn, gcc_assert, get_all_loop_exits(), ggc_alloc(), in_current_region_p(), basic_block_def::index, NEXT_INSN(), NULL, sel_bb_head(), SUCCS_NORMAL, and SUCCS_SKIP_TO_LOOP_EXITS.

◆ _succ_iter_next()

void _succ_iter_next ( succ_iterator * ip )

inline

References ei_next(), gcc_assert, and ggc_alloc().

◆ _succ_iter_start()

succ_iterator _succ_iter_start	(	insn_t *	succp,
		insn_t	insn,
		int	flags )

inline

We need to return a succ_iterator to avoid 'unitialized' warning
during bootstrap.

References BB_END, BLOCK_FOR_INSN(), cfun, ei_start, EXIT_BLOCK_PTR_FOR_FN, gcc_assert, ggc_alloc(), i, basic_block_def::index, INSN_P, NOTE_INSN_BASIC_BLOCK_P, NULL, and basic_block_def::succs.

◆ _xlist_add()

void _xlist_add	(	_xlist_t *	lp,
		rtx	x )

inline

_xlist_t functions.

References _list_add(), and _XLIST_X.

◆ _xlist_is_in_p()

bool _xlist_is_in_p	(	_xlist_t	l,
		rtx	x )

inline

References _XLIST_NEXT, and _XLIST_X.

◆ add_clean_fence_to_fences()

void add_clean_fence_to_fences	(	flist_tail_t	,
		insn_t	,
		fence_t	)

extern

◆ add_dirty_fence_to_fences()

void add_dirty_fence_to_fences	(	flist_tail_t	,
		insn_t	,
		fence_t	)

extern

◆ advance_deps_context()

void advance_deps_context	(	deps_t	,
		insn_t	)

extern

Deps context functions.

◆ alloc_sched_pools()

void alloc_sched_pools ( void )

extern

◆ av_set_add()

void av_set_add	(	av_set_t *	,
		expr_t	)

extern

Av set functions.

◆ av_set_clear()

void av_set_clear ( av_set_t * )

extern

◆ av_set_code_motion_filter()

void av_set_code_motion_filter	(	av_set_t *	,
		av_set_t	)

extern

◆ av_set_copy()

av_set_t av_set_copy ( av_set_t )

extern

◆ av_set_element()

expr_t av_set_element	(	av_set_t	,
		int	)

extern

◆ av_set_is_in_p()

bool av_set_is_in_p	(	av_set_t	,
		vinsn_t	)

extern

◆ av_set_iter_remove()

void av_set_iter_remove ( av_set_iterator * )

extern

◆ av_set_leave_one_nonspec()

void av_set_leave_one_nonspec ( av_set_t * )

extern

◆ av_set_lookup()

expr_t av_set_lookup	(	av_set_t	,
		vinsn_t	)

extern

◆ av_set_split_usefulness()

void av_set_split_usefulness	(	av_set_t	,
		int	,
		int	)

extern

◆ av_set_substract_cond_branches()

void av_set_substract_cond_branches ( av_set_t * )

extern

◆ av_set_union_and_clear()

void av_set_union_and_clear	(	av_set_t *	,
		av_set_t *	,
		insn_t	)

extern

◆ av_set_union_and_live()

void av_set_union_and_live	(	av_set_t *	,
		av_set_t *	,
		regset	,
		regset	,
		insn_t	)

extern

◆ bb_ends_ebb_p()

bool bb_ends_ebb_p ( basic_block )

extern

◆ bb_header_p()

bool bb_header_p ( insn_t )

extern

◆ bb_next_bb()

basic_block bb_next_bb ( basic_block bb )

inline

Return the next block of BB not running into inconsistencies.

References EDGE_COUNT, FALLTHRU_EDGE, basic_block_def::next_bb, single_succ(), and basic_block_def::succs.

◆ blist_add()

void blist_add	(	blist_t *	,
		insn_t	,
		ilist_t	,
		deps_t	)

extern

◆ blist_remove()

void blist_remove ( blist_t * )

extern

◆ bookkeeping_can_be_created_if_moved_through_p()

bool bookkeeping_can_be_created_if_moved_through_p ( insn_t )

extern

◆ change_vinsn_in_expr()

void change_vinsn_in_expr	(	expr_t	,
		vinsn_t	)

extern

◆ clear_expr()

void clear_expr ( expr_t )

extern

◆ clear_outdated_rtx_info()

void clear_outdated_rtx_info ( basic_block )

extern

◆ compute_live()

regset compute_live ( insn_t )

extern

◆ compute_succs_info()

struct succs_info * compute_succs_info	(	insn_t	,
		short	)

extern

◆ considered_for_pipelining_p()

bool considered_for_pipelining_p ( class loop * )

extern

◆ copy_data_sets()

void copy_data_sets	(	basic_block	,
		basic_block	)

extern

◆ copy_expr()

void copy_expr	(	expr_t	,
		expr_t	)

extern

EXPR functions.

◆ copy_expr_onside()

void copy_expr_onside	(	expr_t	,
		expr_t	)

extern

◆ create_copy_of_insn_rtx()

rtx_insn * create_copy_of_insn_rtx ( rtx )

extern

◆ create_insn_rtx_from_pattern()

rtx_insn * create_insn_rtx_from_pattern	(	rtx	,
		rtx	)

extern

Expression transformation routines.

◆ create_target_context()

tc_t create_target_context ( bool )

extern

Target context functions.

◆ create_vinsn_from_insn_rtx()

vinsn_t create_vinsn_from_insn_rtx	(	rtx_insn *	,
		bool	)

extern

◆ def_list_add()

void def_list_add	(	def_list_t *	,
		insn_t	,
		unsigned int	)

extern

◆ exchange_data_sets()

void exchange_data_sets	(	basic_block	,
		basic_block	)

extern

◆ expr_dest_reg()

rtx expr_dest_reg ( expr_t )

extern

◆ expr_dest_regno()

unsigned expr_dest_regno ( expr_t )

extern

◆ fallthru_bb_of_jump()

basic_block fallthru_bb_of_jump ( const rtx_insn * )

extern

◆ find_in_history_vect()

int find_in_history_vect	(	vec< expr_history_def >	,
		rtx	,
		vinsn_t	,
		bool	)

extern

◆ flist_clear()

void flist_clear ( flist_t * )

extern

◆ flist_lookup()

fence_t flist_lookup	(	flist_t	,
		insn_t	)

extern

◆ flist_tail_init()

void flist_tail_init ( flist_tail_t )

extern

◆ free_bb_note_pool()

void free_bb_note_pool ( void )

extern

◆ free_data_for_scheduled_insn()

void free_data_for_scheduled_insn ( insn_t )

extern

◆ free_data_sets()

void free_data_sets ( basic_block )

extern

◆ free_lv_sets()

void free_lv_sets ( void )

extern

◆ free_nop_and_exit_insns()

void free_nop_and_exit_insns ( void )

extern

◆ free_nop_pool()

void free_nop_pool ( void )

extern

◆ free_nop_vinsn()

void free_nop_vinsn ( void )

extern

◆ free_regset_pool()

void free_regset_pool ( void )

extern

◆ free_sched_pools()

void free_sched_pools ( void )

extern

◆ free_succs_info()

void free_succs_info ( struct succs_info * )

extern

◆ get_all_loop_exits()

vec< edge > get_all_loop_exits ( basic_block bb )

inline

Collect all loop exits recursively, skipping empty BBs between them.
E.g. if BB is a loop header which has several loop exits,
traverse all of them and if any of them turns out to be another loop header
(after skipping empty BBs), add its loop exits to the resulting vector
as well.

References current_loop_nest, EDGE_COUNT, loop::exits, gcc_assert, get_all_loop_exits(), get_loop_exit_edges_unique_dests(), ggc_alloc(), i, in_current_region_p(), inner_loop_header_p(), loop_depth(), basic_block_def::loop_father, loop_outer(), NULL, sel_bb_empty_or_nop_p(), single_succ(), basic_block_def::succs, and vNULL.

Referenced by _succ_iter_cond(), and get_all_loop_exits().

◆ get_av_level()

int get_av_level ( insn_t )

extern

◆ get_av_set()

av_set_t get_av_set ( insn_t )

extern

◆ get_clear_regset_from_pool()

regset get_clear_regset_from_pool ( void )

extern

◆ get_dest_and_mode()

void get_dest_and_mode	(	rtx	,
		rtx *	,
		machine_mode *	)

extern

◆ get_loop_exit_edges_unique_dests()

vec< edge > get_loop_exit_edges_unique_dests ( const class loop * loop )

inline

Return exit edges of LOOP, filtering out edges with the same dest bb.

References cfun, current_loops, loop_exit::e, EXIT_BLOCK_PTR_FOR_FN, loop::exits, gcc_assert, ggc_alloc(), i, loop::latch, LOOPS_HAVE_RECORDED_EXITS, loop_exit::next, and vNULL.

Referenced by get_all_loop_exits().

◆ get_loop_nest_for_rgn()

loop_p get_loop_nest_for_rgn ( unsigned int )

extern

◆ get_nop_from_pool()

insn_t get_nop_from_pool ( insn_t )

extern

◆ get_regset_from_pool()

regset get_regset_from_pool ( void )

extern

Pool functions.

◆ get_seqno_by_preds()

int get_seqno_by_preds ( rtx_insn * )

extern

◆ has_dependence_p()

ds_t has_dependence_p	(	expr_t	,
		insn_t	,
		ds_t **	)

extern

◆ ilist_add()

void ilist_add	(	ilist_t *	lp,
		insn_t	insn )

inline

ilist_t functions.

References _list_add(), and ILIST_INSN.

◆ ilist_copy()

ilist_t ilist_copy ( ilist_t )

extern

Functions that are used in sel-sched.cc.

List functions.

◆ ilist_invert()

ilist_t ilist_invert ( ilist_t )

extern

◆ ilist_is_in_p()

bool ilist_is_in_p	(	ilist_t	l,
		insn_t	insn )

inline

References ILIST_INSN, and ILIST_NEXT.

◆ in_current_region_p()

bool in_current_region_p ( basic_block )

extern

Referenced by _eligible_successor_edge_p(), _succ_iter_cond(), and get_all_loop_exits().

◆ in_same_ebb_p()

bool in_same_ebb_p	(	insn_t	,
		insn_t	)

extern

◆ init_fences()

void init_fences ( insn_t )

extern

Fences functions.

◆ init_lv_sets()

void init_lv_sets ( void )

extern

Various initialization functions.

◆ inner_loop_header_p()

bool inner_loop_header_p ( basic_block bb )

inline

True when BB is a header of the inner loop.

References cfun, current_loop_nest, EXIT_BLOCK_PTR_FOR_FN, flow_bb_inside_loop_p(), gcc_assert, ggc_alloc(), loop_depth(), and basic_block_def::loop_father.

Referenced by get_all_loop_exits().

◆ insert_in_history_vect()

void insert_in_history_vect	(	vec< expr_history_def > *	,
		unsigned	,
		enum	local_trans_type,
		vinsn_t	,
		vinsn_t	,
		ds_t	)

extern

◆ insn_at_boundary_p()

bool insn_at_boundary_p ( insn_t )

extern

◆ insn_eligible_for_subst_p()

bool insn_eligible_for_subst_p ( insn_t )

extern

◆ insn_sid()

sel_insn_data_def insn_sid ( insn_t )

extern

◆ lhs_of_insn_equals_to_dest_p()

bool lhs_of_insn_equals_to_dest_p	(	insn_t	,
		rtx	)

extern

Functions to work with insns.

◆ make_region_from_loop_preheader()

void make_region_from_loop_preheader ( vec< basic_block > *& )

extern

◆ mark_unavailable_targets()

void mark_unavailable_targets	(	av_set_t	,
		av_set_t	,
		regset	)

extern

◆ merge_expr()

void merge_expr	(	expr_t	,
		expr_t	,
		insn_t	)

extern

◆ merge_expr_data()

void merge_expr_data	(	expr_t	,
		expr_t	,
		insn_t	)

extern

◆ merge_with_other_exprs()

expr_t merge_with_other_exprs	(	av_set_t *	,
		av_set_iterator *	,
		expr_t	)

extern

◆ move_fence_to_fences()

void move_fence_to_fences	(	flist_t	,
		flist_tail_t	)

extern

◆ purge_empty_blocks()

void purge_empty_blocks ( void )

extern

◆ recompute_vinsn_lhs_rhs()

void recompute_vinsn_lhs_rhs ( vinsn_t )

extern

◆ register_unavailable_p()

bool register_unavailable_p	(	regset	,
		rtx	)

extern

◆ reset_target_context()

void reset_target_context	(	tc_t	,
		bool	)

extern

◆ return_nop_to_pool()

void return_nop_to_pool	(	insn_t	,
		bool	)

extern

◆ return_regset_to_pool()

void return_regset_to_pool ( regset )

extern

◆ sel_add_loop_preheaders()

void sel_add_loop_preheaders ( bb_vec_t * )

extern

◆ sel_bb_empty_or_nop_p()

bool sel_bb_empty_or_nop_p ( basic_block bb )

inline

References cfun, EXIT_BLOCK_PTR_FOR_FN, INSN_NOP_P, last, NULL_RTX, sel_bb_end(), and sel_bb_head().

Referenced by _eligible_successor_edge_p(), and get_all_loop_exits().

◆ sel_bb_empty_p()

bool sel_bb_empty_p ( basic_block )

extern

Referenced by _eligible_successor_edge_p().

◆ sel_bb_end()

rtx_insn * sel_bb_end ( basic_block )

extern

Referenced by sel_bb_empty_or_nop_p().

◆ sel_bb_end_p()

bool sel_bb_end_p ( insn_t )

extern

◆ sel_bb_head()

rtx_insn * sel_bb_head ( basic_block )

extern

Basic block and CFG functions.

Referenced by _succ_iter_cond(), and sel_bb_empty_or_nop_p().

◆ sel_bb_head_p()

bool sel_bb_head_p ( insn_t )

extern

◆ sel_clear_has_dependence()

void sel_clear_has_dependence ( void )

extern

Dependence analysis functions.

◆ sel_create_recovery_block()

basic_block sel_create_recovery_block ( insn_t )

extern

◆ sel_extend_global_bb_info()

void sel_extend_global_bb_info ( void )

extern

◆ sel_finish_bbs()

void sel_finish_bbs ( void )

extern

◆ sel_finish_global_and_expr()

void sel_finish_global_and_expr ( void )

extern

◆ sel_finish_global_bb_info()

void sel_finish_global_bb_info ( void )

extern

◆ sel_finish_pipelining()

void sel_finish_pipelining ( void )

extern

◆ sel_gen_insn_from_expr_after()

insn_t sel_gen_insn_from_expr_after	(	expr_t	,
		vinsn_t	,
		int	,
		insn_t	)

extern

◆ sel_gen_insn_from_rtx_after()

insn_t sel_gen_insn_from_rtx_after	(	rtx	,
		expr_t	,
		int	,
		insn_t	)

extern

◆ sel_gen_recovery_insn_from_rtx_after()

insn_t sel_gen_recovery_insn_from_rtx_after	(	rtx	,
		expr_t	,
		int	,
		insn_t	)

extern

◆ sel_init_bbs()

void sel_init_bbs ( bb_vec_t )

extern

◆ sel_init_global_and_expr()

void sel_init_global_and_expr ( bb_vec_t )

extern

◆ sel_init_invalid_data_sets()

void sel_init_invalid_data_sets ( insn_t )

extern

◆ sel_init_pipelining()

void sel_init_pipelining ( void )

extern

◆ sel_insn_has_single_succ_p()

bool sel_insn_has_single_succ_p	(	insn_t	,
		int	)

extern

◆ sel_is_loop_preheader_p()

bool sel_is_loop_preheader_p ( basic_block )

extern

◆ sel_move_insn()

insn_t sel_move_insn	(	expr_t	,
		int	,
		insn_t	)

extern

◆ sel_num_cfg_preds_gt_1()

bool sel_num_cfg_preds_gt_1 ( insn_t )

extern

◆ sel_redirect_edge_and_branch()

bool sel_redirect_edge_and_branch	(	edge	,
		basic_block	)

extern

◆ sel_redirect_edge_and_branch_force()

void sel_redirect_edge_and_branch_force	(	edge	,
		basic_block	)

extern

◆ sel_register_cfg_hooks()

void sel_register_cfg_hooks ( void )

extern

◆ sel_remove_insn()

bool sel_remove_insn	(	insn_t	,
		bool	,
		bool	)

extern

◆ sel_save_haifa_priorities()

void sel_save_haifa_priorities ( void )

extern

◆ sel_sched_region()

void sel_sched_region ( int )

extern

◆ sel_set_sched_flags()

void sel_set_sched_flags ( void )

extern

◆ sel_setup_sched_infos()

void sel_setup_sched_infos ( void )

extern

◆ sel_split_edge()

basic_block sel_split_edge ( edge )

extern

◆ sel_unregister_cfg_hooks()

void sel_unregister_cfg_hooks ( void )

extern

◆ sel_vinsn_cost()

int sel_vinsn_cost ( vinsn_t )

extern

◆ set_target_context()

void set_target_context ( tc_t )

extern

◆ setup_nop_and_exit_insns()

void setup_nop_and_exit_insns ( void )

extern

◆ setup_nop_vinsn()

void setup_nop_vinsn ( void )

extern

◆ speculate_expr()

int speculate_expr	(	expr_t	,
		ds_t	)

extern

◆ tick_check_p()

int tick_check_p	(	expr_t	,
		deps_t	,
		fence_t	)

extern

◆ tidy_control_flow()

bool tidy_control_flow	(	basic_block	,
		bool	)

extern

◆ vinsn_attach()

void vinsn_attach ( vinsn_t )

extern

◆ vinsn_cond_branch_p()

bool vinsn_cond_branch_p ( vinsn_t )

extern

◆ vinsn_copy()

vinsn_t vinsn_copy	(	vinsn_t	,
		bool	)

extern

◆ vinsn_detach()

void vinsn_detach ( vinsn_t )

extern

◆ vinsn_equal_p()

bool vinsn_equal_p	(	vinsn_t	,
		vinsn_t	)

extern

◆ vinsn_separable_p()

bool vinsn_separable_p ( vinsn_t )

extern

Vinsns functions.

Variable Documentation

◆ after_recovery

basic_block after_recovery

extern

Some needed definitions.

Referenced by _succ_iter_cond().

◆ bbs_pipelined

sbitmap bbs_pipelined

extern

Saves pipelined blocks.  Bitmap is indexed by bb->index.

◆ blocks_to_reschedule

bitmap blocks_to_reschedule

extern

◆ bookkeeping_p

bool bookkeeping_p

extern

◆ current_loop_nest

class loop* current_loop_nest

extern

The loop nest being pipelined.

Referenced by get_all_loop_exits(), and inner_loop_header_p().

◆ enable_moveup_set_path_p

bool enable_moveup_set_path_p

extern

Various flags.

◆ exit_insn

rtx_insn* exit_insn

extern

An insn that 'contained' in EXIT block.

Referenced by _succ_iter_cond().

◆ fences

flist_t fences

extern

A list of fences currently in the works.

◆ forced_ebb_heads

bitmap_head* forced_ebb_heads

extern

Used in bb_in_ebb_p.

◆ global_level

int global_level

extern

A global level shows whether an insn is valid or not.

◆ max_insns_to_rename

int max_insns_to_rename

extern

◆ nop_pattern

rtx nop_pattern

extern

A NOP pattern used as a placeholder for real insns.

◆ pipelining_p

bool pipelining_p

extern

Referenced by _eligible_successor_edge_p().

◆ preheader_removed

bool preheader_removed

extern

◆ s_i_d

vec<sel_insn_data_def> s_i_d

extern

◆ sched_lists_pool

object_allocator<_list_node> sched_lists_pool

extern

_list_t functions.
All of _*list_* functions are used through accessor macros, thus
we can't move them in sel-sched-ir.cc.

Referenced by _list_alloc(), and _list_remove().

◆ sel_all_regs

regset sel_all_regs

extern

◆ sel_global_bb_info

vec<sel_global_bb_info_def> sel_global_bb_info

extern

Per basic block data.  This array is indexed by basic block index.

◆ sel_region_bb_info

vec<sel_region_bb_info_def> sel_region_bb_info

extern

Per basic block data.  This array is indexed by basic block index.

Variables
object_allocator< _list_node >	sched_lists_pool

vec< sel_insn_data_def >	s_i_d

int	global_level

flist_t	fences

rtx	nop_pattern

rtx_insn *	exit_insn

bitmap	blocks_to_reschedule

vec< sel_global_bb_info_def >	sel_global_bb_info

vec< sel_region_bb_info_def >	sel_region_bb_info

bitmap_head *	forced_ebb_heads

class loop *	current_loop_nest

sbitmap	bbs_pipelined

bool	enable_moveup_set_path_p

bool	pipelining_p

bool	bookkeeping_p

int	max_insns_to_rename

bool	preheader_removed

regset	sel_all_regs

basic_block	after_recovery

Data Structures

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ _AV_SET_EXPR

◆ _AV_SET_NEXT

◆ _FOR_EACH

◆ _FOR_EACH_1

◆ _FOR_EACH_X

◆ _FOR_EACH_X_1

◆ _LIST_NEXT

◆ _xlist_clear

◆ _xlist_iter_remove

◆ _XLIST_NEXT

◆ _xlist_remove

◆ _XLIST_X

◆ AV_LEVEL

◆ AV_SET

◆ AV_SET_VALID_P

◆ BB_AV_LEVEL

◆ BB_AV_SET

◆ BB_AV_SET_VALID_P

◆ BB_LV_SET

◆ BB_LV_SET_VALID_P

◆ BB_NOTE_LIST

◆ BLIST_BND

◆ BLIST_NEXT

◆ BND_AV

◆ BND_AV1

◆ BND_DC

◆ BND_PTR

◆ BND_TO

◆ DEF_LIST_DEF

◆ DEF_LIST_NEXT

◆ EXPR_CANT_MOVE

◆ EXPR_HISTORY_OF_CHANGES

◆ EXPR_INSN_RTX

◆ EXPR_LHS

◆ EXPR_NEEDS_SPEC_CHECK_P

◆ EXPR_ORIG_BB_INDEX

◆ EXPR_ORIG_SCHED_CYCLE

◆ EXPR_PATTERN

◆ EXPR_PRIORITY

◆ EXPR_PRIORITY_ADJ

◆ EXPR_RHS

◆ EXPR_SCHED_TIMES

◆ EXPR_SEPARABLE_P

◆ EXPR_SPEC

◆ EXPR_SPEC_DONE_DS

◆ EXPR_SPEC_TO_CHECK_DS

◆ EXPR_TARGET_AVAILABLE

◆ EXPR_TYPE

◆ EXPR_USEFULNESS

◆ EXPR_VINSN

◆ EXPR_WAS_RENAMED

◆ EXPR_WAS_SUBSTITUTED

◆ FENCE_AFTER_STALL_P

◆ FENCE_BNDS

◆ FENCE_CYCLE

◆ FENCE_DC

◆ FENCE_EXECUTING_INSNS

◆ FENCE_INSN

◆ FENCE_ISSUE_MORE

◆ FENCE_ISSUED_INSNS

◆ FENCE_LAST_SCHEDULED_INSN

◆ FENCE_PROCESSED_P

◆ FENCE_READY_TICKS

◆ FENCE_READY_TICKS_SIZE

◆ FENCE_SCHED_NEXT

◆ FENCE_SCHEDULED_P

◆ FENCE_STARTS_CYCLE_P

◆ FENCE_STATE

◆ FENCE_TC

◆ FLIST_FENCE

◆ FLIST_NEXT

◆ FLIST_TAIL_HEAD

◆ FLIST_TAIL_TAILP