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 name(&self) -> &'static str

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

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