Struct EarlyOtherwiseBranch 

pub(crate) struct EarlyOtherwiseBranch;

This pass optimizes something like

let x: Option<()>;
let y: Option<()>;
match (x,y) {
    (Some(_), Some(_)) => {0},
    (None, None) => {2},
    _ => {1}
}

into something like

let x: Option<()>;
let y: Option<()>;
let discriminant_x = std::mem::discriminant(x);
let discriminant_y = std::mem::discriminant(y);
if discriminant_x == discriminant_y {
    match x {
        Some(_) => 0,
        None => 2,
    }
} else {
    1
}

Specifically, it looks for instances of control flow like this:

    =================
    |      BB1      |
    |---------------|                  ============================
    |     ...       |         /------> |            BBC           |
    |---------------|         |        |--------------------------|
    |  switchInt(Q) |         |        |   _cl = discriminant(P)  |
    |       c       | --------/        |--------------------------|
    |       d       | -------\         |       switchInt(_cl)     |
    |      ...      |        |         |            c             | ---> BBC.2
    |    otherwise  | --\    |    /--- |         otherwise        |
    =================   |    |    |    ============================
                        |    |    |
    =================   |    |    |
    |      BBU      | <-|    |    |    ============================
    |---------------|        \-------> |            BBD           |
    |---------------|             |    |--------------------------|
    |  unreachable  |             |    |   _dl = discriminant(P)  |
    =================             |    |--------------------------|
                                  |    |       switchInt(_dl)     |
    =================             |    |            d             | ---> BBD.2
    |      BB9      | <--------------- |         otherwise        |
    |---------------|                  ============================
    |      ...      |
    =================

Where the otherwise branch on BB1 is permitted to either go to BBU. In the code:

• BB1 is parent and BBC, BBD are children
• P is child_place
• child_ty is the type of _cl.
• Q is parent_op.
• parent_ty is the type of Q.
• BB9 is destination All this is then transformed into:

    =======================
    |          BB1        |
    |---------------------|                  ============================
    |          ...        |         /------> |           BBEq           |
    | _s = discriminant(P)|         |        |--------------------------|
    | _t = Ne(Q, _s)      |         |        |--------------------------|
    |---------------------|         |        |       switchInt(Q)       |
    |     switchInt(_t)   |         |        |            c             | ---> BBC.2
    |        false        | --------/        |            d             | ---> BBD.2
    |       otherwise     |       /--------- |         otherwise        |
    =======================       |          ============================
                                  |
    =================             |
    |      BB9      | <-----------/
    |---------------|
    |      ...      |
    =================

Trait Implementations

impl<'tcx> MirPass<'tcx> for EarlyOtherwiseBranch

fn is_enabled(&self, sess: &Session) -> bool

Returns true if this pass is enabled with the current combination of compiler flags.

fn run_pass(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>)

fn is_required(&self) -> bool

Returns true if this pass must be run (i.e. it is required for soundness). For passes which are strictly optimizations, this should return false. If this is false, #[optimize(none)] will disable the pass.

fn name(&self) -> &'static str

fn profiler_name(&self) -> &'static str

fn can_be_overridden(&self) -> bool

Returns true if this pass can be overridden by -Zenable-mir-passes. This should be true for basically every pass other than those that are necessary for correctness.

fn is_mir_dump_enabled(&self) -> bool

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