Struct TOFinder 

struct TOFinder<'a, 'tcx> {
    tcx: TyCtxt<'tcx>,
    typing_env: TypingEnv<'tcx>,
    ecx: InterpCx<'tcx, DummyMachine>,
    body: &'a Body<'tcx>,
    map: Map<'tcx>,
    maybe_loop_headers: DenseBitSet<BasicBlock>,
    entry_states: IndexVec<BasicBlock, ConditionSet>,
}

Fields

tcx: TyCtxt<'tcx>

typing_env: TypingEnv<'tcx>

ecx: InterpCx<'tcx, DummyMachine>

body: &'a Body<'tcx>

map: Map<'tcx>

maybe_loop_headers: DenseBitSet<BasicBlock>

entry_states: IndexVec<BasicBlock, ConditionSet>

This stores the state of each visited block on entry, and the current state of the block being visited.

Implementations

impl<'a, 'tcx> TOFinder<'a, 'tcx>

fn populate_from_outgoing_edges(&mut self, bb: BasicBlock) -> ConditionSet

Construct the condition set for bb from the terminator, without executing its effect.

fn flood_state( &self, place: Place<'tcx>, extra_elem: Option<TrackElem>, state: &mut ConditionSet, )

Remove all conditions in the state that alias given place.

fn mutated_statement( &self, stmt: &Statement<'tcx>, ) -> Option<(Place<'tcx>, Option<TrackElem>)>

Extract the mutated place from a statement.

This method returns the Place so we can flood the state in case of a partial assignment. (_1 as Ok).0 = _5; (_1 as Err).0 = _6; We want to ensure that a SwitchInt((_1 as Ok).0) does not see the first assignment, as the value may have been mangled by the second assignment.

In case we assign to a discriminant, we return Some(TrackElem::Discriminant), so we can stop at flooding the discriminant, and preserve the variant fields. (_1 as Some).0 = _6; SetDiscriminant(_1, 1); switchInt((_1 as Some).0)

fn process_immediate( &mut self, lhs: PlaceIndex, rhs: ImmTy<'tcx>, state: &mut ConditionSet, )

fn process_constant( &mut self, lhs: PlaceIndex, constant: OpTy<'tcx>, state: &mut ConditionSet, )

If we expect lhs ?= A, we have an opportunity if we assume constant == A.

fn process_copy( &mut self, lhs: PlaceIndex, rhs: PlaceIndex, state: &mut ConditionSet, )

fn process_operand( &mut self, lhs: PlaceIndex, rhs: &Operand<'tcx>, state: &mut ConditionSet, )

fn process_assign( &mut self, lhs_place: &Place<'tcx>, rvalue: &Rvalue<'tcx>, state: &mut ConditionSet, )

fn process_statement( &mut self, stmt: &Statement<'tcx>, state: &mut ConditionSet, )

fn process_terminator(&mut self, bb: BasicBlock, state: &mut ConditionSet)

Execute the terminator for block bb into state entry_states[bb].

fn process_switch_int( &mut self, discr: &Operand<'tcx>, targets: &SwitchTargets, state: &mut ConditionSet, )

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 456 bytes