GCC Middle and Back End API Reference
haifa_sched_info Struct Reference

#include <sched-int.h>

Collaboration diagram for haifa_sched_info:

Data Fields

void(* init_ready_list )(void)
int(* can_schedule_ready_p )(rtx)
int(* schedule_more_p )(void)
ds_t(* new_ready )(rtx, ds_t)
int(* rank )(rtx, rtx)
const char *(* print_insn )(const_rtx, int)
int(* contributes_to_priority )(rtx, rtx)
bool(* insn_finishes_block_p )(rtx)
rtx prev_head
rtx next_tail
rtx head
rtx tail
unsigned int queue_must_finish_empty:1
int sched_max_insns_priority
void(* add_remove_insn )(rtx, int)
void(* begin_schedule_ready )(rtx insn)
void(* begin_move_insn )(rtx insn, rtx last)
basic_block(* advance_target_bb )(basic_block, rtx)
void *(* save_state )(void)
void(* restore_state )(void *)
unsigned int flags

Detailed Description

   This structure holds some state of the current scheduling pass, and
   contains some function pointers that abstract out some of the non-generic
   functionality from functions such as schedule_block or schedule_insn.
   There is one global variable, current_sched_info, which points to the
   sched_info structure currently in use.  

Field Documentation

void(* haifa_sched_info::add_remove_insn)(rtx, int)
     Hooks to support speculative scheduling.  
     Called to notify frontend that instruction is being added (second
     parameter == 0) or removed (second parameter == 1).  
basic_block(* haifa_sched_info::advance_target_bb)(basic_block, rtx)
     If the second parameter is not NULL, return nonnull value, if the
     basic block should be advanced.
     If the second parameter is NULL, return the next basic block in EBB.
     The first parameter is the current basic block in EBB.  
void(* haifa_sched_info::begin_move_insn)(rtx insn, rtx last)
     Called to notify the frontend that an instruction INSN is about to be
     moved to its correct place in the final schedule.  This is done for all
     insns in order of the schedule.  LAST indicates the last scheduled
void(* haifa_sched_info::begin_schedule_ready)(rtx insn)
     Called to notify the frontend that instruction INSN is being

Referenced by prune_ready_list().

int(* haifa_sched_info::can_schedule_ready_p)(rtx)
     Called after taking an insn from the ready list.  Returns nonzero if
     this insn can be scheduled, nonzero if we should silently discard it.  
int(* haifa_sched_info::contributes_to_priority)(rtx, rtx)
     Return nonzero if an insn should be included in priority

Referenced by dep_cost_1().

unsigned int haifa_sched_info::flags
     ??? FIXME: should use straight bitfields inside sched_info instead of
     this flag field.  

Referenced by sched_free_deps(), sched_init_bbs(), sd_add_dep(), and sd_copy_back_deps().

rtx haifa_sched_info::head
     Filled in after the schedule is finished; the first and last scheduled
void(* haifa_sched_info::init_ready_list)(void)
     Add all insns that are initially ready to the ready list.  Called once
     before scheduling a set of insns.  
bool(* haifa_sched_info::insn_finishes_block_p)(rtx)
     Return true if scheduling insn (passed as the parameter) will trigger
     finish of scheduling current block.  
ds_t(* haifa_sched_info::new_ready)(rtx, ds_t)
     Called after an insn has all its hard dependencies resolved.
     Adjusts status of instruction (which is passed through second parameter)
     to indicate if instruction should be moved to the ready list or the
     queue, or if it should silently discard it (until next resolved
rtx haifa_sched_info::next_tail
rtx haifa_sched_info::prev_head
     The boundaries of the set of insns to be scheduled.  

Referenced by debug_ebb_dependencies(), and sched_setup_bb_reg_pressure_info().

const char*(* haifa_sched_info::print_insn)(const_rtx, int)
     Return a string that contains the insn uid and optionally anything else
     necessary to identify this insn in an output.  It's valid to use a
     static buffer for this.  The ALIGNED parameter should cause the string
     to be formatted so that multiple output lines will line up nicely.  

Referenced by get_ebb_head_tail(), and model_promote_predecessors().

unsigned int haifa_sched_info::queue_must_finish_empty
     If nonzero, enables an additional sanity check in schedule_block.  
int(* haifa_sched_info::rank)(rtx, rtx)
     Compare priority of two insns.  Return a positive number if the second
     insn is to be preferred for scheduling, and a negative one if the first
     is to be preferred.  Zero if they are equally good.  
void(* haifa_sched_info::restore_state)(void *)
     Restore frontend scheduler state from the argument, and free the
void*(* haifa_sched_info::save_state)(void)
     Allocate memory, store the frontend scheduler state in it, and
     return it.  
int haifa_sched_info::sched_max_insns_priority
     Maximum priority that has been assigned to an insn.  

Referenced by new_ready().

int(* haifa_sched_info::schedule_more_p)(void)
     Return nonzero if there are more insns that should be scheduled.  
rtx haifa_sched_info::tail

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