Struct SimplifyMatch 

struct SimplifyMatch<'tcx, 'a> {
    tcx: TyCtxt<'tcx>,
    typing_env: TypingEnv<'tcx>,
    patch: MirPatch<'tcx>,
    body: &'a Body<'tcx>,
    switch_bb: BasicBlock,
    discr: &'a Operand<'tcx>,
    discr_local: Option<Local>,
    discr_ty: Ty<'tcx>,
}

Fields

tcx: TyCtxt<'tcx>

typing_env: TypingEnv<'tcx>

patch: MirPatch<'tcx>

body: &'a Body<'tcx>

switch_bb: BasicBlock

discr: &'a Operand<'tcx>

discr_local: Option<Local>

discr_ty: Ty<'tcx>

Implementations

impl<'tcx, 'a> SimplifyMatch<'tcx, 'a>

fn discr_local(&mut self) -> Local

fn unify_if_equal_const( &self, dest: Place<'tcx>, consts: &[(u128, &ConstOperand<'tcx>)], otherwise: Option<&ConstOperand<'tcx>>, ) -> Option<StatementKind<'tcx>>

Unifies the assignments if all rvalues are constants and equal.

fn unify_by_eq_op( &mut self, dest: Place<'tcx>, consts: &[(u128, &ConstOperand<'tcx>)], otherwise: Option<&ConstOperand<'tcx>>, ) -> Option<StatementKind<'tcx>>

If a source block is found that switches between two blocks that are exactly the same modulo const bool assignments (e.g., one assigns true another false to the same place), unify a target block statements into the source block, using Eq / Ne comparison with switch value where const bools value differ.

For example:

bb0: {
    switchInt(move _3) -> [42_isize: bb1, otherwise: bb2];
}

bb1: {
    _2 = const true;
    goto -> bb3;
}

bb2: {
    _2 = const false;
    goto -> bb3;
}

into:

bb0: {
   _2 = Eq(move _3, const 42_isize);
   goto -> bb3;
}

fn unify_by_int_to_int( &mut self, dest: Place<'tcx>, consts: &[(u128, &ConstOperand<'tcx>)], ) -> Option<StatementKind<'tcx>>

Unifies the assignments if all rvalues can be cast from the discriminant value by IntToInt.

For example:

bb0: {
    switchInt(_1) -> [1: bb2, 2: bb3, 3: bb4, otherwise: bb1];
}

bb1: {
    unreachable;
}

bb2: {
    _0 = const 1_i16;
    goto -> bb5;
}

bb3: {
    _0 = const 2_i16;
    goto -> bb5;
}

bb4: {
    _0 = const 3_i16;
    goto -> bb5;
}

into:

bb0: {
   _0 = _1 as i16 (IntToInt);
   goto -> bb5;
}

fn unify_by_copy( &self, dest: Place<'tcx>, rvals: &[(u128, &Rvalue<'tcx>)], ) -> Option<StatementKind<'tcx>>

This is primarily used to unify these copy statements that simplified the canonical enum clone method by GVN. The GVN simplified

match a {
    Foo::A(x) => Foo::A(*x),
    Foo::B => Foo::B
}

to

match a {
    Foo::A(_x) => a, // copy a
    Foo::B => Foo::B
}

This will simplify into a copy statement.

fn try_unify_stmts( &mut self, index: usize, stmts: &[(u128, &StatementKind<'tcx>)], otherwise: Option<&StatementKind<'tcx>>, ) -> Option<StatementKind<'tcx>>

Returns a new statement if we can use the statement replace all statements.

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