Data Structures
struct	resources

Enumerations
enum	mark_resource_type { MARK_SRC_DEST = 0, MARK_SRC_DEST_CALL = 1 }

Functions
void	mark_target_live_regs (rtx, rtx, struct resources *)
void	mark_set_resources (rtx, struct resources *, int, enum mark_resource_type)
void	mark_referenced_resources (rtx, struct resources *, bool)
void	clear_hashed_info_for_insn (rtx)
void	incr_ticks_for_insn (rtx)
void	mark_end_of_function_resources (rtx, bool)
void	init_resource_info (rtx)
void	free_resource_info (void)

Enumeration Type Documentation

enum mark_resource_type

   The kinds of rtl mark_*_resources will consider

Enumerator:

MARK_SRC_DEST
MARK_SRC_DEST_CALL

Function Documentation

void clear_hashed_info_for_insn ( rtx )

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

void incr_ticks_for_insn ( rtx )

void init_resource_info ( rtx )

void mark_end_of_function_resources	(	rtx	,
		bool
	)

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.

     Handle leaf items for which we set resource flags.  Also, special-case
     CALL, SET and CLOBBER operators.

         If this memory shouldn't change, it really isn't referencing
         memory.

         Mark registers used to access memory.

         Traditional asm's are always volatile.

         For all ASM_OPERANDS, we must traverse the vector of input operands.
         We can not just fall through here since then we would be confused
         by the ASM_INPUT rtx inside ASM_OPERANDS, which do not indicate
         traditional asms unlike their normal usage.

         The first operand will be a (MEM (xxx)) but doesn't really reference
         memory.  The second operand may be referenced, though.

         Usually, the first operand of SET is set, not referenced.  But
         registers used to access memory are referenced.  SET_DEST is
         also referenced if it is a ZERO_EXTRACT.

             A CALL references memory, the frame pointer if it exists, the
             stack pointer, any global registers and any registers given in
             USE insns immediately in front of the CALL.

             However, we may have moved some of the parameter loading insns
             into the delay slot of this CALL.  If so, the USE's for them
             don't count and should be skipped.

             If we are part of a delay slot sequence, point at the SEQUENCE.

             Check for a REG_SETJMP.  If it exists, then we must
             assume that this call can need any register.

             This is done to be more conservative about how we handle setjmp.
             We assume that they both use and set all registers.  Using all
             registers ensures that a register will not be considered dead
             just because it crosses a setjmp call.  A register should be
             considered dead only if the setjmp call returns nonzero.

         ... fall through to other INSN processing ...

         In addition to the usual references, also consider all outputs
         as referenced, to compensate for mark_set_resources treating
         them as killed.  This is similar to ZERO_EXTRACT / STRICT_LOW_PART
         handling, execpt that we got a partial incidence instead of a partial
         width.

         No special processing, just speed up.

     Process each sub-expression and flag what it needs.

Referenced by resource_conflicts_p(), return_insn_p(), 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.

         These don't set any resources.

         Called routine modifies the condition code, memory, any registers
         that aren't saved across calls, global registers and anything
         explicitly CLOBBERed immediately after the CALL_INSN.

             Check for a REG_SETJMP.  If it exists, then we must
             assume that this call can clobber any register.

         ... and also what its RTL says it modifies, if anything.

           An insn consisting of just a CLOBBER (or USE) is just for flow
           and doesn't actually do anything, so we ignore it.

         If the source of a SET is a CALL, this is actually done by
         the called routine.  So only include it if we are to include the
         effects of the calling routine.

         Traditional asm's are always volatile.

         For all ASM_OPERANDS, we must traverse the vector of input operands.
         We can not just fall through here since then we would be confused
         by the ASM_INPUT rtx inside ASM_OPERANDS, which do not indicate
         traditional asms unlike their normal usage.

     Process each sub-expression and flag what it needs.

Referenced by check_annul_list_true_false(), find_dead_or_set_registers(), insn_references_resource_p(), and try_merge_delay_insns().

void mark_target_live_regs	(	rtx	,
		rtx	,
		struct resources *
	)

Data Structures

Enumerations

Functions

Enumeration Type Documentation

Function Documentation