Struct ConstraintGraph

pub struct ConstraintGraph<'tcx, T: IntervalArithmetic + Debug> {

    pub vars: VarNodes<'tcx, T>,
    pub oprs: GenOprs<'tcx, T>,
    pub defmap: DefMap<'tcx>,
    pub usemap: UseMap<'tcx>,
    pub symbmap: SymbMap<'tcx>,
    pub values_branchmap: ValuesBranchMap<'tcx, T>,
    constant_vector: Vec<T>,
    pub inst_rand_place_set: Vec<Place<'tcx>>,
    pub essa: DefId,
    pub ssa: DefId,
    pub index: i32,
    pub dfs: HashMap<&'tcx Place<'tcx>, i32>,
    pub root: HashMap<&'tcx Place<'tcx>, &'tcx Place<'tcx>>,
    pub in_component: HashSet<&'tcx Place<'tcx>>,
    pub components: HashMap<&'tcx Place<'tcx>, HashSet<&'tcx Place<'tcx>>>,
    pub worklist: VecDeque<&'tcx Place<'tcx>>,
    pub numAloneSCCs: usize,
    pub numSCCs: usize,
    pub final_vars: VarNodes<'tcx, T>,
}

Fields

vars: VarNodes<'tcx, T>

oprs: GenOprs<'tcx, T>

defmap: DefMap<'tcx>

usemap: UseMap<'tcx>

symbmap: SymbMap<'tcx>

values_branchmap: ValuesBranchMap<'tcx, T>

constant_vector: Vec<T>

inst_rand_place_set: Vec<Place<'tcx>>

essa: DefId

ssa: DefId

index: i32

dfs: HashMap<&'tcx Place<'tcx>, i32>

root: HashMap<&'tcx Place<'tcx>, &'tcx Place<'tcx>>

in_component: HashSet<&'tcx Place<'tcx>>

components: HashMap<&'tcx Place<'tcx>, HashSet<&'tcx Place<'tcx>>>

worklist: VecDeque<&'tcx Place<'tcx>>

numAloneSCCs: usize

numSCCs: usize

final_vars: VarNodes<'tcx, T>

Implementations

impl<'tcx, T> ConstraintGraph<'tcx, T>

where T: IntervalArithmetic + ConstConvert + Debug,

pub fn convert_const(c: &Const<'_>) -> Option<T>

pub fn new(essa: DefId, ssa: DefId) -> Self

pub fn build_final_vars( &mut self, locals_map: &HashMap<Local, HashSet<Local>>, ) -> (VarNodes<'tcx, T>, Vec<Local>)

pub fn rap_print_final_vars(&self)

pub fn rap_print_vars(&self)

pub fn print_vars(&self)

pub fn print_conponent_vars(&self)

fn print_values_branchmap(&self)

fn print_symbmap(&self)

fn print_defmap(&self)

fn print_compusemap( &self, component: &HashSet<&'tcx Place<'tcx>>, comp_use_map: &HashMap<&'tcx Place<'tcx>, HashSet<usize>>, )

fn print_usemap(&self)

pub fn add_varnode(&mut self, v: &'tcx Place<'tcx>) -> &mut VarNode<'tcx, T>

pub fn build_graph(&mut self, body: &'tcx Body<'tcx>)

pub fn build_value_maps(&mut self, body: &'tcx Body<'tcx>)

pub fn build_value_branch_map( &mut self, body: &Body<'tcx>, discr: &'tcx Operand<'tcx>, targets: &'tcx SwitchTargets, block: &'tcx BasicBlockData<'tcx>, )

pub fn flipped_binop(op: BinOp) -> Option<BinOp>

fn extract_condition( &mut self, place: &'tcx Place<'tcx>, switch_block: &'tcx BasicBlockData<'tcx>, ) -> Option<(&'tcx Operand<'tcx>, &'tcx Operand<'tcx>, BinOp)>

fn apply_comparison<U: IntervalArithmetic>( &self, constant: U, cmp_op: BinOp, is_true_branch: bool, const_in_left: bool, ) -> Range<U>

fn build_value_goto_map(&self, block_index: BasicBlock, target: BasicBlock)

pub fn build_varnodes(&mut self)

pub fn build_symbolic_intersect_map(&mut self)

pub fn build_use_map( &mut self, component: &HashSet<&'tcx Place<'tcx>>, ) -> HashMap<&'tcx Place<'tcx>, HashSet<usize>>

pub fn build_operations( &mut self, inst: &'tcx Statement<'tcx>, block: BasicBlock, )

fn add_ssa_op( &mut self, sink: &'tcx Place<'tcx>, inst: &'tcx Statement<'tcx>, operands: &'tcx IndexVec<FieldIdx, Operand<'tcx>>, )

fn add_use_op( &mut self, sink: &'tcx Place<'tcx>, inst: &'tcx Statement<'tcx>, op: &'tcx Operand<'tcx>, )

fn add_essa_op( &mut self, sink: &'tcx Place<'tcx>, inst: &'tcx Statement<'tcx>, operands: &'tcx IndexVec<FieldIdx, Operand<'tcx>>, block: BasicBlock, )

fn add_unary_op( &mut self, sink: &'tcx Place<'tcx>, inst: &'tcx Statement<'tcx>, op: &'tcx Operand<'tcx>, )

fn add_binary_op( &mut self, sink: &'tcx Place<'tcx>, inst: &'tcx Statement<'tcx>, op1: &'tcx Operand<'tcx>, op2: &'tcx Operand<'tcx>, )

fn fix_intersects(&mut self, component: &HashSet<&'tcx Place<'tcx>>)

pub fn widen(&mut self, op: usize) -> bool

pub fn narrow(&mut self, op: usize) -> bool

fn pre_update( &mut self, comp_use_map: &HashMap<&'tcx Place<'tcx>, HashSet<usize>>, entry_points: &HashSet<&'tcx Place<'tcx>>, )

fn pos_update( &mut self, comp_use_map: &HashMap<&'tcx Place<'tcx>, HashSet<usize>>, entry_points: &HashSet<&'tcx Place<'tcx>>, )

fn generate_active_vars( &mut self, component: &HashSet<&'tcx Place<'tcx>>, active_vars: &mut HashSet<&'tcx Place<'tcx>>, )

fn generate_entry_points( &mut self, component: &HashSet<&'tcx Place<'tcx>>, entry_points: &mut HashSet<&'tcx Place<'tcx>>, )

fn propagate_to_next_scc(&mut self, component: &HashSet<&'tcx Place<'tcx>>)

pub fn find_intervals(&mut self)

pub fn add_control_dependence_edges(&mut self)

pub fn del_control_dependence_edges(&mut self)

pub fn build_nuutila(&mut self, single: bool)

pub fn visit( &mut self, place: &'tcx Place<'tcx>, stack: &mut Vec<&'tcx Place<'tcx>>, )