Struct TOFinder

struct TOFinder<'a, 'tcx> {
    tcx: TyCtxt<'tcx>,
    typing_env: TypingEnv<'tcx>,
    ecx: InterpCx<'tcx, DummyMachine>,
    body: &'a Body<'tcx>,
    map: Map<'tcx>,
    loop_headers: BitSet<BasicBlock>,
    arena: &'a DroplessArena,
    opportunities: Vec<ThreadingOpportunity>,
}

Fields

tcx: TyCtxt<'tcx>

typing_env: TypingEnv<'tcx>

ecx: InterpCx<'tcx, DummyMachine>

body: &'a Body<'tcx>

map: Map<'tcx>

loop_headers: BitSet<BasicBlock>

arena: &'a DroplessArena

We use an arena to avoid cloning the slices when cloning state.

opportunities: Vec<ThreadingOpportunity>

Implementations

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

fn is_empty(&self, state: &State<ConditionSet<'a>>) -> bool

fn start_from_switch(&mut self, bb: BasicBlock)

Recursion entry point to find threading opportunities.

fn find_opportunity( &mut self, bb: BasicBlock, state: State<ConditionSet<'a>>, cost: CostChecker<'_, 'tcx>, depth: usize, )

Recursively walk statements backwards from this bb’s terminator to find threading opportunities.

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, bb: BasicBlock, lhs: PlaceIndex, rhs: ImmTy<'tcx>, state: &mut State<ConditionSet<'a>>, )

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

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

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

fn process_assign( &mut self, bb: BasicBlock, lhs_place: &Place<'tcx>, rhs: &Rvalue<'tcx>, state: &mut State<ConditionSet<'a>>, )

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

fn recurse_through_terminator( &mut self, bb: BasicBlock, state: impl FnOnce() -> State<ConditionSet<'a>>, cost: &CostChecker<'_, 'tcx>, depth: usize, )

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

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: 464 bytes