GCC Middle and Back End API Reference
insn_info Struct Reference
Collaboration diagram for insn_info:

Data Fields

bool cannot_delete
bool wild_read
bool non_frame_wild_read
bool frame_read
bool stack_pointer_based
bool contains_cselib_groups
rtx insn
store_info_t store_rec
read_info_t read_rec
regset fixed_regs_live
struct insn_infoprev_insn
struct insn_infonext_local_store

Detailed Description

   One of these records is created for each insn.  

Field Documentation

bool insn_info::cannot_delete
     Set true if the insn contains a store but the insn itself cannot
     be deleted.  This is set if the insn is a parallel and there is
     more than one non dead output or if the insn is in some way

Referenced by dse_step3(), replace_read(), set_all_positions_unneeded(), and set_position_unneeded().

bool insn_info::contains_cselib_groups
     This is true if any of the sets within the store contains a
     cselib base.  Such stores can only be deleted by the local

Referenced by record_store().

regset insn_info::fixed_regs_live
     The live fixed registers.  We assume only fixed registers can
     cause trouble by being clobbered from an expanded pattern;
     storing only the live fixed registers (rather than all registers)
     means less memory needs to be allocated / copied for the individual
bool insn_info::frame_read
     This field is only used for the processing of const functions.
     These functions cannot read memory, but they can read the stack
     because that is where they may get their parms.  We need to be
     this conservative because, like the store motion pass, we don't
     consider CALL_INSN_FUNCTION_USAGE when processing call insns.
     Moreover, we need to distinguish two cases:
     1. Before reload (register elimination), the stores related to
        outgoing arguments are stack pointer based and thus deemed
        of non-constant base in this pass.  This requires special
        handling but also means that the frame pointer based stores
        need not be killed upon encountering a const function call.
     2. After reload, the stores related to outgoing arguments can be
        either stack pointer or hard frame pointer based.  This means
        that we have no other choice than also killing all the frame
        pointer based stores upon encountering a const function call.
     This field is set after reload for const function calls.  Having
     this set is less severe than a wild read, it just means that all
     the frame related stores are killed rather than all the stores.  
rtx insn_info::insn
struct insn_info* insn_info::next_local_store
     The linked list of insns that are in consideration for removal in
     the forwards pass through the basic block.  This pointer may be
     trash as it is not cleared when a wild read occurs.  The only
     time it is guaranteed to be correct is when the traversal starts
     at active_local_stores.  
bool insn_info::non_frame_wild_read
     This is true only for CALL instructions which could potentially read
     any non-frame memory location. This field is used by the global
struct insn_info* insn_info::prev_insn
     The prev insn in the basic block.  

Referenced by get_bitmap_index(), and scan_stores_spill().

read_info_t insn_info::read_rec
     The linked list of mem uses in this insn.  Only the reads from
     rtx bases are listed here.  The reads to cselib bases are
     completely processed during the first scan and so are never

Referenced by scan_stores_spill().

bool insn_info::stack_pointer_based
     This field is only used for the processing of const functions.
     It is set if the insn may contain a stack pointer based store.  

Referenced by record_store().

store_info_t insn_info::store_rec
     The list of mem sets or mem clobbers that are contained in this
     insn.  If the insn is deletable, it contains only one mem set.
     But it could also contain clobbers.  Insns that contain more than
     one mem set are not deletable, but each of those mems are here in
     order to provide info to delete other insns.  

Referenced by check_mem_read_use(), dse_step3(), and scan_stores_spill().

bool insn_info::wild_read
     This field is only used by the global algorithm.  It is set true
     if the insn contains any read of mem except for a (1).  This is
     also set if the insn is a call or has a clobber mem.  If the insn
     contains a wild read, the use_rec will be null.  

Referenced by can_escape(), and get_bitmap_index().

The documentation for this struct was generated from the following file: