Data Structures
struct	target_info

Functions
static void	update_live_status (rtx, const_rtx, void *)
static int	find_basic_block (rtx, int)
static rtx	next_insn_no_annul (rtx)
static rtx	find_dead_or_set_registers (rtx, struct resources , rtx , int, struct resources, struct resources)
static void	update_live_status ()
static int	find_basic_block ()
static rtx	next_insn_no_annul ()
void	mark_referenced_resources (rtx x, struct resources *res, bool include_delayed_effects)
void	mark_set_resources (rtx x, struct resources *res, int in_dest, enum mark_resource_type mark_type)
static bool	return_insn_p ()
void	mark_target_live_regs ()
void	init_resource_info ()
void	free_resource_info ()
void	clear_hashed_info_for_insn ()
void	incr_ticks_for_insn ()
void	mark_end_of_function_resources ()

Variables
static struct resources	start_of_epilogue_needs
static struct resources	end_of_function_needs
static struct target_info **	target_hash_table = NULL
static int *	bb_ticks
static HARD_REG_SET	current_live_regs
static HARD_REG_SET	pending_dead_regs

Function Documentation

void clear_hashed_info_for_insn ( )

Clear any hashed information that we have stored for INSN.

References target_info::block, target_info::next, and target_info::uid.

Referenced by add_to_delay_list().

static int find_basic_block	(	rtx	,
		int
	)

static

Referenced by incr_ticks_for_insn(), and mark_target_live_regs().

static int find_basic_block ( )

static

Find the number of the basic block with correct live register
   information that starts closest to INSN.  Return -1 if we couldn't
   find such a basic block or the beginning is more than
   SEARCH_LIMIT instructions before INSN.  Use SEARCH_LIMIT = -1 for
   an unlimited search.

   The delay slot filling code destroys the control-flow graph so,
   instead of finding the basic block containing INSN, we search
   backwards toward a BARRIER where the live register information is
   correct.

References next_nonnote_insn(), and prev_nonnote_insn().

static rtx find_dead_or_set_registers	(	rtx	target,
		struct resources *	res,
		rtx *	jump_target,
		int	jump_count,
		struct resources	set,
		struct resources	needed
	)

static

A subroutine of mark_target_live_regs.  Search forward from TARGET
   looking for registers that are set before they are used.  These are dead.
   Stop after passing a few conditional jumps, and/or a small
   number of unconditional branches.

References any_condjump_p(), any_uncondjump_p(), can_throw_internal(), mark_referenced_resources(), mark_set_resources(), MARK_SRC_DEST_CALL, target_info::next, pending_dead_regs, resources::regs, and scratch.

Referenced by mark_target_live_regs().

void free_resource_info ( void )

Free up the resources allocated to mark_target_live_regs ().  This
   should be invoked after the last call to mark_target_live_regs ().

References bb_ticks, free(), and target_info::next.

Referenced by dbr_schedule().

void incr_ticks_for_insn ( )

Increment the tick count for the basic block that contains INSN.

References bb_ticks, and find_basic_block().

Referenced by reorg_redirect_jump(), and update_block().

void init_resource_info ( )

Initialize the resources required by mark_target_live_regs ().
   This should be invoked before the first call to mark_target_live_regs.

References bb_ticks, resources::cc, end_of_function_needs, EPILOGUE_USES, global_regs, mark_referenced_resources(), mark_set_resources(), MARK_SRC_DEST_CALL, resources::memory, next_nonnote_insn(), resources::regs, return_insn_p(), and start_of_epilogue_needs.

Referenced by dbr_schedule().

void mark_end_of_function_resources ( )

Add TRIAL to the set of resources used at the end of the current
   function.

References end_of_function_needs, and mark_referenced_resources().

void mark_referenced_resources	(	rtx	x,
		struct resources *	res,
		bool	include_delayed_effects
	)

Given X, some rtl, and RES, a pointer to a `struct resource', mark
   which resources are referenced by the insn.  If INCLUDE_DELAYED_EFFECTS
   is TRUE, resources used by the called routine will be included for
   CALL_INSNs.

References add_to_hard_reg_set(), resources::cc, find_reg_note(), global_regs, mark_referenced_resources(), resources::memory, resources::regs, rtx_equal_p(), SET, subreg_nregs(), subreg_regno(), and resources::volatil.

Referenced by fill_simple_delay_slots(), fill_slots_from_thread(), find_dead_or_set_registers(), init_resource_info(), insn_references_resource_p(), mark_end_of_function_resources(), mark_referenced_resources(), mark_target_live_regs(), redundant_insn(), and try_merge_delay_insns().

void mark_set_resources	(	rtx	x,
		struct resources *	res,
		int	in_dest,
		enum mark_resource_type	mark_type
	)

Given X, a part of an insn, and a pointer to a `struct resource',
   RES, indicate which resources are modified by the insn. If
   MARK_TYPE is MARK_SRC_DEST_CALL, also mark resources potentially
   set by the called routine.

   If IN_DEST is nonzero, it means we are inside a SET.  Otherwise,
   objects are being referenced instead of set.

   We never mark the insn as modifying the condition code unless it explicitly
   SETs CC0 even though this is not totally correct.  The reason for this is
   that we require a SET of CC0 to immediately precede the reference to CC0.
   So if some other insn sets CC0 as a side-effect, we know it cannot affect
   our computation and thus may be placed in a delay slot.

