Use -Cdebug-assertions instead of -Coverlow-checks in tests

Author: Centri3

compiler/rustc_mir_transform/src/simplify_pow_of_two.rs

@@ -222,7 +222,7 @@ impl<'tcx> MirPass<'tcx> for SimplifyPowOfTwo {
                         loc,
                         overflowed.into(),
                         Rvalue::BinaryOp(
-                            BinOp::BitAnd,
+                            BinOp::BitOr,
                             Box::new((
                                 Operand::Copy(shl_eq_shr.into()),
                                 Operand::Copy(shl_result.into()),
@@ -234,7 +234,7 @@ impl<'tcx> MirPass<'tcx> for SimplifyPowOfTwo {
                         i,
                         TerminatorKind::Assert {
                             cond: Operand::Copy(overflowed.into()),
-                            expected: true,
+                            expected: false,
                             msg: Box::new(AssertMessage::Overflow(
                                 // For consistency with the previous error message, though
                                 // it's technically incorrect

tests/mir-opt/simplify_pow_of_two_no_overflow_checks.rs

@@ -1,4 +1,4 @@
-// compile-flags: -Coverflow-checks=false
+// compile-flags: -Cdebug-assertions=false
 
 // EMIT_MIR simplify_pow_of_two_no_overflow_checks.slow_2_u.SimplifyPowOfTwo.diff
 fn slow_2_u(a: u32) -> u32 {

tests/mir-opt/simplify_pow_of_two_no_overflow_checks.slow_256_i.SimplifyPowOfTwo.diff

@@ -15,7 +15,7 @@
       bb0: {
           StorageLive(_2);
           _2 = _1;
--         _0 = core::num::<impl i32>::pow(const 256_i32, move _2) -> [return: bb1, unwind unreachable];
+-         _0 = core::num::<impl i32>::pow(const 256_i32, move _2) -> [return: bb1, unwind continue];
 +         _3 = CheckedMul(move _2, const 8_u32);
 +         _4 = Lt((_3.0: u32), const 32_u32);
 +         _5 = BitOr((_3.1: bool), _4);

tests/mir-opt/simplify_pow_of_two_no_overflow_checks.slow_256_u.SimplifyPowOfTwo.diff

@@ -15,7 +15,7 @@
       bb0: {
           StorageLive(_2);
           _2 = _1;
--         _0 = core::num::<impl u32>::pow(const 256_u32, move _2) -> [return: bb1, unwind unreachable];
+-         _0 = core::num::<impl u32>::pow(const 256_u32, move _2) -> [return: bb1, unwind continue];
 +         _3 = CheckedMul(move _2, const 8_u32);
 +         _4 = Lt((_3.0: u32), const 32_u32);
 +         _5 = BitOr((_3.1: bool), _4);

tests/mir-opt/simplify_pow_of_two_no_overflow_checks.slow_2_i.SimplifyPowOfTwo.diff

@@ -15,7 +15,7 @@
       bb0: {
           StorageLive(_2);
           _2 = _1;
--         _0 = core::num::<impl i32>::pow(const 2_i32, move _2) -> [return: bb1, unwind unreachable];
+-         _0 = core::num::<impl i32>::pow(const 2_i32, move _2) -> [return: bb1, unwind continue];
 +         _3 = CheckedMul(move _2, const 1_u32);
 +         _4 = Lt((_3.0: u32), const 32_u32);
 +         _5 = BitOr((_3.1: bool), _4);

tests/mir-opt/simplify_pow_of_two_no_overflow_checks.slow_2_u.SimplifyPowOfTwo.diff

@@ -15,7 +15,7 @@
       bb0: {
           StorageLive(_2);
           _2 = _1;
--         _0 = core::num::<impl u32>::pow(const 2_u32, move _2) -> [return: bb1, unwind unreachable];
+-         _0 = core::num::<impl u32>::pow(const 2_u32, move _2) -> [return: bb1, unwind continue];
 +         _3 = CheckedMul(move _2, const 1_u32);
 +         _4 = Lt((_3.0: u32), const 32_u32);
 +         _5 = BitOr((_3.1: bool), _4);

tests/mir-opt/simplify_pow_of_two_no_overflow_checks.slow_4_i.SimplifyPowOfTwo.diff

@@ -15,7 +15,7 @@
       bb0: {
           StorageLive(_2);
           _2 = _1;
--         _0 = core::num::<impl i32>::pow(const 4_i32, move _2) -> [return: bb1, unwind unreachable];
+-         _0 = core::num::<impl i32>::pow(const 4_i32, move _2) -> [return: bb1, unwind continue];
 +         _3 = CheckedMul(move _2, const 2_u32);
 +         _4 = Lt((_3.0: u32), const 32_u32);
 +         _5 = BitOr((_3.1: bool), _4);

tests/mir-opt/simplify_pow_of_two_no_overflow_checks.slow_4_u.SimplifyPowOfTwo.diff

@@ -15,7 +15,7 @@
       bb0: {
           StorageLive(_2);
           _2 = _1;
--         _0 = core::num::<impl u32>::pow(const 4_u32, move _2) -> [return: bb1, unwind unreachable];
+-         _0 = core::num::<impl u32>::pow(const 4_u32, move _2) -> [return: bb1, unwind continue];
 +         _3 = CheckedMul(move _2, const 2_u32);
 +         _4 = Lt((_3.0: u32), const 32_u32);
 +         _5 = BitOr((_3.1: bool), _4);

tests/mir-opt/simplify_pow_of_two_overflow_checks.rs

@@ -1,4 +1,4 @@
-// compile-flags: -Coverflow-checks=true
+// compile-flags: -Cdebug-assertions=true
 
 // EMIT_MIR simplify_pow_of_two_overflow_checks.slow_2_u.SimplifyPowOfTwo.diff
 fn slow_2_u(a: u32) -> u32 {

tests/mir-opt/simplify_pow_of_two_overflow_checks.slow_256_i.SimplifyPowOfTwo.diff

@@ -11,19 +11,25 @@
 +     let mut _6: i32;
 +     let mut _7: u32;
 +     let mut _8: i32;
++     let mut _9: i32;
++     let mut _10: bool;
++     let mut _11: bool;
 
       bb0: {
           StorageLive(_2);
           _2 = _1;
--         _0 = core::num::<impl i32>::pow(const 256_i32, move _2) -> [return: bb1, unwind unreachable];
+-         _0 = core::num::<impl i32>::pow(const 256_i32, move _2) -> [return: bb1, unwind continue];
 +         _3 = CheckedMul(move _2, const 8_u32);
 +         _4 = Lt((_3.0: u32), const 32_u32);
 +         _5 = BitOr((_3.1: bool), _4);
 +         _6 = _5 as i32 (IntToInt);
 +         _7 = Shl(const 1_u32, (_3.0: u32));
 +         _8 = _7 as i32 (IntToInt);
 +         _0 = MulUnchecked(_8, _6);
-+         goto -> bb1;
++         _9 = Shr(_8, (_3.0: u32));
++         _10 = Eq(_8, _9);
++         _11 = BitOr(_10, _4);
++         assert(!_11, "attempt to compute `{} * {}`, which would overflow", const 1_u32, (_3.0: u32)) -> [success: bb1, unwind continue];
       }
 
       bb1: {

tests/mir-opt/simplify_pow_of_two_overflow_checks.slow_256_u.SimplifyPowOfTwo.diff

@@ -11,19 +11,25 @@
 +     let mut _6: u32;
 +     let mut _7: u32;
 +     let mut _8: u32;
++     let mut _9: u32;
++     let mut _10: bool;
++     let mut _11: bool;
 
       bb0: {
           StorageLive(_2);
           _2 = _1;
--         _0 = core::num::<impl u32>::pow(const 256_u32, move _2) -> [return: bb1, unwind unreachable];
+-         _0 = core::num::<impl u32>::pow(const 256_u32, move _2) -> [return: bb1, unwind continue];
 +         _3 = CheckedMul(move _2, const 8_u32);
 +         _4 = Lt((_3.0: u32), const 32_u32);
 +         _5 = BitOr((_3.1: bool), _4);
 +         _6 = _5 as u32 (IntToInt);
 +         _7 = Shl(const 1_u32, (_3.0: u32));
 +         _8 = _7 as u32 (IntToInt);
 +         _0 = MulUnchecked(_8, _6);
-+         goto -> bb1;
++         _9 = Shr(_8, (_3.0: u32));
++         _10 = Eq(_8, _9);
++         _11 = BitOr(_10, _4);
++         assert(!_11, "attempt to compute `{} * {}`, which would overflow", const 1_u32, (_3.0: u32)) -> [success: bb1, unwind continue];
       }
 
       bb1: {

tests/mir-opt/simplify_pow_of_two_overflow_checks.slow_2_i.SimplifyPowOfTwo.diff

@@ -11,19 +11,25 @@
 +     let mut _6: i32;
 +     let mut _7: u32;
 +     let mut _8: i32;
++     let mut _9: i32;
++     let mut _10: bool;
++     let mut _11: bool;
 
       bb0: {
           StorageLive(_2);
           _2 = _1;
--         _0 = core::num::<impl i32>::pow(const 2_i32, move _2) -> [return: bb1, unwind unreachable];
+-         _0 = core::num::<impl i32>::pow(const 2_i32, move _2) -> [return: bb1, unwind continue];
 +         _3 = CheckedMul(move _2, const 1_u32);
 +         _4 = Lt((_3.0: u32), const 32_u32);
 +         _5 = BitOr((_3.1: bool), _4);
 +         _6 = _5 as i32 (IntToInt);
 +         _7 = Shl(const 1_u32, (_3.0: u32));
 +         _8 = _7 as i32 (IntToInt);
 +         _0 = MulUnchecked(_8, _6);
-+         goto -> bb1;
++         _9 = Shr(_8, (_3.0: u32));
++         _10 = Eq(_8, _9);
++         _11 = BitOr(_10, _4);
++         assert(!_11, "attempt to compute `{} * {}`, which would overflow", const 1_u32, (_3.0: u32)) -> [success: bb1, unwind continue];
       }
 
       bb1: {

tests/mir-opt/simplify_pow_of_two_overflow_checks.slow_2_u.SimplifyPowOfTwo.diff

@@ -11,19 +11,25 @@
 +     let mut _6: u32;
 +     let mut _7: u32;
 +     let mut _8: u32;
++     let mut _9: u32;
++     let mut _10: bool;
++     let mut _11: bool;
 
       bb0: {
           StorageLive(_2);
           _2 = _1;
--         _0 = core::num::<impl u32>::pow(const 2_u32, move _2) -> [return: bb1, unwind unreachable];
+-         _0 = core::num::<impl u32>::pow(const 2_u32, move _2) -> [return: bb1, unwind continue];
 +         _3 = CheckedMul(move _2, const 1_u32);
 +         _4 = Lt((_3.0: u32), const 32_u32);
 +         _5 = BitOr((_3.1: bool), _4);
 +         _6 = _5 as u32 (IntToInt);
 +         _7 = Shl(const 1_u32, (_3.0: u32));
 +         _8 = _7 as u32 (IntToInt);
 +         _0 = MulUnchecked(_8, _6);
-+         goto -> bb1;
++         _9 = Shr(_8, (_3.0: u32));
++         _10 = Eq(_8, _9);
++         _11 = BitOr(_10, _4);
++         assert(!_11, "attempt to compute `{} * {}`, which would overflow", const 1_u32, (_3.0: u32)) -> [success: bb1, unwind continue];
       }
 
       bb1: {

tests/mir-opt/simplify_pow_of_two_overflow_checks.slow_4_i.SimplifyPowOfTwo.diff

@@ -11,19 +11,25 @@
 +     let mut _6: i32;
 +     let mut _7: u32;
 +     let mut _8: i32;
++     let mut _9: i32;
++     let mut _10: bool;
++     let mut _11: bool;
 
       bb0: {
           StorageLive(_2);
           _2 = _1;
--         _0 = core::num::<impl i32>::pow(const 4_i32, move _2) -> [return: bb1, unwind unreachable];
+-         _0 = core::num::<impl i32>::pow(const 4_i32, move _2) -> [return: bb1, unwind continue];
 +         _3 = CheckedMul(move _2, const 2_u32);
 +         _4 = Lt((_3.0: u32), const 32_u32);
 +         _5 = BitOr((_3.1: bool), _4);
 +         _6 = _5 as i32 (IntToInt);
 +         _7 = Shl(const 1_u32, (_3.0: u32));
 +         _8 = _7 as i32 (IntToInt);
 +         _0 = MulUnchecked(_8, _6);
-+         goto -> bb1;
++         _9 = Shr(_8, (_3.0: u32));
++         _10 = Eq(_8, _9);
++         _11 = BitOr(_10, _4);
++         assert(!_11, "attempt to compute `{} * {}`, which would overflow", const 1_u32, (_3.0: u32)) -> [success: bb1, unwind continue];
       }
 
       bb1: {

tests/mir-opt/simplify_pow_of_two_overflow_checks.slow_4_u.SimplifyPowOfTwo.diff

@@ -11,19 +11,25 @@
 +     let mut _6: u32;
 +     let mut _7: u32;
 +     let mut _8: u32;
++     let mut _9: u32;
++     let mut _10: bool;
++     let mut _11: bool;
 
       bb0: {
           StorageLive(_2);
           _2 = _1;
--         _0 = core::num::<impl u32>::pow(const 4_u32, move _2) -> [return: bb1, unwind unreachable];
+-         _0 = core::num::<impl u32>::pow(const 4_u32, move _2) -> [return: bb1, unwind continue];
 +         _3 = CheckedMul(move _2, const 2_u32);
 +         _4 = Lt((_3.0: u32), const 32_u32);
 +         _5 = BitOr((_3.1: bool), _4);
 +         _6 = _5 as u32 (IntToInt);
 +         _7 = Shl(const 1_u32, (_3.0: u32));
 +         _8 = _7 as u32 (IntToInt);
 +         _0 = MulUnchecked(_8, _6);
-+         goto -> bb1;
++         _9 = Shr(_8, (_3.0: u32));
++         _10 = Eq(_8, _9);
++         _11 = BitOr(_10, _4);
++         assert(!_11, "attempt to compute `{} * {}`, which would overflow", const 1_u32, (_3.0: u32)) -> [success: bb1, unwind continue];
       }
 
       bb1: {