diff --git a/tests/mir-opt/gvn.aggregates.GVN.panic-abort.diff b/tests/mir-opt/gvn.aggregates.GVN.panic-abort.diff deleted file mode 100644 index b1dae36ab6c..00000000000 --- a/tests/mir-opt/gvn.aggregates.GVN.panic-abort.diff +++ /dev/null @@ -1,133 +0,0 @@ -- // MIR for `aggregates` before GVN -+ // MIR for `aggregates` after GVN - - fn aggregates() -> () { - let mut _0: (); - let _1: S<[u8; 0]>; - let mut _2: [u8; 0]; - let mut _4: [u16; 0]; - let mut _6: (); - let mut _8: (); - let mut _11: i32; - let mut _12: i32; - let mut _13: i32; - let mut _14: i32; - let mut _15: i32; - let mut _16: i32; - let mut _17: i32; - let mut _18: i32; - let mut _19: i32; - let mut _20: i32; - scope 1 { - debug a_array => _1; - let _3: S<[u16; 0]>; - scope 2 { - debug b_array => _3; - let _5: S<()>; - scope 3 { - debug a_tuple => _5; - let _7: S<()>; - scope 4 { - debug b_tuple => _7; - let _9: i32; - scope 5 { - debug val => _9; - let _10: [i32; 10]; - scope 6 { - debug array => _10; - } - } - } - } - } - } - - bb0: { - StorageLive(_1); - StorageLive(_2); -- _2 = []; -- _1 = S::<[u8; 0]>(move _2); -+ _2 = const []; -+ _1 = const S::<[u8; 0]>([]); - StorageDead(_2); - StorageLive(_3); - StorageLive(_4); -- _4 = []; -- _3 = S::<[u16; 0]>(move _4); -+ _4 = const []; -+ _3 = const S::<[u16; 0]>([]); - StorageDead(_4); - StorageLive(_5); -- StorageLive(_6); -- _6 = (); -- _5 = S::<()>(move _6); -- StorageDead(_6); -+ nop; -+ _6 = const (); -+ _5 = const S::<()>(()); -+ nop; - StorageLive(_7); - StorageLive(_8); -- _8 = (); -- _7 = S::<()>(move _8); -+ _8 = const (); -+ _7 = const S::<()>(()); - StorageDead(_8); -- StorageLive(_9); -+ nop; - _9 = const 5_i32; - StorageLive(_10); - StorageLive(_11); -- _11 = _9; -+ _11 = const 5_i32; - StorageLive(_12); -- _12 = _9; -+ _12 = const 5_i32; - StorageLive(_13); -- _13 = _9; -+ _13 = const 5_i32; - StorageLive(_14); -- _14 = _9; -+ _14 = const 5_i32; - StorageLive(_15); -- _15 = _9; -+ _15 = const 5_i32; - StorageLive(_16); -- _16 = _9; -+ _16 = const 5_i32; - StorageLive(_17); -- _17 = _9; -+ _17 = const 5_i32; - StorageLive(_18); -- _18 = _9; -+ _18 = const 5_i32; - StorageLive(_19); -- _19 = _9; -+ _19 = const 5_i32; - StorageLive(_20); -- _20 = _9; -- _10 = [move _11, move _12, move _13, move _14, move _15, move _16, move _17, move _18, move _19, move _20]; -+ _20 = const 5_i32; -+ _10 = [const 5_i32; 10]; - StorageDead(_20); - StorageDead(_19); - StorageDead(_18); - StorageDead(_17); - StorageDead(_16); - StorageDead(_15); - StorageDead(_14); - StorageDead(_13); - StorageDead(_12); - StorageDead(_11); - _0 = const (); - StorageDead(_10); -- StorageDead(_9); -+ nop; - StorageDead(_7); - StorageDead(_5); - StorageDead(_3); - StorageDead(_1); - return; - } - } - diff --git a/tests/mir-opt/gvn.aggregates.GVN.panic-unwind.diff b/tests/mir-opt/gvn.aggregates.GVN.panic-unwind.diff deleted file mode 100644 index b1dae36ab6c..00000000000 --- a/tests/mir-opt/gvn.aggregates.GVN.panic-unwind.diff +++ /dev/null @@ -1,133 +0,0 @@ -- // MIR for `aggregates` before GVN -+ // MIR for `aggregates` after GVN - - fn aggregates() -> () { - let mut _0: (); - let _1: S<[u8; 0]>; - let mut _2: [u8; 0]; - let mut _4: [u16; 0]; - let mut _6: (); - let mut _8: (); - let mut _11: i32; - let mut _12: i32; - let mut _13: i32; - let mut _14: i32; - let mut _15: i32; - let mut _16: i32; - let mut _17: i32; - let mut _18: i32; - let mut _19: i32; - let mut _20: i32; - scope 1 { - debug a_array => _1; - let _3: S<[u16; 0]>; - scope 2 { - debug b_array => _3; - let _5: S<()>; - scope 3 { - debug a_tuple => _5; - let _7: S<()>; - scope 4 { - debug b_tuple => _7; - let _9: i32; - scope 5 { - debug val => _9; - let _10: [i32; 10]; - scope 6 { - debug array => _10; - } - } - } - } - } - } - - bb0: { - StorageLive(_1); - StorageLive(_2); -- _2 = []; -- _1 = S::<[u8; 0]>(move _2); -+ _2 = const []; -+ _1 = const S::<[u8; 0]>([]); - StorageDead(_2); - StorageLive(_3); - StorageLive(_4); -- _4 = []; -- _3 = S::<[u16; 0]>(move _4); -+ _4 = const []; -+ _3 = const S::<[u16; 0]>([]); - StorageDead(_4); - StorageLive(_5); -- StorageLive(_6); -- _6 = (); -- _5 = S::<()>(move _6); -- StorageDead(_6); -+ nop; -+ _6 = const (); -+ _5 = const S::<()>(()); -+ nop; - StorageLive(_7); - StorageLive(_8); -- _8 = (); -- _7 = S::<()>(move _8); -+ _8 = const (); -+ _7 = const S::<()>(()); - StorageDead(_8); -- StorageLive(_9); -+ nop; - _9 = const 5_i32; - StorageLive(_10); - StorageLive(_11); -- _11 = _9; -+ _11 = const 5_i32; - StorageLive(_12); -- _12 = _9; -+ _12 = const 5_i32; - StorageLive(_13); -- _13 = _9; -+ _13 = const 5_i32; - StorageLive(_14); -- _14 = _9; -+ _14 = const 5_i32; - StorageLive(_15); -- _15 = _9; -+ _15 = const 5_i32; - StorageLive(_16); -- _16 = _9; -+ _16 = const 5_i32; - StorageLive(_17); -- _17 = _9; -+ _17 = const 5_i32; - StorageLive(_18); -- _18 = _9; -+ _18 = const 5_i32; - StorageLive(_19); -- _19 = _9; -+ _19 = const 5_i32; - StorageLive(_20); -- _20 = _9; -- _10 = [move _11, move _12, move _13, move _14, move _15, move _16, move _17, move _18, move _19, move _20]; -+ _20 = const 5_i32; -+ _10 = [const 5_i32; 10]; - StorageDead(_20); - StorageDead(_19); - StorageDead(_18); - StorageDead(_17); - StorageDead(_16); - StorageDead(_15); - StorageDead(_14); - StorageDead(_13); - StorageDead(_12); - StorageDead(_11); - _0 = const (); - StorageDead(_10); -- StorageDead(_9); -+ nop; - StorageDead(_7); - StorageDead(_5); - StorageDead(_3); - StorageDead(_1); - return; - } - } - diff --git a/tests/mir-opt/gvn.arithmetic_checked.GVN.panic-abort.diff b/tests/mir-opt/gvn.arithmetic_checked.GVN.panic-abort.diff index 3efe7abc976..6633df3ae70 100644 --- a/tests/mir-opt/gvn.arithmetic_checked.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn.arithmetic_checked.GVN.panic-abort.diff @@ -20,57 +20,6 @@ let mut _15: u64; let mut _16: u64; let mut _17: (u64, 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 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 mut _62: u32; - let mut _63: bool; - let _64: (); - let mut _65: u64; - let mut _66: u64; - let mut _67: u32; - let mut _68: bool; bb0: { StorageLive(_2); @@ -149,249 +98,6 @@ bb8: { StorageDead(_15); StorageDead(_14); - StorageLive(_18); - StorageLive(_19); - StorageLive(_20); - _20 = _1; -- _21 = Eq(const 0_u64, const 0_u64); -- assert(!move _21, "attempt to divide `{}` by zero", _20) -> [success: bb9, unwind unreachable]; -+ _21 = const true; -+ assert(!const true, "attempt to divide `{}` by zero", _1) -> [success: bb9, unwind unreachable]; - } - - bb9: { -- _19 = Div(move _20, const 0_u64); -+ _19 = Div(_1, const 0_u64); - StorageDead(_20); - _18 = opaque::(move _19) -> [return: bb10, unwind unreachable]; - } - - bb10: { - StorageDead(_19); - StorageDead(_18); - StorageLive(_22); - StorageLive(_23); - StorageLive(_24); - _24 = _1; -- _25 = Eq(const 1_u64, const 0_u64); -- assert(!move _25, "attempt to divide `{}` by zero", _24) -> [success: bb11, unwind unreachable]; -+ _25 = const false; -+ assert(!const false, "attempt to divide `{}` by zero", _1) -> [success: bb11, unwind unreachable]; - } - - bb11: { -- _23 = Div(move _24, const 1_u64); -+ _23 = Div(_1, const 1_u64); - StorageDead(_24); - _22 = opaque::(move _23) -> [return: bb12, unwind unreachable]; - } - - bb12: { - 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 0_u64) -> [success: bb13, unwind unreachable]; -+ _29 = Eq(_1, const 0_u64); -+ assert(!_29, "attempt to divide `{}` by zero", const 0_u64) -> [success: bb13, unwind unreachable]; - } - - bb13: { -- _27 = Div(const 0_u64, move _28); -+ _27 = Div(const 0_u64, _1); - StorageDead(_28); - _26 = opaque::(move _27) -> [return: bb14, unwind unreachable]; - } - - bb14: { - StorageDead(_27); - StorageDead(_26); - StorageLive(_30); - StorageLive(_31); - StorageLive(_32); - _32 = _1; -- _33 = Eq(_32, const 0_u64); -- assert(!move _33, "attempt to divide `{}` by zero", const 1_u64) -> [success: bb15, unwind unreachable]; -+ _33 = _29; -+ assert(!_29, "attempt to divide `{}` by zero", const 1_u64) -> [success: bb15, unwind unreachable]; - } - - bb15: { -- _31 = Div(const 1_u64, move _32); -+ _31 = Div(const 1_u64, _1); - StorageDead(_32); - _30 = opaque::(move _31) -> [return: bb16, unwind unreachable]; - } - - bb16: { - StorageDead(_31); - StorageDead(_30); - StorageLive(_34); - StorageLive(_35); - StorageLive(_36); - _36 = _1; -- _37 = Eq(const 0_u64, const 0_u64); -- assert(!move _37, "attempt to calculate the remainder of `{}` with a divisor of zero", _36) -> [success: bb17, unwind unreachable]; -+ _37 = const true; -+ assert(!const true, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb17, unwind unreachable]; - } - - bb17: { -- _35 = Rem(move _36, const 0_u64); -+ _35 = Rem(_1, const 0_u64); - StorageDead(_36); - _34 = opaque::(move _35) -> [return: bb18, unwind unreachable]; - } - - bb18: { - StorageDead(_35); - StorageDead(_34); - StorageLive(_38); - StorageLive(_39); - StorageLive(_40); - _40 = _1; -- _41 = Eq(const 1_u64, const 0_u64); -- assert(!move _41, "attempt to calculate the remainder of `{}` with a divisor of zero", _40) -> [success: bb19, unwind unreachable]; -+ _41 = const false; -+ assert(!const false, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb19, unwind unreachable]; - } - - bb19: { -- _39 = Rem(move _40, const 1_u64); -+ _39 = Rem(_1, const 1_u64); - StorageDead(_40); - _38 = opaque::(move _39) -> [return: bb20, unwind unreachable]; - } - - bb20: { - 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 0_u64) -> [success: bb21, unwind unreachable]; -+ _45 = _29; -+ assert(!_29, "attempt to calculate the remainder of `{}` with a divisor of zero", const 0_u64) -> [success: bb21, unwind unreachable]; - } - - bb21: { -- _43 = Rem(const 0_u64, move _44); -+ _43 = Rem(const 0_u64, _1); - StorageDead(_44); - _42 = opaque::(move _43) -> [return: bb22, unwind unreachable]; - } - - bb22: { - StorageDead(_43); - StorageDead(_42); - StorageLive(_46); - StorageLive(_47); - StorageLive(_48); - _48 = _1; -- _49 = Eq(_48, const 0_u64); -- assert(!move _49, "attempt to calculate the remainder of `{}` with a divisor of zero", const 1_u64) -> [success: bb23, unwind unreachable]; -+ _49 = _29; -+ assert(!_29, "attempt to calculate the remainder of `{}` with a divisor of zero", const 1_u64) -> [success: bb23, unwind unreachable]; - } - - bb23: { -- _47 = Rem(const 1_u64, move _48); -+ _47 = Rem(const 1_u64, _1); - StorageDead(_48); - _46 = opaque::(move _47) -> [return: bb24, unwind unreachable]; - } - - bb24: { - StorageDead(_47); - StorageDead(_46); - StorageLive(_50); - StorageLive(_51); - StorageLive(_52); - _52 = _1; -- _51 = BitAnd(move _52, const 0_u64); -+ _51 = BitAnd(_1, const 0_u64); - StorageDead(_52); - _50 = opaque::(move _51) -> [return: bb25, unwind unreachable]; - } - - bb25: { - StorageDead(_51); - StorageDead(_50); - StorageLive(_53); - StorageLive(_54); - StorageLive(_55); - _55 = _1; -- _54 = BitOr(move _55, const 0_u64); -+ _54 = BitOr(_1, const 0_u64); - StorageDead(_55); - _53 = opaque::(move _54) -> [return: bb26, unwind unreachable]; - } - - bb26: { - StorageDead(_54); - StorageDead(_53); - StorageLive(_56); - StorageLive(_57); - StorageLive(_58); - _58 = _1; -- _57 = BitXor(move _58, const 0_u64); -+ _57 = BitXor(_1, const 0_u64); - StorageDead(_58); - _56 = opaque::(move _57) -> [return: bb27, unwind unreachable]; - } - - bb27: { - StorageDead(_57); - StorageDead(_56); - StorageLive(_59); - StorageLive(_60); - StorageLive(_61); - _61 = _1; -- _62 = const 0_i32 as u32 (IntToInt); -- _63 = Lt(move _62, const 64_u32); -- assert(move _63, "attempt to shift right by `{}`, which would overflow", const 0_i32) -> [success: bb28, unwind unreachable]; -+ _62 = const 0_u32; -+ _63 = const true; -+ assert(const true, "attempt to shift right by `{}`, which would overflow", const 0_i32) -> [success: bb28, unwind unreachable]; - } - - bb28: { -- _60 = Shr(move _61, const 0_i32); -+ _60 = Shr(_1, const 0_i32); - StorageDead(_61); - _59 = opaque::(move _60) -> [return: bb29, unwind unreachable]; - } - - bb29: { - StorageDead(_60); - StorageDead(_59); - StorageLive(_64); - StorageLive(_65); - StorageLive(_66); - _66 = _1; -- _67 = const 0_i32 as u32 (IntToInt); -- _68 = Lt(move _67, const 64_u32); -- assert(move _68, "attempt to shift left by `{}`, which would overflow", const 0_i32) -> [success: bb30, unwind unreachable]; -+ _67 = const 0_u32; -+ _68 = const true; -+ assert(const true, "attempt to shift left by `{}`, which would overflow", const 0_i32) -> [success: bb30, unwind unreachable]; - } - - bb30: { -- _65 = Shl(move _66, const 0_i32); -+ _65 = Shl(_1, const 0_i32); - StorageDead(_66); - _64 = opaque::(move _65) -> [return: bb31, unwind unreachable]; - } - - bb31: { - StorageDead(_65); - StorageDead(_64); _0 = const (); return; } diff --git a/tests/mir-opt/gvn.arithmetic_checked.GVN.panic-unwind.diff b/tests/mir-opt/gvn.arithmetic_checked.GVN.panic-unwind.diff index 9fbb8df79a1..d100a77fee5 100644 --- a/tests/mir-opt/gvn.arithmetic_checked.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn.arithmetic_checked.GVN.panic-unwind.diff @@ -20,57 +20,6 @@ let mut _15: u64; let mut _16: u64; let mut _17: (u64, 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 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 mut _62: u32; - let mut _63: bool; - let _64: (); - let mut _65: u64; - let mut _66: u64; - let mut _67: u32; - let mut _68: bool; bb0: { StorageLive(_2); @@ -149,249 +98,6 @@ bb8: { StorageDead(_15); StorageDead(_14); - StorageLive(_18); - StorageLive(_19); - StorageLive(_20); - _20 = _1; -- _21 = Eq(const 0_u64, const 0_u64); -- assert(!move _21, "attempt to divide `{}` by zero", _20) -> [success: bb9, unwind continue]; -+ _21 = const true; -+ assert(!const true, "attempt to divide `{}` by zero", _1) -> [success: bb9, unwind continue]; - } - - bb9: { -- _19 = Div(move _20, const 0_u64); -+ _19 = Div(_1, const 0_u64); - StorageDead(_20); - _18 = opaque::(move _19) -> [return: bb10, unwind continue]; - } - - bb10: { - StorageDead(_19); - StorageDead(_18); - StorageLive(_22); - StorageLive(_23); - StorageLive(_24); - _24 = _1; -- _25 = Eq(const 1_u64, const 0_u64); -- assert(!move _25, "attempt to divide `{}` by zero", _24) -> [success: bb11, unwind continue]; -+ _25 = const false; -+ assert(!const false, "attempt to divide `{}` by zero", _1) -> [success: bb11, unwind continue]; - } - - bb11: { -- _23 = Div(move _24, const 1_u64); -+ _23 = Div(_1, const 1_u64); - StorageDead(_24); - _22 = opaque::(move _23) -> [return: bb12, unwind continue]; - } - - bb12: { - 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 0_u64) -> [success: bb13, unwind continue]; -+ _29 = Eq(_1, const 0_u64); -+ assert(!_29, "attempt to divide `{}` by zero", const 0_u64) -> [success: bb13, unwind continue]; - } - - bb13: { -- _27 = Div(const 0_u64, move _28); -+ _27 = Div(const 0_u64, _1); - StorageDead(_28); - _26 = opaque::(move _27) -> [return: bb14, unwind continue]; - } - - bb14: { - StorageDead(_27); - StorageDead(_26); - StorageLive(_30); - StorageLive(_31); - StorageLive(_32); - _32 = _1; -- _33 = Eq(_32, const 0_u64); -- assert(!move _33, "attempt to divide `{}` by zero", const 1_u64) -> [success: bb15, unwind continue]; -+ _33 = _29; -+ assert(!_29, "attempt to divide `{}` by zero", const 1_u64) -> [success: bb15, unwind continue]; - } - - bb15: { -- _31 = Div(const 1_u64, move _32); -+ _31 = Div(const 1_u64, _1); - StorageDead(_32); - _30 = opaque::(move _31) -> [return: bb16, unwind continue]; - } - - bb16: { - StorageDead(_31); - StorageDead(_30); - StorageLive(_34); - StorageLive(_35); - StorageLive(_36); - _36 = _1; -- _37 = Eq(const 0_u64, const 0_u64); -- assert(!move _37, "attempt to calculate the remainder of `{}` with a divisor of zero", _36) -> [success: bb17, unwind continue]; -+ _37 = const true; -+ assert(!const true, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb17, unwind continue]; - } - - bb17: { -- _35 = Rem(move _36, const 0_u64); -+ _35 = Rem(_1, const 0_u64); - StorageDead(_36); - _34 = opaque::(move _35) -> [return: bb18, unwind continue]; - } - - bb18: { - StorageDead(_35); - StorageDead(_34); - StorageLive(_38); - StorageLive(_39); - StorageLive(_40); - _40 = _1; -- _41 = Eq(const 1_u64, const 0_u64); -- assert(!move _41, "attempt to calculate the remainder of `{}` with a divisor of zero", _40) -> [success: bb19, unwind continue]; -+ _41 = const false; -+ assert(!const false, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb19, unwind continue]; - } - - bb19: { -- _39 = Rem(move _40, const 1_u64); -+ _39 = Rem(_1, const 1_u64); - StorageDead(_40); - _38 = opaque::(move _39) -> [return: bb20, unwind continue]; - } - - bb20: { - 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 0_u64) -> [success: bb21, unwind continue]; -+ _45 = _29; -+ assert(!_29, "attempt to calculate the remainder of `{}` with a divisor of zero", const 0_u64) -> [success: bb21, unwind continue]; - } - - bb21: { -- _43 = Rem(const 0_u64, move _44); -+ _43 = Rem(const 0_u64, _1); - StorageDead(_44); - _42 = opaque::(move _43) -> [return: bb22, unwind continue]; - } - - bb22: { - StorageDead(_43); - StorageDead(_42); - StorageLive(_46); - StorageLive(_47); - StorageLive(_48); - _48 = _1; -- _49 = Eq(_48, const 0_u64); -- assert(!move _49, "attempt to calculate the remainder of `{}` with a divisor of zero", const 1_u64) -> [success: bb23, unwind continue]; -+ _49 = _29; -+ assert(!_29, "attempt to calculate the remainder of `{}` with a divisor of zero", const 1_u64) -> [success: bb23, unwind continue]; - } - - bb23: { -- _47 = Rem(const 1_u64, move _48); -+ _47 = Rem(const 1_u64, _1); - StorageDead(_48); - _46 = opaque::(move _47) -> [return: bb24, unwind continue]; - } - - bb24: { - StorageDead(_47); - StorageDead(_46); - StorageLive(_50); - StorageLive(_51); - StorageLive(_52); - _52 = _1; -- _51 = BitAnd(move _52, const 0_u64); -+ _51 = BitAnd(_1, const 0_u64); - StorageDead(_52); - _50 = opaque::(move _51) -> [return: bb25, unwind continue]; - } - - bb25: { - StorageDead(_51); - StorageDead(_50); - StorageLive(_53); - StorageLive(_54); - StorageLive(_55); - _55 = _1; -- _54 = BitOr(move _55, const 0_u64); -+ _54 = BitOr(_1, const 0_u64); - StorageDead(_55); - _53 = opaque::(move _54) -> [return: bb26, unwind continue]; - } - - bb26: { - StorageDead(_54); - StorageDead(_53); - StorageLive(_56); - StorageLive(_57); - StorageLive(_58); - _58 = _1; -- _57 = BitXor(move _58, const 0_u64); -+ _57 = BitXor(_1, const 0_u64); - StorageDead(_58); - _56 = opaque::(move _57) -> [return: bb27, unwind continue]; - } - - bb27: { - StorageDead(_57); - StorageDead(_56); - StorageLive(_59); - StorageLive(_60); - StorageLive(_61); - _61 = _1; -- _62 = const 0_i32 as u32 (IntToInt); -- _63 = Lt(move _62, const 64_u32); -- assert(move _63, "attempt to shift right by `{}`, which would overflow", const 0_i32) -> [success: bb28, unwind continue]; -+ _62 = const 0_u32; -+ _63 = const true; -+ assert(const true, "attempt to shift right by `{}`, which would overflow", const 0_i32) -> [success: bb28, unwind continue]; - } - - bb28: { -- _60 = Shr(move _61, const 0_i32); -+ _60 = Shr(_1, const 0_i32); - StorageDead(_61); - _59 = opaque::(move _60) -> [return: bb29, unwind continue]; - } - - bb29: { - StorageDead(_60); - StorageDead(_59); - StorageLive(_64); - StorageLive(_65); - StorageLive(_66); - _66 = _1; -- _67 = const 0_i32 as u32 (IntToInt); -- _68 = Lt(move _67, const 64_u32); -- assert(move _68, "attempt to shift left by `{}`, which would overflow", const 0_i32) -> [success: bb30, unwind continue]; -+ _67 = const 0_u32; -+ _68 = const true; -+ assert(const true, "attempt to shift left by `{}`, which would overflow", const 0_i32) -> [success: bb30, unwind continue]; - } - - bb30: { -- _65 = Shl(move _66, const 0_i32); -+ _65 = Shl(_1, const 0_i32); - StorageDead(_66); - _64 = opaque::(move _65) -> [return: bb31, unwind continue]; - } - - bb31: { - StorageDead(_65); - StorageDead(_64); _0 = const (); return; } diff --git a/tests/mir-opt/gvn.comparison.GVN.panic-abort.diff b/tests/mir-opt/gvn.comparison.GVN.panic-abort.diff new file mode 100644 index 00000000000..ee3b9da2122 --- /dev/null +++ b/tests/mir-opt/gvn.comparison.GVN.panic-abort.diff @@ -0,0 +1,94 @@ +- // MIR for `comparison` before GVN ++ // MIR for `comparison` after GVN + + fn comparison(_1: u64, _2: u64) -> () { + debug x => _1; + debug y => _2; + let mut _0: (); + let _3: (); + let mut _4: bool; + let mut _5: u64; + let mut _6: u64; + let _7: (); + let mut _8: bool; + let mut _9: u64; + let mut _10: u64; + let _11: (); + let mut _12: bool; + let mut _13: u64; + let mut _14: u64; + let _15: (); + let mut _16: bool; + let mut _17: u64; + let mut _18: u64; + + bb0: { + StorageLive(_3); + StorageLive(_4); + StorageLive(_5); + _5 = _1; + StorageLive(_6); + _6 = _1; +- _4 = Eq(move _5, move _6); ++ _4 = Eq(_1, _1); + StorageDead(_6); + StorageDead(_5); + _3 = opaque::(move _4) -> [return: bb1, unwind unreachable]; + } + + bb1: { + StorageDead(_4); + StorageDead(_3); + StorageLive(_7); + StorageLive(_8); + StorageLive(_9); + _9 = _1; + StorageLive(_10); + _10 = _1; +- _8 = Ne(move _9, move _10); ++ _8 = Ne(_1, _1); + StorageDead(_10); + StorageDead(_9); + _7 = opaque::(move _8) -> [return: bb2, unwind unreachable]; + } + + bb2: { + StorageDead(_8); + StorageDead(_7); + StorageLive(_11); + StorageLive(_12); + StorageLive(_13); + _13 = _1; + StorageLive(_14); + _14 = _2; +- _12 = Eq(move _13, move _14); ++ _12 = Eq(_1, _2); + StorageDead(_14); + StorageDead(_13); + _11 = opaque::(move _12) -> [return: bb3, unwind unreachable]; + } + + bb3: { + StorageDead(_12); + StorageDead(_11); + StorageLive(_15); + StorageLive(_16); + StorageLive(_17); + _17 = _1; + StorageLive(_18); + _18 = _2; +- _16 = Ne(move _17, move _18); ++ _16 = Ne(_1, _2); + StorageDead(_18); + StorageDead(_17); + _15 = opaque::(move _16) -> [return: bb4, unwind unreachable]; + } + + bb4: { + StorageDead(_16); + StorageDead(_15); + _0 = const (); + return; + } + } + diff --git a/tests/mir-opt/gvn.comparison.GVN.panic-unwind.diff b/tests/mir-opt/gvn.comparison.GVN.panic-unwind.diff new file mode 100644 index 00000000000..a1408fe3434 --- /dev/null +++ b/tests/mir-opt/gvn.comparison.GVN.panic-unwind.diff @@ -0,0 +1,94 @@ +- // MIR for `comparison` before GVN ++ // MIR for `comparison` after GVN + + fn comparison(_1: u64, _2: u64) -> () { + debug x => _1; + debug y => _2; + let mut _0: (); + let _3: (); + let mut _4: bool; + let mut _5: u64; + let mut _6: u64; + let _7: (); + let mut _8: bool; + let mut _9: u64; + let mut _10: u64; + let _11: (); + let mut _12: bool; + let mut _13: u64; + let mut _14: u64; + let _15: (); + let mut _16: bool; + let mut _17: u64; + let mut _18: u64; + + bb0: { + StorageLive(_3); + StorageLive(_4); + StorageLive(_5); + _5 = _1; + StorageLive(_6); + _6 = _1; +- _4 = Eq(move _5, move _6); ++ _4 = Eq(_1, _1); + StorageDead(_6); + StorageDead(_5); + _3 = opaque::(move _4) -> [return: bb1, unwind continue]; + } + + bb1: { + StorageDead(_4); + StorageDead(_3); + StorageLive(_7); + StorageLive(_8); + StorageLive(_9); + _9 = _1; + StorageLive(_10); + _10 = _1; +- _8 = Ne(move _9, move _10); ++ _8 = Ne(_1, _1); + StorageDead(_10); + StorageDead(_9); + _7 = opaque::(move _8) -> [return: bb2, unwind continue]; + } + + bb2: { + StorageDead(_8); + StorageDead(_7); + StorageLive(_11); + StorageLive(_12); + StorageLive(_13); + _13 = _1; + StorageLive(_14); + _14 = _2; +- _12 = Eq(move _13, move _14); ++ _12 = Eq(_1, _2); + StorageDead(_14); + StorageDead(_13); + _11 = opaque::(move _12) -> [return: bb3, unwind continue]; + } + + bb3: { + StorageDead(_12); + StorageDead(_11); + StorageLive(_15); + StorageLive(_16); + StorageLive(_17); + _17 = _1; + StorageLive(_18); + _18 = _2; +- _16 = Ne(move _17, move _18); ++ _16 = Ne(_1, _2); + StorageDead(_18); + StorageDead(_17); + _15 = opaque::(move _16) -> [return: bb4, unwind continue]; + } + + bb4: { + StorageDead(_16); + StorageDead(_15); + _0 = const (); + return; + } + } + diff --git a/tests/mir-opt/gvn.repeat.GVN.panic-abort.diff b/tests/mir-opt/gvn.repeat.GVN.panic-abort.diff new file mode 100644 index 00000000000..37915f8578d --- /dev/null +++ b/tests/mir-opt/gvn.repeat.GVN.panic-abort.diff @@ -0,0 +1,79 @@ +- // MIR for `repeat` before GVN ++ // MIR for `repeat` after GVN + + fn repeat() -> () { + let mut _0: (); + let _1: i32; + let mut _3: i32; + let mut _4: i32; + let mut _5: i32; + let mut _6: i32; + let mut _7: i32; + let mut _8: i32; + let mut _9: i32; + let mut _10: i32; + let mut _11: i32; + let mut _12: i32; + scope 1 { + debug val => _1; + let _2: [i32; 10]; + scope 2 { + debug array => _2; + } + } + + bb0: { +- StorageLive(_1); ++ nop; + _1 = const 5_i32; + StorageLive(_2); + StorageLive(_3); +- _3 = _1; ++ _3 = const 5_i32; + StorageLive(_4); +- _4 = _1; ++ _4 = const 5_i32; + StorageLive(_5); +- _5 = _1; ++ _5 = const 5_i32; + StorageLive(_6); +- _6 = _1; ++ _6 = const 5_i32; + StorageLive(_7); +- _7 = _1; ++ _7 = const 5_i32; + StorageLive(_8); +- _8 = _1; ++ _8 = const 5_i32; + StorageLive(_9); +- _9 = _1; ++ _9 = const 5_i32; + StorageLive(_10); +- _10 = _1; ++ _10 = const 5_i32; + StorageLive(_11); +- _11 = _1; ++ _11 = const 5_i32; + StorageLive(_12); +- _12 = _1; +- _2 = [move _3, move _4, move _5, move _6, move _7, move _8, move _9, move _10, move _11, move _12]; ++ _12 = const 5_i32; ++ _2 = [const 5_i32; 10]; + StorageDead(_12); + StorageDead(_11); + StorageDead(_10); + StorageDead(_9); + StorageDead(_8); + StorageDead(_7); + StorageDead(_6); + StorageDead(_5); + StorageDead(_4); + StorageDead(_3); + _0 = const (); + StorageDead(_2); +- StorageDead(_1); ++ nop; + return; + } + } + diff --git a/tests/mir-opt/gvn.repeat.GVN.panic-unwind.diff b/tests/mir-opt/gvn.repeat.GVN.panic-unwind.diff new file mode 100644 index 00000000000..37915f8578d --- /dev/null +++ b/tests/mir-opt/gvn.repeat.GVN.panic-unwind.diff @@ -0,0 +1,79 @@ +- // MIR for `repeat` before GVN ++ // MIR for `repeat` after GVN + + fn repeat() -> () { + let mut _0: (); + let _1: i32; + let mut _3: i32; + let mut _4: i32; + let mut _5: i32; + let mut _6: i32; + let mut _7: i32; + let mut _8: i32; + let mut _9: i32; + let mut _10: i32; + let mut _11: i32; + let mut _12: i32; + scope 1 { + debug val => _1; + let _2: [i32; 10]; + scope 2 { + debug array => _2; + } + } + + bb0: { +- StorageLive(_1); ++ nop; + _1 = const 5_i32; + StorageLive(_2); + StorageLive(_3); +- _3 = _1; ++ _3 = const 5_i32; + StorageLive(_4); +- _4 = _1; ++ _4 = const 5_i32; + StorageLive(_5); +- _5 = _1; ++ _5 = const 5_i32; + StorageLive(_6); +- _6 = _1; ++ _6 = const 5_i32; + StorageLive(_7); +- _7 = _1; ++ _7 = const 5_i32; + StorageLive(_8); +- _8 = _1; ++ _8 = const 5_i32; + StorageLive(_9); +- _9 = _1; ++ _9 = const 5_i32; + StorageLive(_10); +- _10 = _1; ++ _10 = const 5_i32; + StorageLive(_11); +- _11 = _1; ++ _11 = const 5_i32; + StorageLive(_12); +- _12 = _1; +- _2 = [move _3, move _4, move _5, move _6, move _7, move _8, move _9, move _10, move _11, move _12]; ++ _12 = const 5_i32; ++ _2 = [const 5_i32; 10]; + StorageDead(_12); + StorageDead(_11); + StorageDead(_10); + StorageDead(_9); + StorageDead(_8); + StorageDead(_7); + StorageDead(_6); + StorageDead(_5); + StorageDead(_4); + StorageDead(_3); + _0 = const (); + StorageDead(_2); +- StorageDead(_1); ++ nop; + return; + } + } + diff --git a/tests/mir-opt/gvn.rs b/tests/mir-opt/gvn.rs index 55de186edf1..1c14f818044 100644 --- a/tests/mir-opt/gvn.rs +++ b/tests/mir-opt/gvn.rs @@ -1,4 +1,3 @@ -// skip-filecheck // unit-test: GVN // EMIT_MIR_FOR_EACH_PANIC_STRATEGY // only-64bit @@ -15,48 +14,120 @@ use std::mem::transmute; struct S(T); fn subexpression_elimination(x: u64, y: u64, mut z: u64) { + // CHECK-LABEL: fn subexpression_elimination( + + // CHECK: [[add:_.*]] = Add(_1, _2); + // CHECK: opaque::([[add]]) opaque(x + y); + // CHECK: [[mul:_.*]] = Mul(_1, _2); + // CHECK: opaque::([[mul]]) opaque(x * y); + // CHECK: [[sub:_.*]] = Sub(_1, _2); + // CHECK: opaque::([[sub]]) opaque(x - y); + // CHECK: [[div:_.*]] = Div(_1, _2); + // CHECK: opaque::([[div]]) opaque(x / y); + // CHECK: [[rem:_.*]] = Rem(_1, _2); + // CHECK: opaque::([[rem]]) opaque(x % y); + // CHECK: [[and:_.*]] = BitAnd(_1, _2); + // CHECK: opaque::([[and]]) opaque(x & y); + // CHECK: [[or:_.*]] = BitOr(_1, _2); + // CHECK: opaque::([[or]]) opaque(x | y); + // CHECK: [[xor:_.*]] = BitXor(_1, _2); + // CHECK: opaque::([[xor]]) opaque(x ^ y); + // CHECK: [[shl:_.*]] = Shl(_1, _2); + // CHECK: opaque::([[shl]]) opaque(x << y); + // CHECK: [[shr:_.*]] = Shr(_1, _2); + // CHECK: opaque::([[shr]]) opaque(x >> y); + // CHECK: [[int:_.*]] = _1 as u32 (IntToInt); + // CHECK: opaque::([[int]]) opaque(x as u32); + // CHECK: [[float:_.*]] = _1 as f32 (IntToFloat); + // CHECK: opaque::([[float]]) opaque(x as f32); + // CHECK: [[wrap:_.*]] = S::(_1); + // CHECK: opaque::>([[wrap]]) opaque(S(x)); + // CHECK: opaque::(_1) opaque(S(x).0); // Those are duplicates to substitute somehow. - opaque((x + y) + z); - opaque((x * y) + z); - opaque((x - y) + z); - opaque((x / y) + z); - opaque((x % y) + z); - opaque((x & y) + z); - opaque((x | y) + z); - opaque((x ^ y) + z); - opaque((x << y) + z); - opaque((x >> y) + z); + // CHECK: opaque::([[add]]) + opaque(x + y); + // CHECK: opaque::([[mul]]) + opaque(x * y); + // CHECK: opaque::([[sub]]) + opaque(x - y); + // CHECK: opaque::([[div]]) + opaque(x / y); + // CHECK: opaque::([[rem]]) + opaque(x % y); + // CHECK: opaque::([[and]]) + opaque(x & y); + // CHECK: opaque::([[or]]) + opaque(x | y); + // CHECK: opaque::([[xor]]) + opaque(x ^ y); + // CHECK: opaque::([[shl]]) + opaque(x << y); + // CHECK: opaque::([[shr]]) + opaque(x >> y); + // CHECK: opaque::([[int]]) + opaque(x as u32); + // CHECK: opaque::([[float]]) + opaque(x as f32); + // CHECK: opaque::>([[wrap]]) opaque(S(x)); + // CHECK: opaque::(_1) opaque(S(x).0); + // We can substitute through a complex expression. + // CHECK: [[compound:_.*]] = Sub([[mul]], _2); + // CHECK: opaque::([[compound]]) + // CHECK: opaque::([[compound]]) + opaque((x * y) - y); + opaque((x * y) - y); + // We can substitute through an immutable reference too. + // CHECK: [[ref:_.*]] = &_3; + // CHECK: [[deref:_.*]] = (*[[ref]]); + // CHECK: [[addref:_.*]] = Add([[deref]], _1); + // CHECK: opaque::([[addref]]) + // CHECK: opaque::([[addref]]) let a = &z; opaque(*a + x); opaque(*a + x); // But not through a mutable reference or a pointer. + // CHECK: [[mut:_.*]] = &mut _3; + // CHECK: [[addmut:_.*]] = Add( + // CHECK: opaque::(move [[addmut]]) + // CHECK: [[addmut2:_.*]] = Add( + // CHECK: opaque::(move [[addmut2]]) let b = &mut z; opaque(*b + x); opaque(*b + x); unsafe { + // CHECK: [[raw:_.*]] = &raw const _3; + // CHECK: [[addraw:_.*]] = Add( + // CHECK: opaque::(move [[addraw]]) + // CHECK: [[addraw2:_.*]] = Add( + // CHECK: opaque::(move [[addraw2]]) let c = &raw const z; opaque(*c + x); opaque(*c + x); + // CHECK: [[ptr:_.*]] = &raw mut _3; + // CHECK: [[addptr:_.*]] = Add( + // CHECK: opaque::(move [[addptr]]) + // CHECK: [[addptr2:_.*]] = Add( + // CHECK: opaque::(move [[addptr2]]) let d = &raw mut z; opaque(*d + x); opaque(*d + x); @@ -64,12 +135,21 @@ fn subexpression_elimination(x: u64, y: u64, mut z: u64) { // We can substitute again, but not with the earlier computations. // Important: `e` is not `a`! + // CHECK: [[ref2:_.*]] = &_3; + // CHECK: [[deref2:_.*]] = (*[[ref2]]); + // CHECK: [[addref2:_.*]] = Add([[deref2]], _1); + // CHECK: opaque::([[addref2]]) + // CHECK: opaque::([[addref2]]) let e = &z; opaque(*e + x); opaque(*e + x); } fn wrap_unwrap(x: T) -> T { + // CHECK-LABEL: fn wrap_unwrap( + // CHECK: [[some:_.*]] = Option::::Some(_1); + // CHECK: switchInt(const 1_isize) + // CHECK: _0 = _1; match Some(x) { Some(y) => y, None => panic!(), @@ -77,155 +157,354 @@ fn wrap_unwrap(x: T) -> T { } fn repeated_index(x: T, idx: usize) { + // CHECK-LABEL: fn repeated_index( + // CHECK: [[a:_.*]] = [_1; N]; let a = [x; N]; + // CHECK: opaque::(_1) opaque(a[0]); + // CHECK: opaque::(_1) opaque(a[idx]); } +/// Verify symbolic integer arithmetic simplifications. fn arithmetic(x: u64) { + // CHECK-LABEL: fn arithmetic( + // CHECK: [[add:_.*]] = Add(_1, const 0_u64); + // CHECK: opaque::(move [[add]]) opaque(x + 0); + // CHECK: [[sub:_.*]] = Sub(_1, const 0_u64); + // CHECK: opaque::(move [[sub]]) opaque(x - 0); + // CHECK: [[mul0:_.*]] = Mul(_1, const 0_u64); + // CHECK: opaque::(move [[mul0]]) opaque(x * 0); + // CHECK: [[mul1:_.*]] = Mul(_1, const 1_u64); + // CHECK: opaque::(move [[mul1]]) opaque(x * 1); + // CHECK: [[div0:_.*]] = Div(_1, const 0_u64); + // CHECK: opaque::(move [[div0]]) opaque(x / 0); + // CHECK: [[div1:_.*]] = Div(_1, const 1_u64); + // CHECK: opaque::(move [[div1]]) opaque(x / 1); + // CHECK: [[zdiv:_.*]] = Div(const 0_u64, _1); + // CHECK: opaque::(move [[zdiv]]) opaque(0 / x); + // CHECK: [[odiv:_.*]] = Div(const 1_u64, _1); + // CHECK: opaque::(move [[odiv]]) opaque(1 / x); + // CHECK: [[rem0:_.*]] = Rem(_1, const 0_u64); + // CHECK: opaque::(move [[rem0]]) opaque(x % 0); + // CHECK: [[rem1:_.*]] = Rem(_1, const 1_u64); + // CHECK: opaque::(move [[rem1]]) opaque(x % 1); + // CHECK: [[zrem:_.*]] = Rem(const 0_u64, _1); + // CHECK: opaque::(move [[zrem]]) opaque(0 % x); + // CHECK: [[orem:_.*]] = Rem(const 1_u64, _1); + // CHECK: opaque::(move [[orem]]) opaque(1 % x); + // CHECK: [[and:_.*]] = BitAnd(_1, const 0_u64); + // CHECK: opaque::(move [[and]]) opaque(x & 0); + // CHECK: [[or:_.*]] = BitOr(_1, const 0_u64); + // CHECK: opaque::(move [[or]]) opaque(x | 0); + // CHECK: [[xor:_.*]] = BitXor(_1, const 0_u64); + // CHECK: opaque::(move [[xor]]) opaque(x ^ 0); + // CHECK: [[shr:_.*]] = Shr(_1, const 0_i32); + // CHECK: opaque::(move [[shr]]) opaque(x >> 0); + // CHECK: [[shl:_.*]] = Shl(_1, const 0_i32); + // CHECK: opaque::(move [[shl]]) opaque(x << 0); } +fn comparison(x: u64, y: u64) { + // CHECK-LABEL: fn comparison( + // CHECK: [[eqxx:_.*]] = Eq(_1, _1); + // CHECK: opaque::(move [[eqxx]]) + opaque(x == x); + // CHECK: [[nexx:_.*]] = Ne(_1, _1); + // CHECK: opaque::(move [[nexx]]) + opaque(x != x); + // CHECK: [[eqxy:_.*]] = Eq(_1, _2); + // CHECK: opaque::(move [[eqxy]]) + opaque(x == y); + // CHECK: [[nexy:_.*]] = Ne(_1, _2); + // CHECK: opaque::(move [[nexy]]) + opaque(x != y); +} + +/// Verify symbolic integer arithmetic simplifications on checked ops. #[rustc_inherit_overflow_checks] fn arithmetic_checked(x: u64) { + // CHECK-LABEL: fn arithmetic_checked( + // CHECK: [[cadd:_.*]] = CheckedAdd(_1, const 0_u64); + // CHECK: [[add:_.*]] = move ([[cadd]].0: u64); + // CHECK: opaque::(move [[add]]) opaque(x + 0); + // CHECK: [[csub:_.*]] = CheckedSub(_1, const 0_u64); + // CHECK: [[sub:_.*]] = move ([[csub]].0: u64); + // CHECK: opaque::(move [[sub]]) opaque(x - 0); + // CHECK: [[cmul0:_.*]] = CheckedMul(_1, const 0_u64); + // CHECK: [[mul0:_.*]] = move ([[cmul0]].0: u64); + // CHECK: opaque::(move [[mul0]]) opaque(x * 0); + // CHECK: [[cmul1:_.*]] = CheckedMul(_1, const 1_u64); + // CHECK: [[mul1:_.*]] = move ([[cmul1]].0: u64); + // CHECK: opaque::(move [[mul1]]) opaque(x * 1); - opaque(x / 0); - opaque(x / 1); - opaque(0 / x); - opaque(1 / x); - opaque(x % 0); - opaque(x % 1); - opaque(0 % x); - opaque(1 % x); - opaque(x & 0); - opaque(x | 0); - opaque(x ^ 0); - opaque(x >> 0); - opaque(x << 0); } +/// Verify that we do not apply arithmetic simplifications on floats. fn arithmetic_float(x: f64) { + // CHECK-LABEL: fn arithmetic_float( + // CHECK: [[add:_.*]] = Add(_1, const 0f64); + // CHECK: opaque::(move [[add]]) opaque(x + 0.); + // CHECK: [[sub:_.*]] = Sub(_1, const 0f64); + // CHECK: opaque::(move [[sub]]) opaque(x - 0.); + // CHECK: [[mul:_.*]] = Mul(_1, const 0f64); + // CHECK: opaque::(move [[mul]]) opaque(x * 0.); + // CHECK: [[div0:_.*]] = Div(_1, const 0f64); + // CHECK: opaque::(move [[div0]]) opaque(x / 0.); + // CHECK: [[zdiv:_.*]] = Div(const 0f64, _1); + // CHECK: opaque::(move [[zdiv]]) opaque(0. / x); + // CHECK: [[rem0:_.*]] = Rem(_1, const 0f64); + // CHECK: opaque::(move [[rem0]]) opaque(x % 0.); + // CHECK: [[zrem:_.*]] = Rem(const 0f64, _1); + // CHECK: opaque::(move [[zrem]]) opaque(0. % x); // Those are not simplifiable to `true`/`false`, thanks to NaNs. + // CHECK: [[eq:_.*]] = Eq(_1, _1); + // CHECK: opaque::(move [[eq]]) opaque(x == x); + // CHECK: [[ne:_.*]] = Ne(_1, _1); + // CHECK: opaque::(move [[ne]]) opaque(x != x); } fn cast() { + // CHECK-LABEL: fn cast( let i = 1_i64; let u = 1_u64; let f = 1_f64; + // CHECK: opaque::(const 1_u8) opaque(i as u8); + // CHECK: opaque::(const 1_u16) opaque(i as u16); + // CHECK: opaque::(const 1_u32) opaque(i as u32); + // CHECK: opaque::(const 1_u64) opaque(i as u64); + // CHECK: opaque::(const 1_i8) opaque(i as i8); + // CHECK: opaque::(const 1_i16) opaque(i as i16); + // CHECK: opaque::(const 1_i32) opaque(i as i32); + // CHECK: opaque::(const 1_i64) opaque(i as i64); + // CHECK: opaque::(const 1f32) opaque(i as f32); + // CHECK: opaque::(const 1f64) opaque(i as f64); + // CHECK: opaque::(const 1_u8) opaque(u as u8); + // CHECK: opaque::(const 1_u16) opaque(u as u16); + // CHECK: opaque::(const 1_u32) opaque(u as u32); + // CHECK: opaque::(const 1_u64) opaque(u as u64); + // CHECK: opaque::(const 1_i8) opaque(u as i8); + // CHECK: opaque::(const 1_i16) opaque(u as i16); + // CHECK: opaque::(const 1_i32) opaque(u as i32); + // CHECK: opaque::(const 1_i64) opaque(u as i64); + // CHECK: opaque::(const 1f32) opaque(u as f32); + // CHECK: opaque::(const 1f64) opaque(u as f64); + // CHECK: opaque::(const 1_u8) opaque(f as u8); + // CHECK: opaque::(const 1_u16) opaque(f as u16); + // CHECK: opaque::(const 1_u32) opaque(f as u32); + // CHECK: opaque::(const 1_u64) opaque(f as u64); + // CHECK: opaque::(const 1_i8) opaque(f as i8); + // CHECK: opaque::(const 1_i16) opaque(f as i16); + // CHECK: opaque::(const 1_i32) opaque(f as i32); + // CHECK: opaque::(const 1_i64) opaque(f as i64); + // CHECK: opaque::(const 1f32) opaque(f as f32); + // CHECK: opaque::(const 1f64) opaque(f as f64); } fn multiple_branches(t: bool, x: u8, y: u8) { + // CHECK-LABEL: fn multiple_branches( + // CHECK: switchInt(_1) -> [0: [[bbf:bb.*]], otherwise: [[bbt:bb.*]]]; if t { - opaque(x + y); // a - opaque(x + y); // should reuse a + // CHECK: [[bbt]]: { + // CHECK: [[a:_.*]] = Add(_2, _3); + // CHECK: opaque::([[a]]) + // CHECK: opaque::([[a]]) + // CHECK: goto -> [[bbc:bb.*]]; + opaque(x + y); + opaque(x + y); } else { - opaque(x + y); // b - opaque(x + y); // shoud reuse b + // CHECK: [[bbf]]: { + // CHECK: [[b:_.*]] = Add(_2, _3); + // CHECK: opaque::([[b]]) + // CHECK: opaque::([[b]]) + // CHECK: goto -> [[bbc:bb.*]]; + opaque(x + y); + opaque(x + y); } - opaque(x + y); // c + // Neither `a` nor `b` dominate `c`, so we cannot reuse any of them. + // CHECK: [[bbc]]: { + // CHECK: [[c:_.*]] = Add(_2, _3); + // CHECK: opaque::([[c]]) + opaque(x + y); + + // `c` dominates both calls, so we can reuse it. if t { - opaque(x + y); // should reuse c + // CHECK: opaque::([[c]]) + opaque(x + y); } else { - opaque(x + y); // should reuse c + // CHECK: opaque::([[c]]) + opaque(x + y); } } +/// Verify that we do not reuse a `&raw? mut?` rvalue. fn references(mut x: impl Sized) { + // CHECK-LABEL: fn references( + // CHECK: [[ref1:_.*]] = &_1; + // CHECK: opaque::<&impl Sized>(move [[ref1]]) opaque(&x); - opaque(&x); // should not reuse a + // CHECK: [[ref2:_.*]] = &_1; + // CHECK: opaque::<&impl Sized>(move [[ref2]]) + opaque(&x); + // CHECK: [[ref3:_.*]] = &mut _1; + // CHECK: opaque::<&mut impl Sized>(move [[ref3]]) opaque(&mut x); - opaque(&mut x); // should not reuse a + // CHECK: [[ref4:_.*]] = &mut _1; + // CHECK: opaque::<&mut impl Sized>(move [[ref4]]) + opaque(&mut x); + // CHECK: [[ref5:_.*]] = &raw const _1; + // CHECK: opaque::<*const impl Sized>(move [[ref5]]) opaque(&raw const x); - opaque(&raw const x); // should not reuse a + // CHECK: [[ref6:_.*]] = &raw const _1; + // CHECK: opaque::<*const impl Sized>(move [[ref6]]) + opaque(&raw const x); + // CHECK: [[ref7:_.*]] = &raw mut _1; + // CHECK: opaque::<*mut impl Sized>(move [[ref7]]) + opaque(&raw mut x); + // CHECK: [[ref8:_.*]] = &raw mut _1; + // CHECK: opaque::<*mut impl Sized>(move [[ref8]]) opaque(&raw mut x); - opaque(&raw mut x); // should not reuse a let r = &mut x; - let s = S(r).0; // Obfuscate `r`. - opaque(&*s); // This is `&*r`. - opaque(&mut *s); // This is `&*r`. - opaque(&raw const *s); // This is `&*r`. - opaque(&raw mut *s); // This is `&*r`. + let s = S(r).0; // Obfuscate `r`. Following lines should still reborrow `r`. + // CHECK: [[ref9:_.*]] = &mut _1; + // CHECK: [[ref10:_.*]] = &(*[[ref9]]); + // CHECK: opaque::<&impl Sized>(move [[ref10]]) + opaque(&*s); + // CHECK: [[ref11:_.*]] = &mut (*[[ref9]]); + // CHECK: opaque::<&mut impl Sized>(move [[ref11]]) + opaque(&mut *s); + // CHECK: [[ref12:_.*]] = &raw const (*[[ref9]]); + // CHECK: opaque::<*const impl Sized>(move [[ref12]]) + opaque(&raw const *s); + // CHECK: [[ref12:_.*]] = &raw mut (*[[ref9]]); + // CHECK: opaque::<*mut impl Sized>(move [[ref12]]) + opaque(&raw mut *s); } fn dereferences(t: &mut u32, u: &impl Copy, s: &S) { + // CHECK-LABEL: fn dereferences( + + // Do not reuse dereferences of `&mut`. + // CHECK: [[st1:_.*]] = (*_1); + // CHECK: opaque::(move [[st1]]) + // CHECK: [[st2:_.*]] = (*_1); + // CHECK: opaque::(move [[st2]]) opaque(*t); - opaque(*t); // this cannot reuse a, as x is &mut. + opaque(*t); + + // Do not reuse dereferences of `*const`. + // CHECK: [[raw:_.*]] = &raw const (*_1); + // CHECK: [[st3:_.*]] = (*[[raw]]); + // CHECK: opaque::(move [[st3]]) + // CHECK: [[st4:_.*]] = (*[[raw]]); + // CHECK: opaque::(move [[st4]]) let z = &raw const *t; unsafe { opaque(*z) }; - unsafe { opaque(*z) }; // this cannot reuse a, as x is *const. + unsafe { opaque(*z) }; + + // Do not reuse dereferences of `*mut`. + // CHECK: [[ptr:_.*]] = &raw mut (*_1); + // CHECK: [[st5:_.*]] = (*[[ptr]]); + // CHECK: opaque::(move [[st5]]) + // CHECK: [[st6:_.*]] = (*[[ptr]]); + // CHECK: opaque::(move [[st6]]) let z = &raw mut *t; unsafe { opaque(*z) }; - unsafe { opaque(*z) }; // this cannot reuse a, as x is *mut. + unsafe { opaque(*z) }; + + // We can reuse dereferences of `&Freeze`. + // CHECK: [[ref:_.*]] = &(*_1); + // CHECK: [[st7:_.*]] = (*[[ref]]); + // CHECK: opaque::([[st7]]) + // CHECK: opaque::([[st7]]) let z = &*t; opaque(*z); - opaque(*z); // this can reuse, as `z` is immutable ref, Freeze and Copy. - opaque(&*z); // but not for a reborrow. + opaque(*z); + // But not in reborrows. + // CHECK: [[reborrow:_.*]] = &(*[[ref]]); + // CHECK: opaque::<&u32>(move [[reborrow]]) + opaque(&*z); + + // `*u` is not Freeze, so we cannot reuse. + // CHECK: [[st8:_.*]] = (*_2); + // CHECK: opaque::(move [[st8]]) + // CHECK: [[st9:_.*]] = (*_2); + // CHECK: opaque::(move [[st9]]) opaque(*u); - opaque(*u); // this cannot reuse, as `z` is not Freeze. + opaque(*u); + + // `*s` is not Copy, by `(*s).0` is, so we can reuse. + // CHECK: [[st10:_.*]] = ((*_3).0: u32); + // CHECK: opaque::([[st10]]) + // CHECK: opaque::([[st10]]) + opaque(s.0); opaque(s.0); - opaque(s.0); // *s is not Copy, by (*s).0 is, so we can reuse. } fn slices() { + // CHECK-LABEL: fn slices( + // CHECK: {{_.*}} = const " + // CHECK-NOT: {{_.*}} = const " let s = "my favourite slice"; // This is a `Const::Slice` in MIR. opaque(s); let t = s; // This should be the same pointer, so cannot be a `Const::Slice`. @@ -238,6 +517,7 @@ fn slices() { #[custom_mir(dialect = "analysis")] fn duplicate_slice() -> (bool, bool) { + // CHECK-LABEL: fn duplicate_slice( mir!( let au: u128; let bu: u128; @@ -246,41 +526,50 @@ fn duplicate_slice() -> (bool, bool) { let c: &str; let d: &str; { + // CHECK: [[a:_.*]] = (const "a",); + // CHECK: [[au:_.*]] = ([[a]].0: &str) as u128 (Transmute); let a = ("a",); Call(au = transmute::<_, u128>(a.0), bb1) } bb1 = { + // CHECK: [[c:_.*]] = identity::<&str>(([[a]].0: &str)) Call(c = identity(a.0), bb2) } bb2 = { + // CHECK: [[cu:_.*]] = [[c]] as u128 (Transmute); Call(cu = transmute::<_, u128>(c), bb3) } bb3 = { - let b = "a"; // This slice is different from `a.0`. - Call(bu = transmute::<_, u128>(b), bb4) // Hence `bu` is not `au`. + // This slice is different from `a.0`. Hence `bu` is not `au`. + // CHECK: [[b:_.*]] = const "a"; + // CHECK: [[bu:_.*]] = [[b]] as u128 (Transmute); + let b = "a"; + Call(bu = transmute::<_, u128>(b), bb4) } bb4 = { - Call(d = identity(b), bb5) // This returns a copy of `b`, which is not `a`. + // This returns a copy of `b`, which is not `a`. + // CHECK: [[d:_.*]] = identity::<&str>([[b]]) + Call(d = identity(b), bb5) } bb5 = { + // CHECK: [[du:_.*]] = [[d]] as u128 (Transmute); Call(du = transmute::<_, u128>(d), bb6) } bb6 = { - let direct = au == bu; // Must not fold to `true`... - let indirect = cu == du; // ...as this will not. + // `direct` must not fold to `true`, as `indirect` will not. + // CHECK: = Eq([[au]], [[bu]]); + // CHECK: = Eq([[cu]], [[du]]); + let direct = au == bu; + let indirect = cu == du; RET = (direct, indirect); Return() } ) } -fn aggregates() { - let a_array: S<[u8; 0]> = S([]); - let b_array: S<[u16; 0]> = S([]); // This must not be merged with `a_array`. - - let a_tuple: S<()> = S(()); - let b_tuple: S<()> = S(()); // But this can be with `a_tuple`. - +fn repeat() { + // CHECK-LABEL: fn repeat( + // CHECK: = [const 5_i32; 10]; let val = 5; let array = [val, val, val, val, val, val, val, val, val, val]; } @@ -290,6 +579,7 @@ fn main() { wrap_unwrap(5); repeated_index::(5, 3); arithmetic(5); + comparison(5, 6); arithmetic_checked(5); arithmetic_float(5.); cast(); @@ -299,7 +589,7 @@ fn main() { slices(); let (direct, indirect) = duplicate_slice(); assert_eq!(direct, indirect); - aggregates(); + repeat(); } #[inline(never)] @@ -314,6 +604,7 @@ fn identity(x: T) -> T { // EMIT_MIR gvn.wrap_unwrap.GVN.diff // EMIT_MIR gvn.repeated_index.GVN.diff // EMIT_MIR gvn.arithmetic.GVN.diff +// EMIT_MIR gvn.comparison.GVN.diff // EMIT_MIR gvn.arithmetic_checked.GVN.diff // EMIT_MIR gvn.arithmetic_float.GVN.diff // EMIT_MIR gvn.cast.GVN.diff @@ -322,4 +613,4 @@ fn identity(x: T) -> T { // EMIT_MIR gvn.dereferences.GVN.diff // EMIT_MIR gvn.slices.GVN.diff // EMIT_MIR gvn.duplicate_slice.GVN.diff -// EMIT_MIR gvn.aggregates.GVN.diff +// EMIT_MIR gvn.repeat.GVN.diff diff --git a/tests/mir-opt/gvn.subexpression_elimination.GVN.panic-abort.diff b/tests/mir-opt/gvn.subexpression_elimination.GVN.panic-abort.diff index 23ba2559448..0a747d3aef0 100644 --- a/tests/mir-opt/gvn.subexpression_elimination.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn.subexpression_elimination.GVN.panic-abort.diff @@ -65,11 +65,11 @@ let mut _60: u64; let mut _61: u64; let mut _62: u64; - let mut _63: u64; + let _63: (); let mut _64: u64; - let _65: (); + let mut _65: u64; let mut _66: u64; - let mut _67: u64; + let _67: (); let mut _68: u64; let mut _69: u64; let mut _70: u64; @@ -77,25 +77,25 @@ let mut _72: u64; let mut _73: u64; let mut _74: u64; - let mut _75: u64; - let mut _76: u64; - let _77: (); + let mut _75: bool; + let _76: (); + let mut _77: u64; let mut _78: u64; let mut _79: u64; - let mut _80: u64; - let mut _81: u64; - let mut _82: bool; + let mut _80: bool; + let _81: (); + let mut _82: u64; let mut _83: u64; - let _84: (); - let mut _85: u64; + let mut _84: u64; + let _85: (); let mut _86: u64; let mut _87: u64; let mut _88: u64; - let mut _89: bool; + let _89: (); let mut _90: u64; - let _91: (); + let mut _91: u64; let mut _92: u64; - let mut _93: u64; + let _93: (); let mut _94: u64; let mut _95: u64; let mut _96: u64; @@ -103,93 +103,91 @@ let mut _98: u64; let mut _99: u64; let mut _100: u64; - let mut _101: u64; - let mut _102: u64; - let _103: (); - let mut _104: u64; - let mut _105: u64; + let _101: (); + let mut _102: u32; + let mut _103: u64; + let _104: (); + let mut _105: f32; let mut _106: u64; - let mut _107: u64; - let mut _108: u64; - let _109: (); - let mut _110: u64; + let _107: (); + let mut _108: S; + let mut _109: u64; + let _110: (); let mut _111: u64; - let mut _112: u64; + let mut _112: S; let mut _113: u64; - let mut _114: u64; - let _115: (); + let _114: (); + let mut _115: u64; let mut _116: u64; let mut _117: u64; let mut _118: u64; let mut _119: u64; - let mut _120: u64; - let _121: (); - let mut _122: S; + let _120: (); + let mut _121: u64; + let mut _122: u64; let mut _123: u64; - let _124: (); + let mut _124: u64; let mut _125: u64; - let mut _126: S; - let mut _127: u64; - let _128: &u64; - let _129: (); + let _126: &u64; + let _127: (); + let mut _128: u64; + let mut _129: u64; let mut _130: u64; - let mut _131: u64; + let _131: (); let mut _132: u64; - let _133: (); + let mut _133: u64; let mut _134: u64; - let mut _135: u64; - let mut _136: u64; - let _138: (); + let _136: (); + let mut _137: u64; + let mut _138: u64; let mut _139: u64; - let mut _140: u64; + let _140: (); let mut _141: u64; - let _142: (); + let mut _142: u64; let mut _143: u64; - let mut _144: u64; - let mut _145: u64; + let _144: (); let _146: (); - let _148: (); + let mut _147: u64; + let mut _148: u64; let mut _149: u64; - let mut _150: u64; + let _150: (); let mut _151: u64; - let _152: (); + let mut _152: u64; let mut _153: u64; - let mut _154: u64; - let mut _155: u64; - let _157: (); + let _155: (); + let mut _156: u64; + let mut _157: u64; let mut _158: u64; - let mut _159: u64; + let _159: (); let mut _160: u64; - let _161: (); + let mut _161: u64; let mut _162: u64; - let mut _163: u64; - let mut _164: u64; - let _166: (); + let _164: (); + let mut _165: u64; + let mut _166: u64; let mut _167: u64; - let mut _168: u64; + let _168: (); let mut _169: u64; - let _170: (); + let mut _170: u64; let mut _171: u64; - let mut _172: u64; - let mut _173: u64; scope 1 { - debug a => _128; - let _137: &mut u64; + debug a => _126; + let _135: &mut u64; scope 2 { - debug b => _137; - let _165: &u64; + debug b => _135; + let _163: &u64; scope 3 { - let _147: *const u64; + let _145: *const u64; scope 4 { - debug c => _147; - let _156: *mut u64; + debug c => _145; + let _154: *mut u64; scope 5 { - debug d => _156; + debug d => _154; } } } scope 6 { - debug e => _165; + debug e => _163; } } } @@ -400,30 +398,36 @@ + nop; StorageDead(_42); StorageLive(_46); - StorageLive(_47); +- StorageLive(_47); ++ nop; StorageLive(_48); _48 = _1; - _47 = move _48 as u32 (IntToInt); + _47 = _1 as u32 (IntToInt); StorageDead(_48); - _46 = opaque::(move _47) -> [return: bb13, unwind unreachable]; +- _46 = opaque::(move _47) -> [return: bb13, unwind unreachable]; ++ _46 = opaque::(_47) -> [return: bb13, unwind unreachable]; } bb13: { - StorageDead(_47); +- StorageDead(_47); ++ nop; StorageDead(_46); StorageLive(_49); - StorageLive(_50); +- StorageLive(_50); ++ nop; StorageLive(_51); _51 = _1; - _50 = move _51 as f32 (IntToFloat); + _50 = _1 as f32 (IntToFloat); StorageDead(_51); - _49 = opaque::(move _50) -> [return: bb14, unwind unreachable]; +- _49 = opaque::(move _50) -> [return: bb14, unwind unreachable]; ++ _49 = opaque::(_50) -> [return: bb14, unwind unreachable]; } bb14: { - StorageDead(_50); +- StorageDead(_50); ++ nop; StorageDead(_49); StorageLive(_52); - StorageLive(_53); @@ -462,479 +466,497 @@ StorageLive(_59); StorageLive(_60); StorageLive(_61); + _61 = _1; StorageLive(_62); - _62 = _1; - StorageLive(_63); - _63 = _2; -- _61 = Add(move _62, move _63); -+ _61 = _5; - StorageDead(_63); + _62 = _2; +- _60 = Add(move _61, move _62); ++ _60 = _5; StorageDead(_62); - StorageLive(_64); - _64 = _3; -- _60 = Add(move _61, move _64); -+ _60 = Add(_5, move _64); - StorageDead(_64); StorageDead(_61); - _59 = opaque::(move _60) -> [return: bb17, unwind unreachable]; +- _59 = opaque::(move _60) -> [return: bb17, unwind unreachable]; ++ _59 = opaque::(_5) -> [return: bb17, unwind unreachable]; } bb17: { StorageDead(_60); StorageDead(_59); + StorageLive(_63); + StorageLive(_64); StorageLive(_65); + _65 = _1; StorageLive(_66); - StorageLive(_67); - StorageLive(_68); - _68 = _1; - StorageLive(_69); - _69 = _2; -- _67 = Mul(move _68, move _69); -+ _67 = _9; - StorageDead(_69); - StorageDead(_68); - StorageLive(_70); - _70 = _3; -- _66 = Add(move _67, move _70); -+ _66 = Add(_9, move _70); - StorageDead(_70); - StorageDead(_67); - _65 = opaque::(move _66) -> [return: bb18, unwind unreachable]; + _66 = _2; +- _64 = Mul(move _65, move _66); ++ _64 = _9; + StorageDead(_66); + StorageDead(_65); +- _63 = opaque::(move _64) -> [return: bb18, unwind unreachable]; ++ _63 = opaque::(_9) -> [return: bb18, unwind unreachable]; } bb18: { - StorageDead(_66); - StorageDead(_65); - StorageLive(_71); - StorageLive(_72); - StorageLive(_73); - StorageLive(_74); - _74 = _1; - StorageLive(_75); - _75 = _2; -- _73 = Sub(move _74, move _75); -+ _73 = _13; - StorageDead(_75); - StorageDead(_74); - StorageLive(_76); - _76 = _3; -- _72 = Add(move _73, move _76); -+ _72 = Add(_13, move _76); - StorageDead(_76); - StorageDead(_73); - _71 = opaque::(move _72) -> [return: bb19, unwind unreachable]; + StorageDead(_64); + StorageDead(_63); + StorageLive(_67); + StorageLive(_68); + StorageLive(_69); + _69 = _1; + StorageLive(_70); + _70 = _2; +- _68 = Sub(move _69, move _70); ++ _68 = _13; + StorageDead(_70); + StorageDead(_69); +- _67 = opaque::(move _68) -> [return: bb19, unwind unreachable]; ++ _67 = opaque::(_13) -> [return: bb19, unwind unreachable]; } bb19: { - StorageDead(_72); - StorageDead(_71); - StorageLive(_77); - StorageLive(_78); - StorageLive(_79); - StorageLive(_80); - _80 = _1; - StorageLive(_81); - _81 = _2; -- _82 = Eq(_81, const 0_u64); -- assert(!move _82, "attempt to divide `{}` by zero", _80) -> [success: bb20, unwind unreachable]; -+ _82 = _20; + StorageDead(_68); + StorageDead(_67); + StorageLive(_71); + StorageLive(_72); + StorageLive(_73); + _73 = _1; + StorageLive(_74); + _74 = _2; +- _75 = Eq(_74, const 0_u64); +- assert(!move _75, "attempt to divide `{}` by zero", _73) -> [success: bb20, unwind unreachable]; ++ _75 = _20; + assert(!_20, "attempt to divide `{}` by zero", _1) -> [success: bb20, unwind unreachable]; } bb20: { -- _79 = Div(move _80, move _81); -+ _79 = _17; - StorageDead(_81); - StorageDead(_80); - StorageLive(_83); - _83 = _3; -- _78 = Add(move _79, move _83); -+ _78 = Add(_17, move _83); - StorageDead(_83); - StorageDead(_79); - _77 = opaque::(move _78) -> [return: bb21, unwind unreachable]; +- _72 = Div(move _73, move _74); ++ _72 = _17; + StorageDead(_74); + StorageDead(_73); +- _71 = opaque::(move _72) -> [return: bb21, unwind unreachable]; ++ _71 = opaque::(_17) -> [return: bb21, unwind unreachable]; } bb21: { + StorageDead(_72); + StorageDead(_71); + StorageLive(_76); + StorageLive(_77); + StorageLive(_78); + _78 = _1; + StorageLive(_79); + _79 = _2; +- _80 = Eq(_79, const 0_u64); +- assert(!move _80, "attempt to calculate the remainder of `{}` with a divisor of zero", _78) -> [success: bb22, unwind unreachable]; ++ _80 = _20; ++ assert(!_20, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb22, unwind unreachable]; + } + + bb22: { +- _77 = Rem(move _78, move _79); ++ _77 = _22; + StorageDead(_79); StorageDead(_78); +- _76 = opaque::(move _77) -> [return: bb23, unwind unreachable]; ++ _76 = opaque::(_22) -> [return: bb23, unwind unreachable]; + } + + bb23: { StorageDead(_77); + StorageDead(_76); + StorageLive(_81); + StorageLive(_82); + StorageLive(_83); + _83 = _1; StorageLive(_84); + _84 = _2; +- _82 = BitAnd(move _83, move _84); ++ _82 = _27; + StorageDead(_84); + StorageDead(_83); +- _81 = opaque::(move _82) -> [return: bb24, unwind unreachable]; ++ _81 = opaque::(_27) -> [return: bb24, unwind unreachable]; + } + + bb24: { + StorageDead(_82); + StorageDead(_81); StorageLive(_85); StorageLive(_86); StorageLive(_87); _87 = _1; StorageLive(_88); _88 = _2; -- _89 = Eq(_88, const 0_u64); -- assert(!move _89, "attempt to calculate the remainder of `{}` with a divisor of zero", _87) -> [success: bb22, unwind unreachable]; -+ _89 = _20; -+ assert(!_20, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb22, unwind unreachable]; - } - - bb22: { -- _86 = Rem(move _87, move _88); -+ _86 = _22; +- _86 = BitOr(move _87, move _88); ++ _86 = _31; StorageDead(_88); StorageDead(_87); - StorageLive(_90); - _90 = _3; -- _85 = Add(move _86, move _90); -+ _85 = Add(_22, move _90); - StorageDead(_90); - StorageDead(_86); - _84 = opaque::(move _85) -> [return: bb23, unwind unreachable]; - } - - bb23: { - StorageDead(_85); - StorageDead(_84); - StorageLive(_91); - StorageLive(_92); - StorageLive(_93); - StorageLive(_94); - _94 = _1; - StorageLive(_95); - _95 = _2; -- _93 = BitAnd(move _94, move _95); -+ _93 = _27; - StorageDead(_95); - StorageDead(_94); - StorageLive(_96); - _96 = _3; -- _92 = Add(move _93, move _96); -+ _92 = Add(_27, move _96); - StorageDead(_96); - StorageDead(_93); - _91 = opaque::(move _92) -> [return: bb24, unwind unreachable]; - } - - bb24: { - StorageDead(_92); - StorageDead(_91); - StorageLive(_97); - StorageLive(_98); - StorageLive(_99); - StorageLive(_100); - _100 = _1; - StorageLive(_101); - _101 = _2; -- _99 = BitOr(move _100, move _101); -+ _99 = _31; - StorageDead(_101); - StorageDead(_100); - StorageLive(_102); - _102 = _3; -- _98 = Add(move _99, move _102); -+ _98 = Add(_31, move _102); - StorageDead(_102); - StorageDead(_99); - _97 = opaque::(move _98) -> [return: bb25, unwind unreachable]; +- _85 = opaque::(move _86) -> [return: bb25, unwind unreachable]; ++ _85 = opaque::(_31) -> [return: bb25, unwind unreachable]; } bb25: { + StorageDead(_86); + StorageDead(_85); + StorageLive(_89); + StorageLive(_90); + StorageLive(_91); + _91 = _1; + StorageLive(_92); + _92 = _2; +- _90 = BitXor(move _91, move _92); ++ _90 = _35; + StorageDead(_92); + StorageDead(_91); +- _89 = opaque::(move _90) -> [return: bb26, unwind unreachable]; ++ _89 = opaque::(_35) -> [return: bb26, unwind unreachable]; + } + + bb26: { + StorageDead(_90); + StorageDead(_89); + StorageLive(_93); + StorageLive(_94); + StorageLive(_95); + _95 = _1; + StorageLive(_96); + _96 = _2; +- _94 = Shl(move _95, move _96); ++ _94 = _39; + StorageDead(_96); + StorageDead(_95); +- _93 = opaque::(move _94) -> [return: bb27, unwind unreachable]; ++ _93 = opaque::(_39) -> [return: bb27, unwind unreachable]; + } + + bb27: { + StorageDead(_94); + StorageDead(_93); + StorageLive(_97); + StorageLive(_98); + StorageLive(_99); + _99 = _1; + StorageLive(_100); + _100 = _2; +- _98 = Shr(move _99, move _100); ++ _98 = _43; + StorageDead(_100); + StorageDead(_99); +- _97 = opaque::(move _98) -> [return: bb28, unwind unreachable]; ++ _97 = opaque::(_43) -> [return: bb28, unwind unreachable]; + } + + bb28: { StorageDead(_98); StorageDead(_97); + StorageLive(_101); + StorageLive(_102); StorageLive(_103); + _103 = _1; +- _102 = move _103 as u32 (IntToInt); ++ _102 = _47; + StorageDead(_103); +- _101 = opaque::(move _102) -> [return: bb29, unwind unreachable]; ++ _101 = opaque::(_47) -> [return: bb29, unwind unreachable]; + } + + bb29: { + StorageDead(_102); + StorageDead(_101); StorageLive(_104); StorageLive(_105); StorageLive(_106); _106 = _1; - StorageLive(_107); - _107 = _2; -- _105 = BitXor(move _106, move _107); -+ _105 = _35; - StorageDead(_107); +- _105 = move _106 as f32 (IntToFloat); ++ _105 = _50; StorageDead(_106); - StorageLive(_108); - _108 = _3; -- _104 = Add(move _105, move _108); -+ _104 = Add(_35, move _108); - StorageDead(_108); - StorageDead(_105); - _103 = opaque::(move _104) -> [return: bb26, unwind unreachable]; +- _104 = opaque::(move _105) -> [return: bb30, unwind unreachable]; ++ _104 = opaque::(_50) -> [return: bb30, unwind unreachable]; } - bb26: { + bb30: { + StorageDead(_105); StorageDead(_104); - StorageDead(_103); + StorageLive(_107); + StorageLive(_108); StorageLive(_109); + _109 = _1; +- _108 = S::(move _109); ++ _108 = _53; + StorageDead(_109); +- _107 = opaque::>(move _108) -> [return: bb31, unwind unreachable]; ++ _107 = opaque::>(_53) -> [return: bb31, unwind unreachable]; + } + + bb31: { + StorageDead(_108); + StorageDead(_107); StorageLive(_110); StorageLive(_111); StorageLive(_112); - _112 = _1; StorageLive(_113); - _113 = _2; -- _111 = Shl(move _112, move _113); -+ _111 = _39; + _113 = _1; +- _112 = S::(move _113); ++ _112 = _53; StorageDead(_113); - StorageDead(_112); - StorageLive(_114); - _114 = _3; -- _110 = Add(move _111, move _114); -+ _110 = Add(_39, move _114); - StorageDead(_114); - StorageDead(_111); - _109 = opaque::(move _110) -> [return: bb27, unwind unreachable]; +- _111 = (_112.0: u64); +- _110 = opaque::(move _111) -> [return: bb32, unwind unreachable]; ++ _111 = _1; ++ _110 = opaque::(_1) -> [return: bb32, unwind unreachable]; } - bb27: { + bb32: { + StorageDead(_111); + StorageDead(_112); StorageDead(_110); - StorageDead(_109); - StorageLive(_115); + StorageLive(_114); +- StorageLive(_115); ++ nop; StorageLive(_116); StorageLive(_117); + _117 = _1; StorageLive(_118); - _118 = _1; + _118 = _2; +- _116 = Mul(move _117, move _118); ++ _116 = _9; + StorageDead(_118); + StorageDead(_117); StorageLive(_119); _119 = _2; -- _117 = Shr(move _118, move _119); -+ _117 = _43; +- _115 = Sub(move _116, move _119); ++ _115 = Sub(_9, _2); StorageDead(_119); - StorageDead(_118); - StorageLive(_120); - _120 = _3; -- _116 = Add(move _117, move _120); -+ _116 = Add(_43, move _120); - StorageDead(_120); - StorageDead(_117); - _115 = opaque::(move _116) -> [return: bb28, unwind unreachable]; + StorageDead(_116); +- _114 = opaque::(move _115) -> [return: bb33, unwind unreachable]; ++ _114 = opaque::(_115) -> [return: bb33, unwind unreachable]; } - bb28: { - StorageDead(_116); - StorageDead(_115); + bb33: { +- StorageDead(_115); ++ nop; + StorageDead(_114); + StorageLive(_120); StorageLive(_121); StorageLive(_122); StorageLive(_123); _123 = _1; -- _122 = S::(move _123); -+ _122 = _53; - StorageDead(_123); -- _121 = opaque::>(move _122) -> [return: bb29, unwind unreachable]; -+ _121 = opaque::>(_53) -> [return: bb29, unwind unreachable]; - } - - bb29: { - StorageDead(_122); - StorageDead(_121); StorageLive(_124); - StorageLive(_125); - StorageLive(_126); - StorageLive(_127); - _127 = _1; -- _126 = S::(move _127); -+ _126 = _53; - StorageDead(_127); -- _125 = (_126.0: u64); -- _124 = opaque::(move _125) -> [return: bb30, unwind unreachable]; -+ _125 = _1; -+ _124 = opaque::(_1) -> [return: bb30, unwind unreachable]; - } - - bb30: { - StorageDead(_125); - StorageDead(_126); + _124 = _2; +- _122 = Mul(move _123, move _124); ++ _122 = _9; StorageDead(_124); -- StorageLive(_128); -+ nop; - _128 = &_3; - StorageLive(_129); -- StorageLive(_130); -- StorageLive(_131); -+ nop; -+ nop; - _131 = (*_128); - StorageLive(_132); - _132 = _1; -- _130 = Add(move _131, move _132); -+ _130 = Add(_131, _1); - StorageDead(_132); -- StorageDead(_131); -- _129 = opaque::(move _130) -> [return: bb31, unwind unreachable]; -+ nop; -+ _129 = opaque::(_130) -> [return: bb31, unwind unreachable]; - } - - bb31: { -- StorageDead(_130); -+ nop; - StorageDead(_129); - StorageLive(_133); - StorageLive(_134); - StorageLive(_135); -- _135 = (*_128); -+ _135 = _131; - StorageLive(_136); - _136 = _1; -- _134 = Add(move _135, move _136); -+ _134 = _130; - StorageDead(_136); - StorageDead(_135); -- _133 = opaque::(move _134) -> [return: bb32, unwind unreachable]; -+ _133 = opaque::(_130) -> [return: bb32, unwind unreachable]; - } - - bb32: { - StorageDead(_134); - StorageDead(_133); -- StorageLive(_137); -+ nop; - _137 = &mut _3; - StorageLive(_138); - StorageLive(_139); - StorageLive(_140); - _140 = (*_137); - StorageLive(_141); - _141 = _1; -- _139 = Add(move _140, move _141); -+ _139 = Add(move _140, _1); - StorageDead(_141); - StorageDead(_140); - _138 = opaque::(move _139) -> [return: bb33, unwind unreachable]; - } - - bb33: { - StorageDead(_139); - StorageDead(_138); - StorageLive(_142); - StorageLive(_143); - StorageLive(_144); - _144 = (*_137); - StorageLive(_145); - _145 = _1; -- _143 = Add(move _144, move _145); -+ _143 = Add(move _144, _1); - StorageDead(_145); - StorageDead(_144); - _142 = opaque::(move _143) -> [return: bb34, unwind unreachable]; + StorageDead(_123); + StorageLive(_125); + _125 = _2; +- _121 = Sub(move _122, move _125); ++ _121 = _115; + StorageDead(_125); + StorageDead(_122); +- _120 = opaque::(move _121) -> [return: bb34, unwind unreachable]; ++ _120 = opaque::(_115) -> [return: bb34, unwind unreachable]; } bb34: { - StorageDead(_143); - StorageDead(_142); - StorageLive(_146); -- StorageLive(_147); + StorageDead(_121); + StorageDead(_120); +- StorageLive(_126); + nop; - _147 = &raw const _3; - StorageLive(_148); - StorageLive(_149); - StorageLive(_150); - _150 = (*_147); - StorageLive(_151); - _151 = _1; -- _149 = Add(move _150, move _151); -+ _149 = Add(move _150, _1); - StorageDead(_151); - StorageDead(_150); - _148 = opaque::(move _149) -> [return: bb35, unwind unreachable]; + _126 = &_3; + StorageLive(_127); +- StorageLive(_128); +- StorageLive(_129); ++ nop; ++ nop; + _129 = (*_126); + StorageLive(_130); + _130 = _1; +- _128 = Add(move _129, move _130); ++ _128 = Add(_129, _1); + StorageDead(_130); +- StorageDead(_129); +- _127 = opaque::(move _128) -> [return: bb35, unwind unreachable]; ++ nop; ++ _127 = opaque::(_128) -> [return: bb35, unwind unreachable]; } bb35: { - StorageDead(_149); - StorageDead(_148); - StorageLive(_152); - StorageLive(_153); - StorageLive(_154); - _154 = (*_147); - StorageLive(_155); - _155 = _1; -- _153 = Add(move _154, move _155); -+ _153 = Add(move _154, _1); - StorageDead(_155); - StorageDead(_154); - _152 = opaque::(move _153) -> [return: bb36, unwind unreachable]; +- StorageDead(_128); ++ nop; + StorageDead(_127); + StorageLive(_131); + StorageLive(_132); + StorageLive(_133); +- _133 = (*_126); ++ _133 = _129; + StorageLive(_134); + _134 = _1; +- _132 = Add(move _133, move _134); ++ _132 = _128; + StorageDead(_134); + StorageDead(_133); +- _131 = opaque::(move _132) -> [return: bb36, unwind unreachable]; ++ _131 = opaque::(_128) -> [return: bb36, unwind unreachable]; } bb36: { - StorageDead(_153); - StorageDead(_152); -- StorageLive(_156); + StorageDead(_132); + StorageDead(_131); +- StorageLive(_135); + nop; - _156 = &raw mut _3; - StorageLive(_157); - StorageLive(_158); - StorageLive(_159); - _159 = (*_156); - StorageLive(_160); - _160 = _1; -- _158 = Add(move _159, move _160); -+ _158 = Add(move _159, _1); - StorageDead(_160); - StorageDead(_159); - _157 = opaque::(move _158) -> [return: bb37, unwind unreachable]; + _135 = &mut _3; + StorageLive(_136); + StorageLive(_137); + StorageLive(_138); + _138 = (*_135); + StorageLive(_139); + _139 = _1; +- _137 = Add(move _138, move _139); ++ _137 = Add(move _138, _1); + StorageDead(_139); + StorageDead(_138); + _136 = opaque::(move _137) -> [return: bb37, unwind unreachable]; } bb37: { - StorageDead(_158); - StorageDead(_157); - StorageLive(_161); - StorageLive(_162); - StorageLive(_163); - _163 = (*_156); - StorageLive(_164); - _164 = _1; -- _162 = Add(move _163, move _164); -+ _162 = Add(move _163, _1); - StorageDead(_164); - StorageDead(_163); - _161 = opaque::(move _162) -> [return: bb38, unwind unreachable]; + StorageDead(_137); + StorageDead(_136); + StorageLive(_140); + StorageLive(_141); + StorageLive(_142); + _142 = (*_135); + StorageLive(_143); + _143 = _1; +- _141 = Add(move _142, move _143); ++ _141 = Add(move _142, _1); + StorageDead(_143); + StorageDead(_142); + _140 = opaque::(move _141) -> [return: bb38, unwind unreachable]; } bb38: { - StorageDead(_162); - StorageDead(_161); - _146 = const (); -- StorageDead(_156); -- StorageDead(_147); + StorageDead(_141); + StorageDead(_140); + StorageLive(_144); +- StorageLive(_145); + nop; -+ nop; - StorageDead(_146); -- StorageLive(_165); -+ nop; - _165 = &_3; - StorageLive(_166); -- StorageLive(_167); -- StorageLive(_168); -+ nop; -+ nop; - _168 = (*_165); - StorageLive(_169); - _169 = _1; -- _167 = Add(move _168, move _169); -+ _167 = Add(_168, _1); - StorageDead(_169); -- StorageDead(_168); -- _166 = opaque::(move _167) -> [return: bb39, unwind unreachable]; -+ nop; -+ _166 = opaque::(_167) -> [return: bb39, unwind unreachable]; + _145 = &raw const _3; + StorageLive(_146); + StorageLive(_147); + StorageLive(_148); + _148 = (*_145); + StorageLive(_149); + _149 = _1; +- _147 = Add(move _148, move _149); ++ _147 = Add(move _148, _1); + StorageDead(_149); + StorageDead(_148); + _146 = opaque::(move _147) -> [return: bb39, unwind unreachable]; } bb39: { -- StorageDead(_167); -+ nop; - StorageDead(_166); - StorageLive(_170); - StorageLive(_171); - StorageLive(_172); -- _172 = (*_165); -+ _172 = _168; - StorageLive(_173); - _173 = _1; -- _171 = Add(move _172, move _173); -+ _171 = _167; - StorageDead(_173); - StorageDead(_172); -- _170 = opaque::(move _171) -> [return: bb40, unwind unreachable]; -+ _170 = opaque::(_167) -> [return: bb40, unwind unreachable]; + StorageDead(_147); + StorageDead(_146); + StorageLive(_150); + StorageLive(_151); + StorageLive(_152); + _152 = (*_145); + StorageLive(_153); + _153 = _1; +- _151 = Add(move _152, move _153); ++ _151 = Add(move _152, _1); + StorageDead(_153); + StorageDead(_152); + _150 = opaque::(move _151) -> [return: bb40, unwind unreachable]; } bb40: { + StorageDead(_151); + StorageDead(_150); +- StorageLive(_154); ++ nop; + _154 = &raw mut _3; + StorageLive(_155); + StorageLive(_156); + StorageLive(_157); + _157 = (*_154); + StorageLive(_158); + _158 = _1; +- _156 = Add(move _157, move _158); ++ _156 = Add(move _157, _1); + StorageDead(_158); + StorageDead(_157); + _155 = opaque::(move _156) -> [return: bb41, unwind unreachable]; + } + + bb41: { + StorageDead(_156); + StorageDead(_155); + StorageLive(_159); + StorageLive(_160); + StorageLive(_161); + _161 = (*_154); + StorageLive(_162); + _162 = _1; +- _160 = Add(move _161, move _162); ++ _160 = Add(move _161, _1); + StorageDead(_162); + StorageDead(_161); + _159 = opaque::(move _160) -> [return: bb42, unwind unreachable]; + } + + bb42: { + StorageDead(_160); + StorageDead(_159); + _144 = const (); +- StorageDead(_154); +- StorageDead(_145); ++ nop; ++ nop; + StorageDead(_144); +- StorageLive(_163); ++ nop; + _163 = &_3; + StorageLive(_164); +- StorageLive(_165); +- StorageLive(_166); ++ nop; ++ nop; + _166 = (*_163); + StorageLive(_167); + _167 = _1; +- _165 = Add(move _166, move _167); ++ _165 = Add(_166, _1); + StorageDead(_167); +- StorageDead(_166); +- _164 = opaque::(move _165) -> [return: bb43, unwind unreachable]; ++ nop; ++ _164 = opaque::(_165) -> [return: bb43, unwind unreachable]; + } + + bb43: { +- StorageDead(_165); ++ nop; + StorageDead(_164); + StorageLive(_168); + StorageLive(_169); + StorageLive(_170); +- _170 = (*_163); ++ _170 = _166; + StorageLive(_171); + _171 = _1; +- _169 = Add(move _170, move _171); ++ _169 = _165; StorageDead(_171); StorageDead(_170); +- _168 = opaque::(move _169) -> [return: bb44, unwind unreachable]; ++ _168 = opaque::(_165) -> [return: bb44, unwind unreachable]; + } + + bb44: { + StorageDead(_169); + StorageDead(_168); _0 = const (); -- StorageDead(_165); -- StorageDead(_137); -- StorageDead(_128); +- StorageDead(_163); +- StorageDead(_135); +- StorageDead(_126); + nop; + nop; + nop; diff --git a/tests/mir-opt/gvn.subexpression_elimination.GVN.panic-unwind.diff b/tests/mir-opt/gvn.subexpression_elimination.GVN.panic-unwind.diff index 062dc6ff561..119a4d9bbe9 100644 --- a/tests/mir-opt/gvn.subexpression_elimination.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn.subexpression_elimination.GVN.panic-unwind.diff @@ -65,11 +65,11 @@ let mut _60: u64; let mut _61: u64; let mut _62: u64; - let mut _63: u64; + let _63: (); let mut _64: u64; - let _65: (); + let mut _65: u64; let mut _66: u64; - let mut _67: u64; + let _67: (); let mut _68: u64; let mut _69: u64; let mut _70: u64; @@ -77,25 +77,25 @@ let mut _72: u64; let mut _73: u64; let mut _74: u64; - let mut _75: u64; - let mut _76: u64; - let _77: (); + let mut _75: bool; + let _76: (); + let mut _77: u64; let mut _78: u64; let mut _79: u64; - let mut _80: u64; - let mut _81: u64; - let mut _82: bool; + let mut _80: bool; + let _81: (); + let mut _82: u64; let mut _83: u64; - let _84: (); - let mut _85: u64; + let mut _84: u64; + let _85: (); let mut _86: u64; let mut _87: u64; let mut _88: u64; - let mut _89: bool; + let _89: (); let mut _90: u64; - let _91: (); + let mut _91: u64; let mut _92: u64; - let mut _93: u64; + let _93: (); let mut _94: u64; let mut _95: u64; let mut _96: u64; @@ -103,93 +103,91 @@ let mut _98: u64; let mut _99: u64; let mut _100: u64; - let mut _101: u64; - let mut _102: u64; - let _103: (); - let mut _104: u64; - let mut _105: u64; + let _101: (); + let mut _102: u32; + let mut _103: u64; + let _104: (); + let mut _105: f32; let mut _106: u64; - let mut _107: u64; - let mut _108: u64; - let _109: (); - let mut _110: u64; + let _107: (); + let mut _108: S; + let mut _109: u64; + let _110: (); let mut _111: u64; - let mut _112: u64; + let mut _112: S; let mut _113: u64; - let mut _114: u64; - let _115: (); + let _114: (); + let mut _115: u64; let mut _116: u64; let mut _117: u64; let mut _118: u64; let mut _119: u64; - let mut _120: u64; - let _121: (); - let mut _122: S; + let _120: (); + let mut _121: u64; + let mut _122: u64; let mut _123: u64; - let _124: (); + let mut _124: u64; let mut _125: u64; - let mut _126: S; - let mut _127: u64; - let _128: &u64; - let _129: (); + let _126: &u64; + let _127: (); + let mut _128: u64; + let mut _129: u64; let mut _130: u64; - let mut _131: u64; + let _131: (); let mut _132: u64; - let _133: (); + let mut _133: u64; let mut _134: u64; - let mut _135: u64; - let mut _136: u64; - let _138: (); + let _136: (); + let mut _137: u64; + let mut _138: u64; let mut _139: u64; - let mut _140: u64; + let _140: (); let mut _141: u64; - let _142: (); + let mut _142: u64; let mut _143: u64; - let mut _144: u64; - let mut _145: u64; + let _144: (); let _146: (); - let _148: (); + let mut _147: u64; + let mut _148: u64; let mut _149: u64; - let mut _150: u64; + let _150: (); let mut _151: u64; - let _152: (); + let mut _152: u64; let mut _153: u64; - let mut _154: u64; - let mut _155: u64; - let _157: (); + let _155: (); + let mut _156: u64; + let mut _157: u64; let mut _158: u64; - let mut _159: u64; + let _159: (); let mut _160: u64; - let _161: (); + let mut _161: u64; let mut _162: u64; - let mut _163: u64; - let mut _164: u64; - let _166: (); + let _164: (); + let mut _165: u64; + let mut _166: u64; let mut _167: u64; - let mut _168: u64; + let _168: (); let mut _169: u64; - let _170: (); + let mut _170: u64; let mut _171: u64; - let mut _172: u64; - let mut _173: u64; scope 1 { - debug a => _128; - let _137: &mut u64; + debug a => _126; + let _135: &mut u64; scope 2 { - debug b => _137; - let _165: &u64; + debug b => _135; + let _163: &u64; scope 3 { - let _147: *const u64; + let _145: *const u64; scope 4 { - debug c => _147; - let _156: *mut u64; + debug c => _145; + let _154: *mut u64; scope 5 { - debug d => _156; + debug d => _154; } } } scope 6 { - debug e => _165; + debug e => _163; } } } @@ -400,30 +398,36 @@ + nop; StorageDead(_42); StorageLive(_46); - StorageLive(_47); +- StorageLive(_47); ++ nop; StorageLive(_48); _48 = _1; - _47 = move _48 as u32 (IntToInt); + _47 = _1 as u32 (IntToInt); StorageDead(_48); - _46 = opaque::(move _47) -> [return: bb13, unwind continue]; +- _46 = opaque::(move _47) -> [return: bb13, unwind continue]; ++ _46 = opaque::(_47) -> [return: bb13, unwind continue]; } bb13: { - StorageDead(_47); +- StorageDead(_47); ++ nop; StorageDead(_46); StorageLive(_49); - StorageLive(_50); +- StorageLive(_50); ++ nop; StorageLive(_51); _51 = _1; - _50 = move _51 as f32 (IntToFloat); + _50 = _1 as f32 (IntToFloat); StorageDead(_51); - _49 = opaque::(move _50) -> [return: bb14, unwind continue]; +- _49 = opaque::(move _50) -> [return: bb14, unwind continue]; ++ _49 = opaque::(_50) -> [return: bb14, unwind continue]; } bb14: { - StorageDead(_50); +- StorageDead(_50); ++ nop; StorageDead(_49); StorageLive(_52); - StorageLive(_53); @@ -462,479 +466,497 @@ StorageLive(_59); StorageLive(_60); StorageLive(_61); + _61 = _1; StorageLive(_62); - _62 = _1; - StorageLive(_63); - _63 = _2; -- _61 = Add(move _62, move _63); -+ _61 = _5; - StorageDead(_63); + _62 = _2; +- _60 = Add(move _61, move _62); ++ _60 = _5; StorageDead(_62); - StorageLive(_64); - _64 = _3; -- _60 = Add(move _61, move _64); -+ _60 = Add(_5, move _64); - StorageDead(_64); StorageDead(_61); - _59 = opaque::(move _60) -> [return: bb17, unwind continue]; +- _59 = opaque::(move _60) -> [return: bb17, unwind continue]; ++ _59 = opaque::(_5) -> [return: bb17, unwind continue]; } bb17: { StorageDead(_60); StorageDead(_59); + StorageLive(_63); + StorageLive(_64); StorageLive(_65); + _65 = _1; StorageLive(_66); - StorageLive(_67); - StorageLive(_68); - _68 = _1; - StorageLive(_69); - _69 = _2; -- _67 = Mul(move _68, move _69); -+ _67 = _9; - StorageDead(_69); - StorageDead(_68); - StorageLive(_70); - _70 = _3; -- _66 = Add(move _67, move _70); -+ _66 = Add(_9, move _70); - StorageDead(_70); - StorageDead(_67); - _65 = opaque::(move _66) -> [return: bb18, unwind continue]; + _66 = _2; +- _64 = Mul(move _65, move _66); ++ _64 = _9; + StorageDead(_66); + StorageDead(_65); +- _63 = opaque::(move _64) -> [return: bb18, unwind continue]; ++ _63 = opaque::(_9) -> [return: bb18, unwind continue]; } bb18: { - StorageDead(_66); - StorageDead(_65); - StorageLive(_71); - StorageLive(_72); - StorageLive(_73); - StorageLive(_74); - _74 = _1; - StorageLive(_75); - _75 = _2; -- _73 = Sub(move _74, move _75); -+ _73 = _13; - StorageDead(_75); - StorageDead(_74); - StorageLive(_76); - _76 = _3; -- _72 = Add(move _73, move _76); -+ _72 = Add(_13, move _76); - StorageDead(_76); - StorageDead(_73); - _71 = opaque::(move _72) -> [return: bb19, unwind continue]; + StorageDead(_64); + StorageDead(_63); + StorageLive(_67); + StorageLive(_68); + StorageLive(_69); + _69 = _1; + StorageLive(_70); + _70 = _2; +- _68 = Sub(move _69, move _70); ++ _68 = _13; + StorageDead(_70); + StorageDead(_69); +- _67 = opaque::(move _68) -> [return: bb19, unwind continue]; ++ _67 = opaque::(_13) -> [return: bb19, unwind continue]; } bb19: { - StorageDead(_72); - StorageDead(_71); - StorageLive(_77); - StorageLive(_78); - StorageLive(_79); - StorageLive(_80); - _80 = _1; - StorageLive(_81); - _81 = _2; -- _82 = Eq(_81, const 0_u64); -- assert(!move _82, "attempt to divide `{}` by zero", _80) -> [success: bb20, unwind continue]; -+ _82 = _20; + StorageDead(_68); + StorageDead(_67); + StorageLive(_71); + StorageLive(_72); + StorageLive(_73); + _73 = _1; + StorageLive(_74); + _74 = _2; +- _75 = Eq(_74, const 0_u64); +- assert(!move _75, "attempt to divide `{}` by zero", _73) -> [success: bb20, unwind continue]; ++ _75 = _20; + assert(!_20, "attempt to divide `{}` by zero", _1) -> [success: bb20, unwind continue]; } bb20: { -- _79 = Div(move _80, move _81); -+ _79 = _17; - StorageDead(_81); - StorageDead(_80); - StorageLive(_83); - _83 = _3; -- _78 = Add(move _79, move _83); -+ _78 = Add(_17, move _83); - StorageDead(_83); - StorageDead(_79); - _77 = opaque::(move _78) -> [return: bb21, unwind continue]; +- _72 = Div(move _73, move _74); ++ _72 = _17; + StorageDead(_74); + StorageDead(_73); +- _71 = opaque::(move _72) -> [return: bb21, unwind continue]; ++ _71 = opaque::(_17) -> [return: bb21, unwind continue]; } bb21: { + StorageDead(_72); + StorageDead(_71); + StorageLive(_76); + StorageLive(_77); + StorageLive(_78); + _78 = _1; + StorageLive(_79); + _79 = _2; +- _80 = Eq(_79, const 0_u64); +- assert(!move _80, "attempt to calculate the remainder of `{}` with a divisor of zero", _78) -> [success: bb22, unwind continue]; ++ _80 = _20; ++ assert(!_20, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb22, unwind continue]; + } + + bb22: { +- _77 = Rem(move _78, move _79); ++ _77 = _22; + StorageDead(_79); StorageDead(_78); +- _76 = opaque::(move _77) -> [return: bb23, unwind continue]; ++ _76 = opaque::(_22) -> [return: bb23, unwind continue]; + } + + bb23: { StorageDead(_77); + StorageDead(_76); + StorageLive(_81); + StorageLive(_82); + StorageLive(_83); + _83 = _1; StorageLive(_84); + _84 = _2; +- _82 = BitAnd(move _83, move _84); ++ _82 = _27; + StorageDead(_84); + StorageDead(_83); +- _81 = opaque::(move _82) -> [return: bb24, unwind continue]; ++ _81 = opaque::(_27) -> [return: bb24, unwind continue]; + } + + bb24: { + StorageDead(_82); + StorageDead(_81); StorageLive(_85); StorageLive(_86); StorageLive(_87); _87 = _1; StorageLive(_88); _88 = _2; -- _89 = Eq(_88, const 0_u64); -- assert(!move _89, "attempt to calculate the remainder of `{}` with a divisor of zero", _87) -> [success: bb22, unwind continue]; -+ _89 = _20; -+ assert(!_20, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb22, unwind continue]; - } - - bb22: { -- _86 = Rem(move _87, move _88); -+ _86 = _22; +- _86 = BitOr(move _87, move _88); ++ _86 = _31; StorageDead(_88); StorageDead(_87); - StorageLive(_90); - _90 = _3; -- _85 = Add(move _86, move _90); -+ _85 = Add(_22, move _90); - StorageDead(_90); - StorageDead(_86); - _84 = opaque::(move _85) -> [return: bb23, unwind continue]; - } - - bb23: { - StorageDead(_85); - StorageDead(_84); - StorageLive(_91); - StorageLive(_92); - StorageLive(_93); - StorageLive(_94); - _94 = _1; - StorageLive(_95); - _95 = _2; -- _93 = BitAnd(move _94, move _95); -+ _93 = _27; - StorageDead(_95); - StorageDead(_94); - StorageLive(_96); - _96 = _3; -- _92 = Add(move _93, move _96); -+ _92 = Add(_27, move _96); - StorageDead(_96); - StorageDead(_93); - _91 = opaque::(move _92) -> [return: bb24, unwind continue]; - } - - bb24: { - StorageDead(_92); - StorageDead(_91); - StorageLive(_97); - StorageLive(_98); - StorageLive(_99); - StorageLive(_100); - _100 = _1; - StorageLive(_101); - _101 = _2; -- _99 = BitOr(move _100, move _101); -+ _99 = _31; - StorageDead(_101); - StorageDead(_100); - StorageLive(_102); - _102 = _3; -- _98 = Add(move _99, move _102); -+ _98 = Add(_31, move _102); - StorageDead(_102); - StorageDead(_99); - _97 = opaque::(move _98) -> [return: bb25, unwind continue]; +- _85 = opaque::(move _86) -> [return: bb25, unwind continue]; ++ _85 = opaque::(_31) -> [return: bb25, unwind continue]; } bb25: { + StorageDead(_86); + StorageDead(_85); + StorageLive(_89); + StorageLive(_90); + StorageLive(_91); + _91 = _1; + StorageLive(_92); + _92 = _2; +- _90 = BitXor(move _91, move _92); ++ _90 = _35; + StorageDead(_92); + StorageDead(_91); +- _89 = opaque::(move _90) -> [return: bb26, unwind continue]; ++ _89 = opaque::(_35) -> [return: bb26, unwind continue]; + } + + bb26: { + StorageDead(_90); + StorageDead(_89); + StorageLive(_93); + StorageLive(_94); + StorageLive(_95); + _95 = _1; + StorageLive(_96); + _96 = _2; +- _94 = Shl(move _95, move _96); ++ _94 = _39; + StorageDead(_96); + StorageDead(_95); +- _93 = opaque::(move _94) -> [return: bb27, unwind continue]; ++ _93 = opaque::(_39) -> [return: bb27, unwind continue]; + } + + bb27: { + StorageDead(_94); + StorageDead(_93); + StorageLive(_97); + StorageLive(_98); + StorageLive(_99); + _99 = _1; + StorageLive(_100); + _100 = _2; +- _98 = Shr(move _99, move _100); ++ _98 = _43; + StorageDead(_100); + StorageDead(_99); +- _97 = opaque::(move _98) -> [return: bb28, unwind continue]; ++ _97 = opaque::(_43) -> [return: bb28, unwind continue]; + } + + bb28: { StorageDead(_98); StorageDead(_97); + StorageLive(_101); + StorageLive(_102); StorageLive(_103); + _103 = _1; +- _102 = move _103 as u32 (IntToInt); ++ _102 = _47; + StorageDead(_103); +- _101 = opaque::(move _102) -> [return: bb29, unwind continue]; ++ _101 = opaque::(_47) -> [return: bb29, unwind continue]; + } + + bb29: { + StorageDead(_102); + StorageDead(_101); StorageLive(_104); StorageLive(_105); StorageLive(_106); _106 = _1; - StorageLive(_107); - _107 = _2; -- _105 = BitXor(move _106, move _107); -+ _105 = _35; - StorageDead(_107); +- _105 = move _106 as f32 (IntToFloat); ++ _105 = _50; StorageDead(_106); - StorageLive(_108); - _108 = _3; -- _104 = Add(move _105, move _108); -+ _104 = Add(_35, move _108); - StorageDead(_108); - StorageDead(_105); - _103 = opaque::(move _104) -> [return: bb26, unwind continue]; +- _104 = opaque::(move _105) -> [return: bb30, unwind continue]; ++ _104 = opaque::(_50) -> [return: bb30, unwind continue]; } - bb26: { + bb30: { + StorageDead(_105); StorageDead(_104); - StorageDead(_103); + StorageLive(_107); + StorageLive(_108); StorageLive(_109); + _109 = _1; +- _108 = S::(move _109); ++ _108 = _53; + StorageDead(_109); +- _107 = opaque::>(move _108) -> [return: bb31, unwind continue]; ++ _107 = opaque::>(_53) -> [return: bb31, unwind continue]; + } + + bb31: { + StorageDead(_108); + StorageDead(_107); StorageLive(_110); StorageLive(_111); StorageLive(_112); - _112 = _1; StorageLive(_113); - _113 = _2; -- _111 = Shl(move _112, move _113); -+ _111 = _39; + _113 = _1; +- _112 = S::(move _113); ++ _112 = _53; StorageDead(_113); - StorageDead(_112); - StorageLive(_114); - _114 = _3; -- _110 = Add(move _111, move _114); -+ _110 = Add(_39, move _114); - StorageDead(_114); - StorageDead(_111); - _109 = opaque::(move _110) -> [return: bb27, unwind continue]; +- _111 = (_112.0: u64); +- _110 = opaque::(move _111) -> [return: bb32, unwind continue]; ++ _111 = _1; ++ _110 = opaque::(_1) -> [return: bb32, unwind continue]; } - bb27: { + bb32: { + StorageDead(_111); + StorageDead(_112); StorageDead(_110); - StorageDead(_109); - StorageLive(_115); + StorageLive(_114); +- StorageLive(_115); ++ nop; StorageLive(_116); StorageLive(_117); + _117 = _1; StorageLive(_118); - _118 = _1; + _118 = _2; +- _116 = Mul(move _117, move _118); ++ _116 = _9; + StorageDead(_118); + StorageDead(_117); StorageLive(_119); _119 = _2; -- _117 = Shr(move _118, move _119); -+ _117 = _43; +- _115 = Sub(move _116, move _119); ++ _115 = Sub(_9, _2); StorageDead(_119); - StorageDead(_118); - StorageLive(_120); - _120 = _3; -- _116 = Add(move _117, move _120); -+ _116 = Add(_43, move _120); - StorageDead(_120); - StorageDead(_117); - _115 = opaque::(move _116) -> [return: bb28, unwind continue]; + StorageDead(_116); +- _114 = opaque::(move _115) -> [return: bb33, unwind continue]; ++ _114 = opaque::(_115) -> [return: bb33, unwind continue]; } - bb28: { - StorageDead(_116); - StorageDead(_115); + bb33: { +- StorageDead(_115); ++ nop; + StorageDead(_114); + StorageLive(_120); StorageLive(_121); StorageLive(_122); StorageLive(_123); _123 = _1; -- _122 = S::(move _123); -+ _122 = _53; - StorageDead(_123); -- _121 = opaque::>(move _122) -> [return: bb29, unwind continue]; -+ _121 = opaque::>(_53) -> [return: bb29, unwind continue]; - } - - bb29: { - StorageDead(_122); - StorageDead(_121); StorageLive(_124); - StorageLive(_125); - StorageLive(_126); - StorageLive(_127); - _127 = _1; -- _126 = S::(move _127); -+ _126 = _53; - StorageDead(_127); -- _125 = (_126.0: u64); -- _124 = opaque::(move _125) -> [return: bb30, unwind continue]; -+ _125 = _1; -+ _124 = opaque::(_1) -> [return: bb30, unwind continue]; - } - - bb30: { - StorageDead(_125); - StorageDead(_126); + _124 = _2; +- _122 = Mul(move _123, move _124); ++ _122 = _9; StorageDead(_124); -- StorageLive(_128); -+ nop; - _128 = &_3; - StorageLive(_129); -- StorageLive(_130); -- StorageLive(_131); -+ nop; -+ nop; - _131 = (*_128); - StorageLive(_132); - _132 = _1; -- _130 = Add(move _131, move _132); -+ _130 = Add(_131, _1); - StorageDead(_132); -- StorageDead(_131); -- _129 = opaque::(move _130) -> [return: bb31, unwind continue]; -+ nop; -+ _129 = opaque::(_130) -> [return: bb31, unwind continue]; - } - - bb31: { -- StorageDead(_130); -+ nop; - StorageDead(_129); - StorageLive(_133); - StorageLive(_134); - StorageLive(_135); -- _135 = (*_128); -+ _135 = _131; - StorageLive(_136); - _136 = _1; -- _134 = Add(move _135, move _136); -+ _134 = _130; - StorageDead(_136); - StorageDead(_135); -- _133 = opaque::(move _134) -> [return: bb32, unwind continue]; -+ _133 = opaque::(_130) -> [return: bb32, unwind continue]; - } - - bb32: { - StorageDead(_134); - StorageDead(_133); -- StorageLive(_137); -+ nop; - _137 = &mut _3; - StorageLive(_138); - StorageLive(_139); - StorageLive(_140); - _140 = (*_137); - StorageLive(_141); - _141 = _1; -- _139 = Add(move _140, move _141); -+ _139 = Add(move _140, _1); - StorageDead(_141); - StorageDead(_140); - _138 = opaque::(move _139) -> [return: bb33, unwind continue]; - } - - bb33: { - StorageDead(_139); - StorageDead(_138); - StorageLive(_142); - StorageLive(_143); - StorageLive(_144); - _144 = (*_137); - StorageLive(_145); - _145 = _1; -- _143 = Add(move _144, move _145); -+ _143 = Add(move _144, _1); - StorageDead(_145); - StorageDead(_144); - _142 = opaque::(move _143) -> [return: bb34, unwind continue]; + StorageDead(_123); + StorageLive(_125); + _125 = _2; +- _121 = Sub(move _122, move _125); ++ _121 = _115; + StorageDead(_125); + StorageDead(_122); +- _120 = opaque::(move _121) -> [return: bb34, unwind continue]; ++ _120 = opaque::(_115) -> [return: bb34, unwind continue]; } bb34: { - StorageDead(_143); - StorageDead(_142); - StorageLive(_146); -- StorageLive(_147); + StorageDead(_121); + StorageDead(_120); +- StorageLive(_126); + nop; - _147 = &raw const _3; - StorageLive(_148); - StorageLive(_149); - StorageLive(_150); - _150 = (*_147); - StorageLive(_151); - _151 = _1; -- _149 = Add(move _150, move _151); -+ _149 = Add(move _150, _1); - StorageDead(_151); - StorageDead(_150); - _148 = opaque::(move _149) -> [return: bb35, unwind continue]; + _126 = &_3; + StorageLive(_127); +- StorageLive(_128); +- StorageLive(_129); ++ nop; ++ nop; + _129 = (*_126); + StorageLive(_130); + _130 = _1; +- _128 = Add(move _129, move _130); ++ _128 = Add(_129, _1); + StorageDead(_130); +- StorageDead(_129); +- _127 = opaque::(move _128) -> [return: bb35, unwind continue]; ++ nop; ++ _127 = opaque::(_128) -> [return: bb35, unwind continue]; } bb35: { - StorageDead(_149); - StorageDead(_148); - StorageLive(_152); - StorageLive(_153); - StorageLive(_154); - _154 = (*_147); - StorageLive(_155); - _155 = _1; -- _153 = Add(move _154, move _155); -+ _153 = Add(move _154, _1); - StorageDead(_155); - StorageDead(_154); - _152 = opaque::(move _153) -> [return: bb36, unwind continue]; +- StorageDead(_128); ++ nop; + StorageDead(_127); + StorageLive(_131); + StorageLive(_132); + StorageLive(_133); +- _133 = (*_126); ++ _133 = _129; + StorageLive(_134); + _134 = _1; +- _132 = Add(move _133, move _134); ++ _132 = _128; + StorageDead(_134); + StorageDead(_133); +- _131 = opaque::(move _132) -> [return: bb36, unwind continue]; ++ _131 = opaque::(_128) -> [return: bb36, unwind continue]; } bb36: { - StorageDead(_153); - StorageDead(_152); -- StorageLive(_156); + StorageDead(_132); + StorageDead(_131); +- StorageLive(_135); + nop; - _156 = &raw mut _3; - StorageLive(_157); - StorageLive(_158); - StorageLive(_159); - _159 = (*_156); - StorageLive(_160); - _160 = _1; -- _158 = Add(move _159, move _160); -+ _158 = Add(move _159, _1); - StorageDead(_160); - StorageDead(_159); - _157 = opaque::(move _158) -> [return: bb37, unwind continue]; + _135 = &mut _3; + StorageLive(_136); + StorageLive(_137); + StorageLive(_138); + _138 = (*_135); + StorageLive(_139); + _139 = _1; +- _137 = Add(move _138, move _139); ++ _137 = Add(move _138, _1); + StorageDead(_139); + StorageDead(_138); + _136 = opaque::(move _137) -> [return: bb37, unwind continue]; } bb37: { - StorageDead(_158); - StorageDead(_157); - StorageLive(_161); - StorageLive(_162); - StorageLive(_163); - _163 = (*_156); - StorageLive(_164); - _164 = _1; -- _162 = Add(move _163, move _164); -+ _162 = Add(move _163, _1); - StorageDead(_164); - StorageDead(_163); - _161 = opaque::(move _162) -> [return: bb38, unwind continue]; + StorageDead(_137); + StorageDead(_136); + StorageLive(_140); + StorageLive(_141); + StorageLive(_142); + _142 = (*_135); + StorageLive(_143); + _143 = _1; +- _141 = Add(move _142, move _143); ++ _141 = Add(move _142, _1); + StorageDead(_143); + StorageDead(_142); + _140 = opaque::(move _141) -> [return: bb38, unwind continue]; } bb38: { - StorageDead(_162); - StorageDead(_161); - _146 = const (); -- StorageDead(_156); -- StorageDead(_147); + StorageDead(_141); + StorageDead(_140); + StorageLive(_144); +- StorageLive(_145); + nop; -+ nop; - StorageDead(_146); -- StorageLive(_165); -+ nop; - _165 = &_3; - StorageLive(_166); -- StorageLive(_167); -- StorageLive(_168); -+ nop; -+ nop; - _168 = (*_165); - StorageLive(_169); - _169 = _1; -- _167 = Add(move _168, move _169); -+ _167 = Add(_168, _1); - StorageDead(_169); -- StorageDead(_168); -- _166 = opaque::(move _167) -> [return: bb39, unwind continue]; -+ nop; -+ _166 = opaque::(_167) -> [return: bb39, unwind continue]; + _145 = &raw const _3; + StorageLive(_146); + StorageLive(_147); + StorageLive(_148); + _148 = (*_145); + StorageLive(_149); + _149 = _1; +- _147 = Add(move _148, move _149); ++ _147 = Add(move _148, _1); + StorageDead(_149); + StorageDead(_148); + _146 = opaque::(move _147) -> [return: bb39, unwind continue]; } bb39: { -- StorageDead(_167); -+ nop; - StorageDead(_166); - StorageLive(_170); - StorageLive(_171); - StorageLive(_172); -- _172 = (*_165); -+ _172 = _168; - StorageLive(_173); - _173 = _1; -- _171 = Add(move _172, move _173); -+ _171 = _167; - StorageDead(_173); - StorageDead(_172); -- _170 = opaque::(move _171) -> [return: bb40, unwind continue]; -+ _170 = opaque::(_167) -> [return: bb40, unwind continue]; + StorageDead(_147); + StorageDead(_146); + StorageLive(_150); + StorageLive(_151); + StorageLive(_152); + _152 = (*_145); + StorageLive(_153); + _153 = _1; +- _151 = Add(move _152, move _153); ++ _151 = Add(move _152, _1); + StorageDead(_153); + StorageDead(_152); + _150 = opaque::(move _151) -> [return: bb40, unwind continue]; } bb40: { + StorageDead(_151); + StorageDead(_150); +- StorageLive(_154); ++ nop; + _154 = &raw mut _3; + StorageLive(_155); + StorageLive(_156); + StorageLive(_157); + _157 = (*_154); + StorageLive(_158); + _158 = _1; +- _156 = Add(move _157, move _158); ++ _156 = Add(move _157, _1); + StorageDead(_158); + StorageDead(_157); + _155 = opaque::(move _156) -> [return: bb41, unwind continue]; + } + + bb41: { + StorageDead(_156); + StorageDead(_155); + StorageLive(_159); + StorageLive(_160); + StorageLive(_161); + _161 = (*_154); + StorageLive(_162); + _162 = _1; +- _160 = Add(move _161, move _162); ++ _160 = Add(move _161, _1); + StorageDead(_162); + StorageDead(_161); + _159 = opaque::(move _160) -> [return: bb42, unwind continue]; + } + + bb42: { + StorageDead(_160); + StorageDead(_159); + _144 = const (); +- StorageDead(_154); +- StorageDead(_145); ++ nop; ++ nop; + StorageDead(_144); +- StorageLive(_163); ++ nop; + _163 = &_3; + StorageLive(_164); +- StorageLive(_165); +- StorageLive(_166); ++ nop; ++ nop; + _166 = (*_163); + StorageLive(_167); + _167 = _1; +- _165 = Add(move _166, move _167); ++ _165 = Add(_166, _1); + StorageDead(_167); +- StorageDead(_166); +- _164 = opaque::(move _165) -> [return: bb43, unwind continue]; ++ nop; ++ _164 = opaque::(_165) -> [return: bb43, unwind continue]; + } + + bb43: { +- StorageDead(_165); ++ nop; + StorageDead(_164); + StorageLive(_168); + StorageLive(_169); + StorageLive(_170); +- _170 = (*_163); ++ _170 = _166; + StorageLive(_171); + _171 = _1; +- _169 = Add(move _170, move _171); ++ _169 = _165; StorageDead(_171); StorageDead(_170); +- _168 = opaque::(move _169) -> [return: bb44, unwind continue]; ++ _168 = opaque::(_165) -> [return: bb44, unwind continue]; + } + + bb44: { + StorageDead(_169); + StorageDead(_168); _0 = const (); -- StorageDead(_165); -- StorageDead(_137); -- StorageDead(_128); +- StorageDead(_163); +- StorageDead(_135); +- StorageDead(_126); + nop; + nop; + nop;