Struct rustc_mir::dataflow::Engine

pub struct Engine<'a, 'tcx, A> where
    A: Analysis<'tcx>,  {
    bits_per_block: usize,
    tcx: TyCtxt<'tcx>,
    body: &'a Body<'tcx>,
    def_id: DefId,
    dead_unwinds: Option<&'a BitSet<BasicBlock>>,
    entry_sets: IndexVec<BasicBlock, BitSet<A::Idx>>,
    analysis: A,
    trans_for_block: Option<IndexVec<BasicBlock, GenKillSet<A::Idx>>>,
}

A solver for dataflow problems.

Fields

bits_per_block: usize

tcx: TyCtxt<'tcx>

body: &'a Body<'tcx>

def_id: DefId

dead_unwinds: Option<&'a BitSet<BasicBlock>>

entry_sets: IndexVec<BasicBlock, BitSet<A::Idx>>

analysis: A

trans_for_block: Option<IndexVec<BasicBlock, GenKillSet<A::Idx>>>

Cached, cumulative transfer functions for each block.

Implementations

impl<A, 'tcx, 'a> Engine<'a, 'tcx, A> where
    A: GenKillAnalysis<'tcx>, 

pub fn new_gen_kill(
    tcx: TyCtxt<'tcx>,
    body: &'a Body<'tcx>,
    def_id: DefId,
    analysis: A
) -> Self

Creates a new Engine to solve a gen-kill dataflow problem.

impl<A, 'tcx, 'a> Engine<'a, 'tcx, A> where
    A: Analysis<'tcx>, 

pub fn new_generic(
    tcx: TyCtxt<'tcx>,
    body: &'a Body<'tcx>,
    def_id: DefId,
    analysis: A
) -> Self

Creates a new Engine to solve a dataflow problem with an arbitrary transfer function.

Gen-kill problems should use new_gen_kill, which will coalesce transfer functions for better performance.

fn new(
    tcx: TyCtxt<'tcx>,
    body: &'a Body<'tcx>,
    def_id: DefId,
    analysis: A,
    trans_for_block: Option<IndexVec<BasicBlock, GenKillSet<A::Idx>>>
) -> Self

pub fn dead_unwinds(self, dead_unwinds: &'a BitSet<BasicBlock>) -> Self

Signals that we do not want dataflow state to propagate across unwind edges for these BasicBlocks.

You must take care that dead_unwinds does not contain a BasicBlock that can actually unwind during execution. Otherwise, your dataflow results will not be correct.

pub fn iterate_to_fixpoint(self) -> Results<'tcx, A>

Computes the fixpoint for this dataflow problem and returns it.