References add_to_hard_reg_set(), resources::cc, find_reg_note(), mark_set_resources(), MARK_SRC_DEST, MARK_SRC_DEST_CALL, resources::memory, resources::regs, SET, subreg_nregs(), subreg_regno(), and resources::volatil.

Referenced by fill_simple_delay_slots(), fill_slots_from_thread(), find_dead_or_set_registers(), init_resource_info(), insn_sets_resource_p(), mark_set_resources(), mark_target_live_regs(), redundant_insn(), steal_delay_list_from_target(), and try_merge_delay_insns().

void mark_target_live_regs ( )

Set the resources that are live at TARGET.

   If TARGET is zero, we refer to the end of the current function and can
   return our precomputed value.

   Otherwise, we try to find out what is live by consulting the basic block
   information.  This is tricky, because we must consider the actions of
   reload and jump optimization, which occur after the basic block information
   has been computed.

   Accordingly, we proceed as follows::

   We find the previous BARRIER and look at all immediately following labels
   (with no intervening active insns) to see if any of them start a basic
   block.  If we hit the start of the function first, we use block 0.

   Once we have found a basic block and a corresponding first insn, we can
   accurately compute the live status (by starting at a label following a
   BARRIER, we are immune to actions taken by reload and jump.)  Then we
   scan all insns between that point and our target.  For each CLOBBER (or
   for call-clobbered regs when we pass a CALL_INSN), mark the appropriate
   registers are dead.  For a SET, mark them as live.

   We have to be careful when using REG_DEAD notes because they are not
   updated by such things as find_equiv_reg.  So keep track of registers
   marked as dead that haven't been assigned to, and mark them dead at the
   next CODE_LABEL since reload and jump won't propagate values across labels.

   If we cannot find the start of a basic block (should be a very rare
   case, if it can happen at all), mark everything as potentially live.

   Next, scan forward from TARGET looking for things set or clobbered
   before they are used.  These are not live.

   Because we can be called many times on the same target, save our results
   in a hash table indexed by INSN_UID.  This is only done if the function
   init_resource_info () was invoked before we are called.

References add_to_hard_reg_set(), target_info::bb_tick, bb_ticks, target_info::block, resources::cc, current_live_regs, end_of_function_needs, find_basic_block(), find_dead_or_set_registers(), global_regs, target_info::live_regs, mark_referenced_resources(), mark_set_resources(), MARK_SRC_DEST_CALL, resources::memory, target_info::next, next_active_insn(), next_insn(), next_insn_no_annul(), note_stores(), pending_dead_regs, resources::regs, remove_from_hard_reg_set(), return_insn_p(), scratch, start_of_epilogue_needs, target_info::uid, update_live_status(), and resources::volatil.

Referenced by fill_slots_from_thread().

static rtx next_insn_no_annul ( rtx )

static

Referenced by mark_target_live_regs().

static rtx next_insn_no_annul ( )

static

Similar to next_insn, but ignores insns in the delay slots of
   an annulled branch.

References target_info::next.

static bool return_insn_p ( )

static

Return TRUE if INSN is a return, possibly with a filled delay slot.

Referenced by init_resource_info(), and mark_target_live_regs().

static void update_live_status	(	rtx	,
		const_rtx	,
		void *
	)

static

Referenced by mark_target_live_regs().

static void update_live_status ( )

static

Utility function called from mark_target_live_regs via note_stores.
   It deadens any CLOBBERed registers and livens any SET registers.

References current_live_regs, pending_dead_regs, subreg_nregs(), and subreg_regno().

Variable Documentation

int* bb_ticks

static

For each basic block, we maintain a generation number of its basic
   block info, which is updated each time we move an insn from the
   target of a jump.  This is the generation number indexed by block
   number.

Referenced by free_resource_info(), incr_ticks_for_insn(), init_resource_info(), and mark_target_live_regs().

HARD_REG_SET current_live_regs

static

Marks registers possibly live at the current place being scanned by
   mark_target_live_regs.  Also used by update_live_status.

Referenced by mark_target_live_regs(), and update_live_status().

struct resources end_of_function_needs

static

Indicates what resources are required at function end.

Referenced by init_resource_info(), mark_end_of_function_resources(), and mark_target_live_regs().

HARD_REG_SET pending_dead_regs

static

Marks registers for which we have seen a REG_DEAD note but no assignment.
   Also only used by the next two functions.

Referenced by find_dead_or_set_registers(), mark_target_live_regs(), and update_live_status().

struct resources start_of_epilogue_needs

static

Indicates what resources are required at the beginning of the epilogue.

Referenced by init_resource_info(), and mark_target_live_regs().

struct target_info** target_hash_table = NULL

static

Define the hash table itself.

Data Structures

Functions

Variables

Function Documentation

Variable Documentation