Struct flowistry::infoflow::FlowAnalysis

pub struct FlowAnalysis<'a, 'tcx> {
    pub tcx: TyCtxt<'tcx>,
    pub def_id: DefId,
    pub body: &'a Body<'tcx>,
    pub place_info: PlaceInfo<'a, 'tcx>,
    /* private fields */
}

Data structure that holds context for performing the information flow analysis.

Fields

tcx: TyCtxt<'tcx>

The type context used for the analysis.

def_id: DefId

The ID of the body being analyzed.

body: &'a Body<'tcx>

The body being analyzed.

place_info: PlaceInfo<'a, 'tcx>

The metadata about places used in the analysis.

Implementations

impl<'a, 'tcx> FlowAnalysis<'a, 'tcx>

pub fn new( tcx: TyCtxt<'tcx>, def_id: DefId, body: &'a Body<'tcx>, place_info: PlaceInfo<'a, 'tcx> ) -> Self

Constructs (but does not execute) a new FlowAnalysis.

pub fn location_domain(&self) -> &Rc<LocationOrArgDomain>

Returns the LocationOrArgDomain used by the analysis.

pub fn deps_for( &self, state: &FlowDomain<'tcx>, place: Place<'tcx> ) -> LocationOrArgSet

Returns all the dependencies of place within state.

Prefer using this method instead of accessing FlowDomain directly, unless you really know what you’re doing.

Trait Implementations

impl<'a, 'tcx> Analysis<'tcx> for FlowAnalysis<'a, 'tcx>

fn apply_statement_effect( &mut self, state: &mut Self::Domain, statement: &Statement<'tcx>, location: Location )

Updates the current dataflow state with the effect of evaluating a statement.

fn apply_terminator_effect<'mir>( &mut self, state: &mut Self::Domain, terminator: &'mir Terminator<'tcx>, location: Location ) -> TerminatorEdges<'mir, 'tcx>

Updates the current dataflow state with the effect of evaluating a terminator.

fn apply_call_return_effect( &mut self, _state: &mut Self::Domain, _block: BasicBlock, _return_places: CallReturnPlaces<'_, 'tcx> )

Updates the current dataflow state with the effect of a successful return from a Call terminator.

fn apply_before_statement_effect( &mut self, _state: &mut Self::Domain, _statement: &Statement<'tcx>, _location: Location )

Updates the current dataflow state with an effect that occurs immediately before the given statement.

fn apply_before_terminator_effect( &mut self, _state: &mut Self::Domain, _terminator: &Terminator<'tcx>, _location: Location )

Updates the current dataflow state with an effect that occurs immediately before the given terminator.

fn apply_switch_int_edge_effects( &mut self, _block: BasicBlock, _discr: &Operand<'tcx>, _apply_edge_effects: &mut impl SwitchIntEdgeEffects<Self::Domain> )

Updates the current dataflow state with the effect of taking a particular branch in a SwitchInt terminator.

fn into_engine<'mir>( self, tcx: TyCtxt<'tcx>, body: &'mir Body<'tcx> ) -> Engine<'mir, 'tcx, Self>where Self: Sized,

Creates an Engine to find the fixpoint for this dataflow problem.

impl<'a, 'tcx> AnalysisDomain<'tcx> for FlowAnalysis<'a, 'tcx>

type Domain = IndexMatrix<Place<'tcx>, LocationOrArg, BitSet<usize>, RcFamily>

The type that holds the dataflow state at any given point in the program.

type Direction = Forward

The direction of this analysis. Either Forward or Backward.

const NAME: &'static str = "FlowAnalysis"

A descriptive name for this analysis. Used only for debugging.

fn bottom_value(&self, _body: &Body<'tcx>) -> Self::Domain

Returns the initial value of the dataflow state upon entry to each basic block.

fn initialize_start_block(&self, _body: &Body<'tcx>, state: &mut Self::Domain)

Mutates the initial value of the dataflow state upon entry to the START_BLOCK.