Struct rustc_mir_transform::jump_threading::TOFinder

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

Fields

tcx: TyCtxt<'tcx>

param_env: ParamEnv<'tcx>

ecx: InterpCx<'tcx, 'tcx, DummyMachine>

body: &'a Body<'tcx>

map: &'a Map

loop_headers: &'a BitSet<BasicBlock>

arena: &'a DroplessArena

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

opportunities: Vec<ThreadingOpportunity>

Implementations

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

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

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

Recursion entry point 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>> ) -> Option<!>

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>> ) -> Option<!>

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

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

fn recurse_through_terminator( &mut self, bb: BasicBlock, state: &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>> ) -> Option<!>

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