441 lines
14 KiB
Diff
441 lines
14 KiB
Diff
- // MIR for `arithmetic` before GVN
|
|
+ // MIR for `arithmetic` after GVN
|
|
|
|
fn arithmetic(_1: u64) -> () {
|
|
debug x => _1;
|
|
let mut _0: ();
|
|
let _2: ();
|
|
let mut _3: u64;
|
|
let mut _4: u64;
|
|
let _5: ();
|
|
let mut _6: u64;
|
|
let mut _7: u64;
|
|
let _8: ();
|
|
let mut _9: u64;
|
|
let mut _10: u64;
|
|
let mut _11: u64;
|
|
let _12: ();
|
|
let mut _13: u64;
|
|
let mut _14: u64;
|
|
let _15: ();
|
|
let mut _16: u64;
|
|
let mut _17: u64;
|
|
let _18: ();
|
|
let mut _19: u64;
|
|
let mut _20: u64;
|
|
let mut _21: bool;
|
|
let _22: ();
|
|
let mut _23: u64;
|
|
let mut _24: u64;
|
|
let mut _25: bool;
|
|
let _26: ();
|
|
let mut _27: u64;
|
|
let mut _28: u64;
|
|
let mut _29: bool;
|
|
let _30: ();
|
|
let mut _31: u64;
|
|
let mut _32: u64;
|
|
let mut _33: bool;
|
|
let _34: ();
|
|
let mut _35: u64;
|
|
let mut _36: u64;
|
|
let mut _37: bool;
|
|
let _38: ();
|
|
let mut _39: u64;
|
|
let mut _40: u64;
|
|
let mut _41: bool;
|
|
let _42: ();
|
|
let mut _43: u64;
|
|
let mut _44: u64;
|
|
let mut _45: bool;
|
|
let _46: ();
|
|
let mut _47: u64;
|
|
let mut _48: u64;
|
|
let mut _49: bool;
|
|
let _50: ();
|
|
let mut _51: u64;
|
|
let mut _52: u64;
|
|
let _53: ();
|
|
let mut _54: u64;
|
|
let mut _55: u64;
|
|
let _56: ();
|
|
let mut _57: u64;
|
|
let mut _58: u64;
|
|
let _59: ();
|
|
let mut _60: u64;
|
|
let mut _61: u64;
|
|
let _62: ();
|
|
let mut _63: u64;
|
|
let mut _64: u64;
|
|
let _65: ();
|
|
let mut _66: u64;
|
|
let mut _67: u64;
|
|
let mut _68: u64;
|
|
let _69: ();
|
|
let mut _70: u64;
|
|
let mut _71: u64;
|
|
let _72: ();
|
|
let mut _73: u64;
|
|
let mut _74: u64;
|
|
|
|
bb0: {
|
|
StorageLive(_2);
|
|
StorageLive(_3);
|
|
StorageLive(_4);
|
|
_4 = copy _1;
|
|
- _3 = Add(move _4, const 0_u64);
|
|
+ _3 = copy _1;
|
|
StorageDead(_4);
|
|
- _2 = opaque::<u64>(move _3) -> [return: bb1, unwind unreachable];
|
|
+ _2 = opaque::<u64>(copy _1) -> [return: bb1, unwind unreachable];
|
|
}
|
|
|
|
bb1: {
|
|
StorageDead(_3);
|
|
StorageDead(_2);
|
|
StorageLive(_5);
|
|
StorageLive(_6);
|
|
StorageLive(_7);
|
|
_7 = copy _1;
|
|
- _6 = Sub(move _7, const 0_u64);
|
|
+ _6 = copy _1;
|
|
StorageDead(_7);
|
|
- _5 = opaque::<u64>(move _6) -> [return: bb2, unwind unreachable];
|
|
+ _5 = opaque::<u64>(copy _1) -> [return: bb2, unwind unreachable];
|
|
}
|
|
|
|
bb2: {
|
|
StorageDead(_6);
|
|
StorageDead(_5);
|
|
StorageLive(_8);
|
|
- StorageLive(_9);
|
|
+ nop;
|
|
StorageLive(_10);
|
|
_10 = copy _1;
|
|
StorageLive(_11);
|
|
_11 = copy _1;
|
|
- _9 = Sub(move _10, move _11);
|
|
+ _9 = const 0_u64;
|
|
StorageDead(_11);
|
|
StorageDead(_10);
|
|
- _8 = opaque::<u64>(move _9) -> [return: bb3, unwind unreachable];
|
|
+ _8 = opaque::<u64>(const 0_u64) -> [return: bb3, unwind unreachable];
|
|
}
|
|
|
|
bb3: {
|
|
- StorageDead(_9);
|
|
+ nop;
|
|
StorageDead(_8);
|
|
StorageLive(_12);
|
|
StorageLive(_13);
|
|
StorageLive(_14);
|
|
_14 = copy _1;
|
|
- _13 = Mul(move _14, const 0_u64);
|
|
+ _13 = const 0_u64;
|
|
StorageDead(_14);
|
|
- _12 = opaque::<u64>(move _13) -> [return: bb4, unwind unreachable];
|
|
+ _12 = opaque::<u64>(const 0_u64) -> [return: bb4, unwind unreachable];
|
|
}
|
|
|
|
bb4: {
|
|
StorageDead(_13);
|
|
StorageDead(_12);
|
|
StorageLive(_15);
|
|
StorageLive(_16);
|
|
StorageLive(_17);
|
|
_17 = copy _1;
|
|
- _16 = Mul(move _17, const 1_u64);
|
|
+ _16 = copy _1;
|
|
StorageDead(_17);
|
|
- _15 = opaque::<u64>(move _16) -> [return: bb5, unwind unreachable];
|
|
+ _15 = opaque::<u64>(copy _1) -> [return: bb5, unwind unreachable];
|
|
}
|
|
|
|
bb5: {
|
|
StorageDead(_16);
|
|
StorageDead(_15);
|
|
StorageLive(_18);
|
|
StorageLive(_19);
|
|
StorageLive(_20);
|
|
_20 = copy _1;
|
|
- _21 = Eq(const 0_u64, const 0_u64);
|
|
- assert(!move _21, "attempt to divide `{}` by zero", copy _20) -> [success: bb6, unwind unreachable];
|
|
+ _21 = const true;
|
|
+ assert(!const true, "attempt to divide `{}` by zero", copy _1) -> [success: bb6, unwind unreachable];
|
|
}
|
|
|
|
bb6: {
|
|
- _19 = Div(move _20, const 0_u64);
|
|
+ _19 = Div(copy _1, const 0_u64);
|
|
StorageDead(_20);
|
|
_18 = opaque::<u64>(move _19) -> [return: bb7, unwind unreachable];
|
|
}
|
|
|
|
bb7: {
|
|
StorageDead(_19);
|
|
StorageDead(_18);
|
|
StorageLive(_22);
|
|
StorageLive(_23);
|
|
StorageLive(_24);
|
|
_24 = copy _1;
|
|
- _25 = Eq(const 1_u64, const 0_u64);
|
|
- assert(!move _25, "attempt to divide `{}` by zero", copy _24) -> [success: bb8, unwind unreachable];
|
|
+ _25 = const false;
|
|
+ assert(!const false, "attempt to divide `{}` by zero", copy _1) -> [success: bb8, unwind unreachable];
|
|
}
|
|
|
|
bb8: {
|
|
- _23 = Div(move _24, const 1_u64);
|
|
+ _23 = copy _1;
|
|
StorageDead(_24);
|
|
- _22 = opaque::<u64>(move _23) -> [return: bb9, unwind unreachable];
|
|
+ _22 = opaque::<u64>(copy _1) -> [return: bb9, unwind unreachable];
|
|
}
|
|
|
|
bb9: {
|
|
StorageDead(_23);
|
|
StorageDead(_22);
|
|
StorageLive(_26);
|
|
StorageLive(_27);
|
|
StorageLive(_28);
|
|
_28 = copy _1;
|
|
- _29 = Eq(copy _28, const 0_u64);
|
|
- assert(!move _29, "attempt to divide `{}` by zero", const 0_u64) -> [success: bb10, unwind unreachable];
|
|
+ _29 = Eq(copy _1, const 0_u64);
|
|
+ assert(!copy _29, "attempt to divide `{}` by zero", const 0_u64) -> [success: bb10, unwind unreachable];
|
|
}
|
|
|
|
bb10: {
|
|
- _27 = Div(const 0_u64, move _28);
|
|
+ _27 = const 0_u64;
|
|
StorageDead(_28);
|
|
- _26 = opaque::<u64>(move _27) -> [return: bb11, unwind unreachable];
|
|
+ _26 = opaque::<u64>(const 0_u64) -> [return: bb11, unwind unreachable];
|
|
}
|
|
|
|
bb11: {
|
|
StorageDead(_27);
|
|
StorageDead(_26);
|
|
StorageLive(_30);
|
|
StorageLive(_31);
|
|
StorageLive(_32);
|
|
_32 = copy _1;
|
|
- _33 = Eq(copy _32, const 0_u64);
|
|
- assert(!move _33, "attempt to divide `{}` by zero", const 1_u64) -> [success: bb12, unwind unreachable];
|
|
+ _33 = copy _29;
|
|
+ assert(!copy _29, "attempt to divide `{}` by zero", const 1_u64) -> [success: bb12, unwind unreachable];
|
|
}
|
|
|
|
bb12: {
|
|
- _31 = Div(const 1_u64, move _32);
|
|
+ _31 = Div(const 1_u64, copy _1);
|
|
StorageDead(_32);
|
|
_30 = opaque::<u64>(move _31) -> [return: bb13, unwind unreachable];
|
|
}
|
|
|
|
bb13: {
|
|
StorageDead(_31);
|
|
StorageDead(_30);
|
|
StorageLive(_34);
|
|
StorageLive(_35);
|
|
StorageLive(_36);
|
|
_36 = copy _1;
|
|
- _37 = Eq(const 0_u64, const 0_u64);
|
|
- assert(!move _37, "attempt to calculate the remainder of `{}` with a divisor of zero", copy _36) -> [success: bb14, unwind unreachable];
|
|
+ _37 = const true;
|
|
+ assert(!const true, "attempt to calculate the remainder of `{}` with a divisor of zero", copy _1) -> [success: bb14, unwind unreachable];
|
|
}
|
|
|
|
bb14: {
|
|
- _35 = Rem(move _36, const 0_u64);
|
|
+ _35 = Rem(copy _1, const 0_u64);
|
|
StorageDead(_36);
|
|
_34 = opaque::<u64>(move _35) -> [return: bb15, unwind unreachable];
|
|
}
|
|
|
|
bb15: {
|
|
StorageDead(_35);
|
|
StorageDead(_34);
|
|
StorageLive(_38);
|
|
StorageLive(_39);
|
|
StorageLive(_40);
|
|
_40 = copy _1;
|
|
- _41 = Eq(const 1_u64, const 0_u64);
|
|
- assert(!move _41, "attempt to calculate the remainder of `{}` with a divisor of zero", copy _40) -> [success: bb16, unwind unreachable];
|
|
+ _41 = const false;
|
|
+ assert(!const false, "attempt to calculate the remainder of `{}` with a divisor of zero", copy _1) -> [success: bb16, unwind unreachable];
|
|
}
|
|
|
|
bb16: {
|
|
- _39 = Rem(move _40, const 1_u64);
|
|
+ _39 = const 0_u64;
|
|
StorageDead(_40);
|
|
- _38 = opaque::<u64>(move _39) -> [return: bb17, unwind unreachable];
|
|
+ _38 = opaque::<u64>(const 0_u64) -> [return: bb17, unwind unreachable];
|
|
}
|
|
|
|
bb17: {
|
|
StorageDead(_39);
|
|
StorageDead(_38);
|
|
StorageLive(_42);
|
|
StorageLive(_43);
|
|
StorageLive(_44);
|
|
_44 = copy _1;
|
|
- _45 = Eq(copy _44, const 0_u64);
|
|
- assert(!move _45, "attempt to calculate the remainder of `{}` with a divisor of zero", const 0_u64) -> [success: bb18, unwind unreachable];
|
|
+ _45 = copy _29;
|
|
+ assert(!copy _29, "attempt to calculate the remainder of `{}` with a divisor of zero", const 0_u64) -> [success: bb18, unwind unreachable];
|
|
}
|
|
|
|
bb18: {
|
|
- _43 = Rem(const 0_u64, move _44);
|
|
+ _43 = const 0_u64;
|
|
StorageDead(_44);
|
|
- _42 = opaque::<u64>(move _43) -> [return: bb19, unwind unreachable];
|
|
+ _42 = opaque::<u64>(const 0_u64) -> [return: bb19, unwind unreachable];
|
|
}
|
|
|
|
bb19: {
|
|
StorageDead(_43);
|
|
StorageDead(_42);
|
|
StorageLive(_46);
|
|
StorageLive(_47);
|
|
StorageLive(_48);
|
|
_48 = copy _1;
|
|
- _49 = Eq(copy _48, const 0_u64);
|
|
- assert(!move _49, "attempt to calculate the remainder of `{}` with a divisor of zero", const 1_u64) -> [success: bb20, unwind unreachable];
|
|
+ _49 = copy _29;
|
|
+ assert(!copy _29, "attempt to calculate the remainder of `{}` with a divisor of zero", const 1_u64) -> [success: bb20, unwind unreachable];
|
|
}
|
|
|
|
bb20: {
|
|
- _47 = Rem(const 1_u64, move _48);
|
|
+ _47 = Rem(const 1_u64, copy _1);
|
|
StorageDead(_48);
|
|
_46 = opaque::<u64>(move _47) -> [return: bb21, unwind unreachable];
|
|
}
|
|
|
|
bb21: {
|
|
StorageDead(_47);
|
|
StorageDead(_46);
|
|
StorageLive(_50);
|
|
StorageLive(_51);
|
|
StorageLive(_52);
|
|
_52 = copy _1;
|
|
- _51 = BitAnd(move _52, const 0_u64);
|
|
+ _51 = const 0_u64;
|
|
StorageDead(_52);
|
|
- _50 = opaque::<u64>(move _51) -> [return: bb22, unwind unreachable];
|
|
+ _50 = opaque::<u64>(const 0_u64) -> [return: bb22, unwind unreachable];
|
|
}
|
|
|
|
bb22: {
|
|
StorageDead(_51);
|
|
StorageDead(_50);
|
|
StorageLive(_53);
|
|
StorageLive(_54);
|
|
StorageLive(_55);
|
|
_55 = copy _1;
|
|
- _54 = BitAnd(move _55, const core::num::<impl u64>::MAX);
|
|
+ _54 = copy _1;
|
|
StorageDead(_55);
|
|
- _53 = opaque::<u64>(move _54) -> [return: bb23, unwind unreachable];
|
|
+ _53 = opaque::<u64>(copy _1) -> [return: bb23, unwind unreachable];
|
|
}
|
|
|
|
bb23: {
|
|
StorageDead(_54);
|
|
StorageDead(_53);
|
|
StorageLive(_56);
|
|
StorageLive(_57);
|
|
StorageLive(_58);
|
|
_58 = copy _1;
|
|
- _57 = BitOr(move _58, const 0_u64);
|
|
+ _57 = copy _1;
|
|
StorageDead(_58);
|
|
- _56 = opaque::<u64>(move _57) -> [return: bb24, unwind unreachable];
|
|
+ _56 = opaque::<u64>(copy _1) -> [return: bb24, unwind unreachable];
|
|
}
|
|
|
|
bb24: {
|
|
StorageDead(_57);
|
|
StorageDead(_56);
|
|
StorageLive(_59);
|
|
StorageLive(_60);
|
|
StorageLive(_61);
|
|
_61 = copy _1;
|
|
- _60 = BitOr(move _61, const core::num::<impl u64>::MAX);
|
|
+ _60 = const u64::MAX;
|
|
StorageDead(_61);
|
|
- _59 = opaque::<u64>(move _60) -> [return: bb25, unwind unreachable];
|
|
+ _59 = opaque::<u64>(const u64::MAX) -> [return: bb25, unwind unreachable];
|
|
}
|
|
|
|
bb25: {
|
|
StorageDead(_60);
|
|
StorageDead(_59);
|
|
StorageLive(_62);
|
|
StorageLive(_63);
|
|
StorageLive(_64);
|
|
_64 = copy _1;
|
|
- _63 = BitXor(move _64, const 0_u64);
|
|
+ _63 = copy _1;
|
|
StorageDead(_64);
|
|
- _62 = opaque::<u64>(move _63) -> [return: bb26, unwind unreachable];
|
|
+ _62 = opaque::<u64>(copy _1) -> [return: bb26, unwind unreachable];
|
|
}
|
|
|
|
bb26: {
|
|
StorageDead(_63);
|
|
StorageDead(_62);
|
|
StorageLive(_65);
|
|
StorageLive(_66);
|
|
StorageLive(_67);
|
|
_67 = copy _1;
|
|
StorageLive(_68);
|
|
_68 = copy _1;
|
|
- _66 = BitXor(move _67, move _68);
|
|
+ _66 = const 0_u64;
|
|
StorageDead(_68);
|
|
StorageDead(_67);
|
|
- _65 = opaque::<u64>(move _66) -> [return: bb27, unwind unreachable];
|
|
+ _65 = opaque::<u64>(const 0_u64) -> [return: bb27, unwind unreachable];
|
|
}
|
|
|
|
bb27: {
|
|
StorageDead(_66);
|
|
StorageDead(_65);
|
|
StorageLive(_69);
|
|
StorageLive(_70);
|
|
StorageLive(_71);
|
|
_71 = copy _1;
|
|
- _70 = Shr(move _71, const 0_i32);
|
|
+ _70 = copy _1;
|
|
StorageDead(_71);
|
|
- _69 = opaque::<u64>(move _70) -> [return: bb28, unwind unreachable];
|
|
+ _69 = opaque::<u64>(copy _1) -> [return: bb28, unwind unreachable];
|
|
}
|
|
|
|
bb28: {
|
|
StorageDead(_70);
|
|
StorageDead(_69);
|
|
StorageLive(_72);
|
|
StorageLive(_73);
|
|
StorageLive(_74);
|
|
_74 = copy _1;
|
|
- _73 = Shl(move _74, const 0_i32);
|
|
+ _73 = copy _1;
|
|
StorageDead(_74);
|
|
- _72 = opaque::<u64>(move _73) -> [return: bb29, unwind unreachable];
|
|
+ _72 = opaque::<u64>(copy _1) -> [return: bb29, unwind unreachable];
|
|
}
|
|
|
|
bb29: {
|
|
StorageDead(_73);
|
|
StorageDead(_72);
|
|
_0 = const ();
|
|
return;
|
|
}
|
|
}
|
|
|