pub struct EarlyOtherwiseBranch;
Expand description

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§

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

Auto Trait Implementations§

Blanket Implementations§

Gets the TypeId of self. Read more
Immutably borrows from an owned value. Read more
Mutably borrows from an owned value. Read more

Returns the argument unchanged.

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

The type returned in the event of a conversion error.
Performs the conversion.
The type returned in the event of a conversion error.
Performs the conversion.

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