Struct rustc_mir_transform::early_otherwise_branch::EarlyOtherwiseBranch

pub struct EarlyOtherwiseBranch;

This pass optimizes something like

let x: Option<()>;
let y: Option<()>;
match (x,y) {
    (Some(_), Some(_)) => {0},
    _ => {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,
        _ => 1, // <----
    } //               | Actually the same bb
} 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 or to BB9. 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      | <-----------/
    |---------------|
    |      ...      |
    =================

This is only correct for some P, since P is now computed outside the original switchInt. The filter on which P are allowed (together with discussion of its correctness) is found in may_hoist.

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