| - // 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 _11: (); |
| let mut _12: u64; |
| let mut _13: u64; |
| let _14: (); |
| let mut _15: u64; |
| let mut _16: u64; |
| let mut _17: bool; |
| 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 _49: (); |
| let mut _50: u64; |
| let mut _51: u64; |
| let _52: (); |
| let mut _53: u64; |
| let mut _54: u64; |
| let _55: (); |
| let mut _56: u64; |
| let mut _57: u64; |
| let _58: (); |
| let mut _59: u64; |
| let mut _60: u64; |
| |
| bb0: { |
| StorageLive(_2); |
| StorageLive(_3); |
| StorageLive(_4); |
| _4 = _1; |
| - _3 = Add(move _4, const 0_u64); |
| + _3 = Add(_1, const 0_u64); |
| StorageDead(_4); |
| _2 = opaque::<u64>(move _3) -> [return: bb1, unwind unreachable]; |
| } |
| |
| bb1: { |
| StorageDead(_3); |
| StorageDead(_2); |
| StorageLive(_5); |
| StorageLive(_6); |
| StorageLive(_7); |
| _7 = _1; |
| - _6 = Sub(move _7, const 0_u64); |
| + _6 = Sub(_1, const 0_u64); |
| StorageDead(_7); |
| _5 = opaque::<u64>(move _6) -> [return: bb2, unwind unreachable]; |
| } |
| |
| bb2: { |
| StorageDead(_6); |
| StorageDead(_5); |
| StorageLive(_8); |
| StorageLive(_9); |
| StorageLive(_10); |
| _10 = _1; |
| - _9 = Mul(move _10, const 0_u64); |
| + _9 = Mul(_1, const 0_u64); |
| StorageDead(_10); |
| _8 = opaque::<u64>(move _9) -> [return: bb3, unwind unreachable]; |
| } |
| |
| bb3: { |
| StorageDead(_9); |
| StorageDead(_8); |
| StorageLive(_11); |
| StorageLive(_12); |
| StorageLive(_13); |
| _13 = _1; |
| - _12 = Mul(move _13, const 1_u64); |
| + _12 = Mul(_1, const 1_u64); |
| StorageDead(_13); |
| _11 = opaque::<u64>(move _12) -> [return: bb4, unwind unreachable]; |
| } |
| |
| bb4: { |
| StorageDead(_12); |
| StorageDead(_11); |
| StorageLive(_14); |
| StorageLive(_15); |
| StorageLive(_16); |
| _16 = _1; |
| - _17 = Eq(const 0_u64, const 0_u64); |
| - assert(!move _17, "attempt to divide `{}` by zero", _16) -> [success: bb5, unwind unreachable]; |
| + _17 = const true; |
| + assert(!const true, "attempt to divide `{}` by zero", _1) -> [success: bb5, unwind unreachable]; |
| } |
| |
| bb5: { |
| - _15 = Div(move _16, const 0_u64); |
| + _15 = Div(_1, const 0_u64); |
| StorageDead(_16); |
| _14 = opaque::<u64>(move _15) -> [return: bb6, unwind unreachable]; |
| } |
| |
| bb6: { |
| StorageDead(_15); |
| StorageDead(_14); |
| StorageLive(_18); |
| StorageLive(_19); |
| StorageLive(_20); |
| _20 = _1; |
| - _21 = Eq(const 1_u64, const 0_u64); |
| - assert(!move _21, "attempt to divide `{}` by zero", _20) -> [success: bb7, unwind unreachable]; |
| + _21 = const false; |
| + assert(!const false, "attempt to divide `{}` by zero", _1) -> [success: bb7, unwind unreachable]; |
| } |
| |
| bb7: { |
| - _19 = Div(move _20, const 1_u64); |
| + _19 = Div(_1, const 1_u64); |
| StorageDead(_20); |
| _18 = opaque::<u64>(move _19) -> [return: bb8, unwind unreachable]; |
| } |
| |
| bb8: { |
| StorageDead(_19); |
| StorageDead(_18); |
| StorageLive(_22); |
| StorageLive(_23); |
| StorageLive(_24); |
| _24 = _1; |
| - _25 = Eq(_24, const 0_u64); |
| - assert(!move _25, "attempt to divide `{}` by zero", const 0_u64) -> [success: bb9, unwind unreachable]; |
| + _25 = Eq(_1, const 0_u64); |
| + assert(!_25, "attempt to divide `{}` by zero", const 0_u64) -> [success: bb9, unwind unreachable]; |
| } |
| |
| bb9: { |
| - _23 = Div(const 0_u64, move _24); |
| + _23 = Div(const 0_u64, _1); |
| StorageDead(_24); |
| _22 = opaque::<u64>(move _23) -> [return: bb10, unwind unreachable]; |
| } |
| |
| bb10: { |
| StorageDead(_23); |
| StorageDead(_22); |
| StorageLive(_26); |
| StorageLive(_27); |
| StorageLive(_28); |
| _28 = _1; |
| - _29 = Eq(_28, const 0_u64); |
| - assert(!move _29, "attempt to divide `{}` by zero", const 1_u64) -> [success: bb11, unwind unreachable]; |
| + _29 = _25; |
| + assert(!_25, "attempt to divide `{}` by zero", const 1_u64) -> [success: bb11, unwind unreachable]; |
| } |
| |
| bb11: { |
| - _27 = Div(const 1_u64, move _28); |
| + _27 = Div(const 1_u64, _1); |
| StorageDead(_28); |
| _26 = opaque::<u64>(move _27) -> [return: bb12, unwind unreachable]; |
| } |
| |
| bb12: { |
| StorageDead(_27); |
| StorageDead(_26); |
| StorageLive(_30); |
| StorageLive(_31); |
| StorageLive(_32); |
| _32 = _1; |
| - _33 = Eq(const 0_u64, const 0_u64); |
| - assert(!move _33, "attempt to calculate the remainder of `{}` with a divisor of zero", _32) -> [success: bb13, unwind unreachable]; |
| + _33 = const true; |
| + assert(!const true, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb13, unwind unreachable]; |
| } |
| |
| bb13: { |
| - _31 = Rem(move _32, const 0_u64); |
| + _31 = Rem(_1, const 0_u64); |
| StorageDead(_32); |
| _30 = opaque::<u64>(move _31) -> [return: bb14, unwind unreachable]; |
| } |
| |
| bb14: { |
| StorageDead(_31); |
| StorageDead(_30); |
| StorageLive(_34); |
| StorageLive(_35); |
| StorageLive(_36); |
| _36 = _1; |
| - _37 = Eq(const 1_u64, const 0_u64); |
| - assert(!move _37, "attempt to calculate the remainder of `{}` with a divisor of zero", _36) -> [success: bb15, unwind unreachable]; |
| + _37 = const false; |
| + assert(!const false, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb15, unwind unreachable]; |
| } |
| |
| bb15: { |
| - _35 = Rem(move _36, const 1_u64); |
| + _35 = Rem(_1, const 1_u64); |
| StorageDead(_36); |
| _34 = opaque::<u64>(move _35) -> [return: bb16, unwind unreachable]; |
| } |
| |
| bb16: { |
| StorageDead(_35); |
| StorageDead(_34); |
| StorageLive(_38); |
| StorageLive(_39); |
| StorageLive(_40); |
| _40 = _1; |
| - _41 = Eq(_40, const 0_u64); |
| - assert(!move _41, "attempt to calculate the remainder of `{}` with a divisor of zero", const 0_u64) -> [success: bb17, unwind unreachable]; |
| + _41 = _25; |
| + assert(!_25, "attempt to calculate the remainder of `{}` with a divisor of zero", const 0_u64) -> [success: bb17, unwind unreachable]; |
| } |
| |
| bb17: { |
| - _39 = Rem(const 0_u64, move _40); |
| + _39 = Rem(const 0_u64, _1); |
| StorageDead(_40); |
| _38 = opaque::<u64>(move _39) -> [return: bb18, unwind unreachable]; |
| } |
| |
| bb18: { |
| StorageDead(_39); |
| StorageDead(_38); |
| StorageLive(_42); |
| StorageLive(_43); |
| StorageLive(_44); |
| _44 = _1; |
| - _45 = Eq(_44, const 0_u64); |
| - assert(!move _45, "attempt to calculate the remainder of `{}` with a divisor of zero", const 1_u64) -> [success: bb19, unwind unreachable]; |
| + _45 = _25; |
| + assert(!_25, "attempt to calculate the remainder of `{}` with a divisor of zero", const 1_u64) -> [success: bb19, unwind unreachable]; |
| } |
| |
| bb19: { |
| - _43 = Rem(const 1_u64, move _44); |
| + _43 = Rem(const 1_u64, _1); |
| StorageDead(_44); |
| _42 = opaque::<u64>(move _43) -> [return: bb20, unwind unreachable]; |
| } |
| |
| bb20: { |
| StorageDead(_43); |
| StorageDead(_42); |
| StorageLive(_46); |
| StorageLive(_47); |
| StorageLive(_48); |
| _48 = _1; |
| - _47 = BitAnd(move _48, const 0_u64); |
| + _47 = BitAnd(_1, const 0_u64); |
| StorageDead(_48); |
| _46 = opaque::<u64>(move _47) -> [return: bb21, unwind unreachable]; |
| } |
| |
| bb21: { |
| StorageDead(_47); |
| StorageDead(_46); |
| StorageLive(_49); |
| StorageLive(_50); |
| StorageLive(_51); |
| _51 = _1; |
| - _50 = BitOr(move _51, const 0_u64); |
| + _50 = BitOr(_1, const 0_u64); |
| StorageDead(_51); |
| _49 = opaque::<u64>(move _50) -> [return: bb22, unwind unreachable]; |
| } |
| |
| bb22: { |
| StorageDead(_50); |
| StorageDead(_49); |
| StorageLive(_52); |
| StorageLive(_53); |
| StorageLive(_54); |
| _54 = _1; |
| - _53 = BitXor(move _54, const 0_u64); |
| + _53 = BitXor(_1, const 0_u64); |
| StorageDead(_54); |
| _52 = opaque::<u64>(move _53) -> [return: bb23, unwind unreachable]; |
| } |
| |
| bb23: { |
| StorageDead(_53); |
| StorageDead(_52); |
| StorageLive(_55); |
| StorageLive(_56); |
| StorageLive(_57); |
| _57 = _1; |
| - _56 = Shr(move _57, const 0_i32); |
| + _56 = Shr(_1, const 0_i32); |
| StorageDead(_57); |
| _55 = opaque::<u64>(move _56) -> [return: bb24, unwind unreachable]; |
| } |
| |
| bb24: { |
| StorageDead(_56); |
| StorageDead(_55); |
| StorageLive(_58); |
| StorageLive(_59); |
| StorageLive(_60); |
| _60 = _1; |
| - _59 = Shl(move _60, const 0_i32); |
| + _59 = Shl(_1, const 0_i32); |
| StorageDead(_60); |
| _58 = opaque::<u64>(move _59) -> [return: bb25, unwind unreachable]; |
| } |
| |
| bb25: { |
| StorageDead(_59); |
| StorageDead(_58); |
| _0 = const (); |
| return; |
| } |
| } |
| |