Simplify binary ops.

19 files changed, 808 insertions, 431 deletions

diff --git a/compiler/rustc_mir_transform/src/gvn.rs b/compiler/rustc_mir_transform/src/gvn.rs
index dc3af038d80..3052369c3ca 100644
--- a/compiler/rustc_mir_transform/src/gvn.rs
+++ b/compiler/rustc_mir_transform/src/gvn.rs
@@ -345,11 +345,20 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
         Some(self.insert(Value::Constant { value, disambiguator }))
     }
 
+    fn insert_bool(&mut self, flag: bool) -> VnIndex {
+        // Booleans are deterministic.
+        self.insert(Value::Constant { value: Const::from_bool(self.tcx, flag), disambiguator: 0 })
+    }
+
     fn insert_scalar(&mut self, scalar: Scalar, ty: Ty<'tcx>) -> VnIndex {
         self.insert_constant(Const::from_scalar(self.tcx, scalar, ty))
             .expect("scalars are deterministic")
     }
 
+    fn insert_tuple(&mut self, values: Vec<VnIndex>) -> VnIndex {
+        self.insert(Value::Aggregate(AggregateTy::Tuple, VariantIdx::from_u32(0), values))
+    }
+
     #[instrument(level = "trace", skip(self), ret)]
     fn eval_to_const(&mut self, value: VnIndex) -> Option<OpTy<'tcx>> {
         use Value::*;
@@ -785,14 +794,26 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
                 Value::Cast { kind, value, from, to }
             }
             Rvalue::BinaryOp(op, box (ref mut lhs, ref mut rhs)) => {
+                let ty = lhs.ty(self.local_decls, self.tcx);
                 let lhs = self.simplify_operand(lhs, location);
                 let rhs = self.simplify_operand(rhs, location);
-                Value::BinaryOp(op, lhs?, rhs?)
+                let lhs = lhs?;
+                let rhs = rhs?;
+                if let Some(value) = self.simplify_binary(op, false, ty, lhs, rhs) {
+                    return Some(value);
+                }
+                Value::BinaryOp(op, lhs, rhs)
             }
             Rvalue::CheckedBinaryOp(op, box (ref mut lhs, ref mut rhs)) => {
+                let ty = lhs.ty(self.local_decls, self.tcx);
                 let lhs = self.simplify_operand(lhs, location);
                 let rhs = self.simplify_operand(rhs, location);
-                Value::CheckedBinaryOp(op, lhs?, rhs?)
+                let lhs = lhs?;
+                let rhs = rhs?;
+                if let Some(value) = self.simplify_binary(op, true, ty, lhs, rhs) {
+                    return Some(value);
+                }
+                Value::CheckedBinaryOp(op, lhs, rhs)
             }
             Rvalue::UnaryOp(op, ref mut arg) => {
                 let arg = self.simplify_operand(arg, location)?;
@@ -894,6 +915,92 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
 
         Some(self.insert(Value::Aggregate(ty, variant_index, fields)))
     }
+
+    #[instrument(level = "trace", skip(self), ret)]
+    fn simplify_binary(
+        &mut self,
+        op: BinOp,
+        checked: bool,
+        lhs_ty: Ty<'tcx>,
+        lhs: VnIndex,
+        rhs: VnIndex,
+    ) -> Option<VnIndex> {
+        // Floats are weird enough that none of the logic below applies.
+        let reasonable_ty =
+            lhs_ty.is_integral() || lhs_ty.is_bool() || lhs_ty.is_char() || lhs_ty.is_any_ptr();
+        if !reasonable_ty {
+            return None;
+        }
+
+        let layout = self.ecx.layout_of(lhs_ty).ok()?;
+
+        let as_bits = |value| {
+            let constant = self.evaluated[value].as_ref()?;
+            let scalar = self.ecx.read_scalar(constant).ok()?;
+            scalar.to_bits(constant.layout.size).ok()
+        };
+
+        // Represent the values as `Ok(bits)` or `Err(VnIndex)`.
+        let a = as_bits(lhs).ok_or(lhs);
+        let b = as_bits(rhs).ok_or(rhs);
+        let result = match (op, a, b) {
+            // Neutral elements.
+            (BinOp::Add | BinOp::BitOr | BinOp::BitXor, Ok(0), Err(p))
+            | (
+                BinOp::Add
+                | BinOp::BitOr
+                | BinOp::BitXor
+                | BinOp::Sub
+                | BinOp::Offset
+                | BinOp::Shl
+                | BinOp::Shr,
+                Err(p),
+                Ok(0),
+            )
+            | (BinOp::Mul, Ok(1), Err(p))
+            | (BinOp::Mul | BinOp::Div, Err(p), Ok(1)) => p,
+            // Attempt to simplify `x & ALL_ONES` to `x`, with `ALL_ONES` depending on type size.
+            (BinOp::BitAnd, Err(p), Ok(ones)) | (BinOp::BitAnd, Ok(ones), Err(p))
+                if ones == layout.size.truncate(u128::MAX)
+                    || (layout.ty.is_bool() && ones == 1) =>
+            {
+                p
+            }
+            // Absorbing elements.
+            (BinOp::Mul | BinOp::BitAnd, _, Ok(0))
+            | (BinOp::Rem, _, Ok(1))
+            | (
+                BinOp::Mul | BinOp::Div | BinOp::Rem | BinOp::BitAnd | BinOp::Shl | BinOp::Shr,
+                Ok(0),
+                _,
+            ) => self.insert_scalar(Scalar::from_uint(0u128, layout.size), lhs_ty),
+            // Attempt to simplify `x | ALL_ONES` to `ALL_ONES`.
+            (BinOp::BitOr, _, Ok(ones)) | (BinOp::BitOr, Ok(ones), _)
+                if ones == layout.size.truncate(u128::MAX)
+                    || (layout.ty.is_bool() && ones == 1) =>
+            {
+                self.insert_scalar(Scalar::from_uint(ones, layout.size), lhs_ty)
+            }
+            // Sub/Xor with itself.
+            (BinOp::Sub | BinOp::BitXor, a, b) if a == b => {
+                self.insert_scalar(Scalar::from_uint(0u128, layout.size), lhs_ty)
+            }
+            // Comparison:
+            // - if both operands can be computed as bits, just compare the bits;
+            // - if we proved that both operands have the same value, we can insert true/false;
+            // - otherwise, do nothing, as we do not try to prove inequality.
+            (BinOp::Eq, a, b) if (a.is_ok() && b.is_ok()) || a == b => self.insert_bool(a == b),
+            (BinOp::Ne, a, b) if (a.is_ok() && b.is_ok()) || a == b => self.insert_bool(a != b),
+            _ => return None,
+        };
+
+        if checked {
+            let false_val = self.insert_bool(false);
+            Some(self.insert_tuple(vec![result, false_val]))
+        } else {
+            Some(result)
+        }
+    }
 }
 
 fn op_to_prop_const<'tcx>(
diff --git a/tests/mir-opt/const_prop/boolean_identities.rs b/tests/mir-opt/const_prop/boolean_identities.rs
index f6575ac8e54..3b7ea25ad46 100644
--- a/tests/mir-opt/const_prop/boolean_identities.rs
+++ b/tests/mir-opt/const_prop/boolean_identities.rs
@@ -5,10 +5,9 @@ pub fn test(x: bool, y: bool) -> bool {
     // CHECK-LABEL: fn test(
     // CHECK: debug a => [[a:_.*]];
     // CHECK: debug b => [[b:_.*]];
-    // FIXME(cjgillot) simplify algebraic identity
-    // CHECK-NOT: [[a]] = const true;
-    // CHECK-NOT: [[b]] = const false;
-    // CHECK-NOT: _0 = const false;
+    // CHECK: [[a]] = const true;
+    // CHECK: [[b]] = const false;
+    // CHECK: _0 = const false;
     let a = (y | true);
     let b = (x & false);
     a & b
diff --git a/tests/mir-opt/const_prop/boolean_identities.test.GVN.diff b/tests/mir-opt/const_prop/boolean_identities.test.GVN.diff
index eca87af7527..0bd8413289e 100644
--- a/tests/mir-opt/const_prop/boolean_identities.test.GVN.diff
+++ b/tests/mir-opt/const_prop/boolean_identities.test.GVN.diff
@@ -24,21 +24,23 @@
           StorageLive(_4);
           _4 = _2;
 -         _3 = BitOr(move _4, const true);
-+         _3 = BitOr(_2, const true);
++         _3 = const true;
           StorageDead(_4);
 -         StorageLive(_5);
 +         nop;
           StorageLive(_6);
           _6 = _1;
 -         _5 = BitAnd(move _6, const false);
-+         _5 = BitAnd(_1, const false);
++         _5 = const false;
           StorageDead(_6);
           StorageLive(_7);
-          _7 = _3;
+-         _7 = _3;
++         _7 = const true;
           StorageLive(_8);
-          _8 = _5;
+-         _8 = _5;
 -         _0 = BitAnd(move _7, move _8);
-+         _0 = BitAnd(_3, _5);
++         _8 = const false;
++         _0 = const false;
           StorageDead(_8);
           StorageDead(_7);
 -         StorageDead(_5);
diff --git a/tests/mir-opt/const_prop/boxes.main.GVN.panic-abort.diff b/tests/mir-opt/const_prop/boxes.main.GVN.panic-abort.diff
index b3fdaa5ee82..59ee38f5a2b 100644
--- a/tests/mir-opt/const_prop/boxes.main.GVN.panic-abort.diff
+++ b/tests/mir-opt/const_prop/boxes.main.GVN.panic-abort.diff
@@ -20,7 +20,8 @@
   
       bb0: {
           StorageLive(_1);
-          StorageLive(_2);
+-         StorageLive(_2);
++         nop;
           StorageLive(_3);
 -         _4 = SizeOf(i32);
 -         _5 = AlignOf(i32);
@@ -39,8 +40,10 @@
           StorageDead(_7);
           _9 = (((_3.0: std::ptr::Unique<i32>).0: std::ptr::NonNull<i32>).0: *const i32);
           _2 = (*_9);
-          _1 = Add(move _2, const 0_i32);
-          StorageDead(_2);
+-         _1 = Add(move _2, const 0_i32);
+-         StorageDead(_2);
++         _1 = _2;
++         nop;
           drop(_3) -> [return: bb2, unwind unreachable];
       }
   
diff --git a/tests/mir-opt/const_prop/boxes.main.GVN.panic-unwind.diff b/tests/mir-opt/const_prop/boxes.main.GVN.panic-unwind.diff
index d0350c97253..9d87bd809d1 100644
--- a/tests/mir-opt/const_prop/boxes.main.GVN.panic-unwind.diff
+++ b/tests/mir-opt/const_prop/boxes.main.GVN.panic-unwind.diff
@@ -20,7 +20,8 @@
   
       bb0: {
           StorageLive(_1);
-          StorageLive(_2);
+-         StorageLive(_2);
++         nop;
           StorageLive(_3);
 -         _4 = SizeOf(i32);
 -         _5 = AlignOf(i32);
@@ -39,8 +40,10 @@
           StorageDead(_7);
           _9 = (((_3.0: std::ptr::Unique<i32>).0: std::ptr::NonNull<i32>).0: *const i32);
           _2 = (*_9);
-          _1 = Add(move _2, const 0_i32);
-          StorageDead(_2);
+-         _1 = Add(move _2, const 0_i32);
+-         StorageDead(_2);
++         _1 = _2;
++         nop;
           drop(_3) -> [return: bb2, unwind: bb3];
       }
   
diff --git a/tests/mir-opt/const_prop/boxes.rs b/tests/mir-opt/const_prop/boxes.rs
index 5227d7b8b8b..d2d61f86d5e 100644
--- a/tests/mir-opt/const_prop/boxes.rs
+++ b/tests/mir-opt/const_prop/boxes.rs
@@ -12,7 +12,7 @@ fn main() {
     // CHECK: debug x => [[x:_.*]];
     // CHECK: (*{{_.*}}) = const 42_i32;
     // CHECK: [[tmp:_.*]] = (*{{_.*}});
-    // CHECK: [[x]] = Add(move [[tmp]], const 0_i32);
+    // CHECK: [[x]] = [[tmp]];
     let x = *(#[rustc_box]
     Box::new(42))
         + 0;
diff --git a/tests/mir-opt/const_prop/mult_by_zero.rs b/tests/mir-opt/const_prop/mult_by_zero.rs
index 2fdb75c3100..b8afaeef43f 100644
--- a/tests/mir-opt/const_prop/mult_by_zero.rs
+++ b/tests/mir-opt/const_prop/mult_by_zero.rs
@@ -3,8 +3,7 @@
 // EMIT_MIR mult_by_zero.test.GVN.diff
 fn test(x: i32) -> i32 {
     // CHECK: fn test(
-    // FIXME(cjgillot) simplify algebraic identity
-    // CHECK-NOT: _0 = const 0_i32;
+    // CHECK: _0 = const 0_i32;
     x * 0
 }
 
diff --git a/tests/mir-opt/const_prop/mult_by_zero.test.GVN.diff b/tests/mir-opt/const_prop/mult_by_zero.test.GVN.diff
index e9fb34749c1..6c2aab45d48 100644
--- a/tests/mir-opt/const_prop/mult_by_zero.test.GVN.diff
+++ b/tests/mir-opt/const_prop/mult_by_zero.test.GVN.diff
@@ -10,7 +10,7 @@
           StorageLive(_2);
           _2 = _1;
 -         _0 = Mul(move _2, const 0_i32);
-+         _0 = Mul(_1, const 0_i32);
++         _0 = const 0_i32;
           StorageDead(_2);
           return;
       }
diff --git a/tests/mir-opt/gvn.arithmetic.GVN.panic-abort.diff b/tests/mir-opt/gvn.arithmetic.GVN.panic-abort.diff
index d524ad242fe..84eb6c5cfe8 100644
--- a/tests/mir-opt/gvn.arithmetic.GVN.panic-abort.diff
+++ b/tests/mir-opt/gvn.arithmetic.GVN.panic-abort.diff
@@ -13,13 +13,13 @@
       let _8: ();
       let mut _9: u64;
       let mut _10: u64;
-      let _11: ();
-      let mut _12: u64;
+      let mut _11: u64;
+      let _12: ();
       let mut _13: u64;
-      let _14: ();
-      let mut _15: u64;
+      let mut _14: u64;
+      let _15: ();
       let mut _16: u64;
-      let mut _17: bool;
+      let mut _17: u64;
       let _18: ();
       let mut _19: u64;
       let mut _20: u64;
@@ -51,18 +51,32 @@
       let _46: ();
       let mut _47: u64;
       let mut _48: u64;
-      let _49: ();
-      let mut _50: u64;
+      let mut _49: bool;
+      let _50: ();
       let mut _51: u64;
-      let _52: ();
-      let mut _53: u64;
+      let mut _52: u64;
+      let _53: ();
       let mut _54: u64;
-      let _55: ();
-      let mut _56: u64;
+      let mut _55: u64;
+      let _56: ();
       let mut _57: u64;
-      let _58: ();
-      let mut _59: u64;
+      let mut _58: u64;
+      let _59: ();
       let mut _60: u64;
+      let mut _61: u64;
+      let _62: ();
+      let mut _63: u64;
+      let mut _64: u64;
+      let _65: ();
+      let mut _66: u64;
+      let mut _67: u64;
+      let mut _68: u64;
+      let _69: ();
+      let mut _70: u64;
+      let mut _71: u64;
+      let _72: ();
+      let mut _73: u64;
+      let mut _74: u64;
   
       bb0: {
           StorageLive(_2);
@@ -70,9 +84,10 @@
           StorageLive(_4);
           _4 = _1;
 -         _3 = Add(move _4, const 0_u64);
-+         _3 = Add(_1, const 0_u64);
++         _3 = _1;
           StorageDead(_4);
-          _2 = opaque::<u64>(move _3) -> [return: bb1, unwind unreachable];
+-         _2 = opaque::<u64>(move _3) -> [return: bb1, unwind unreachable];
++         _2 = opaque::<u64>(_1) -> [return: bb1, unwind unreachable];
       }
   
       bb1: {
@@ -83,98 +98,101 @@
           StorageLive(_7);
           _7 = _1;
 -         _6 = Sub(move _7, const 0_u64);
-+         _6 = Sub(_1, const 0_u64);
++         _6 = _1;
           StorageDead(_7);
-          _5 = opaque::<u64>(move _6) -> [return: bb2, unwind unreachable];
+-         _5 = opaque::<u64>(move _6) -> [return: bb2, unwind unreachable];
++         _5 = opaque::<u64>(_1) -> [return: bb2, unwind unreachable];
       }
   
       bb2: {
           StorageDead(_6);
           StorageDead(_5);
           StorageLive(_8);
-          StorageLive(_9);
+-         StorageLive(_9);
++         nop;
           StorageLive(_10);
           _10 = _1;
--         _9 = Mul(move _10, const 0_u64);
-+         _9 = Mul(_1, const 0_u64);
+          StorageLive(_11);
+          _11 = _1;
+-         _9 = Sub(move _10, move _11);
++         _9 = const 0_u64;
+          StorageDead(_11);
           StorageDead(_10);
-          _8 = opaque::<u64>(move _9) -> [return: bb3, unwind unreachable];
+-         _8 = opaque::<u64>(move _9) -> [return: bb3, unwind unreachable];
++         _8 = opaque::<u64>(const 0_u64) -> [return: bb3, unwind unreachable];
       }
   
       bb3: {
-          StorageDead(_9);
+-         StorageDead(_9);
++         nop;
           StorageDead(_8);
-          StorageLive(_11);
           StorageLive(_12);
           StorageLive(_13);
-          _13 = _1;
--         _12 = Mul(move _13, const 1_u64);
-+         _12 = Mul(_1, const 1_u64);
-          StorageDead(_13);
-          _11 = opaque::<u64>(move _12) -> [return: bb4, unwind unreachable];
+          StorageLive(_14);
+          _14 = _1;
+-         _13 = Mul(move _14, const 0_u64);
++         _13 = const 0_u64;
+          StorageDead(_14);
+-         _12 = opaque::<u64>(move _13) -> [return: bb4, unwind unreachable];
++         _12 = opaque::<u64>(const 0_u64) -> [return: bb4, unwind unreachable];
       }
   
       bb4: {
+          StorageDead(_13);
           StorageDead(_12);
-          StorageDead(_11);
-          StorageLive(_14);
           StorageLive(_15);
           StorageLive(_16);
-          _16 = _1;
--         _17 = Eq(const 0_u64, const 0_u64);
--         assert(!move _17, "attempt to divide `{}` by zero", _16) -> [success: bb5, unwind unreachable];
-+         _17 = const true;
-+         assert(!const true, "attempt to divide `{}` by zero", _1) -> [success: bb5, unwind unreachable];
+          StorageLive(_17);
+          _17 = _1;
+-         _16 = Mul(move _17, const 1_u64);
++         _16 = _1;
+          StorageDead(_17);
+-         _15 = opaque::<u64>(move _16) -> [return: bb5, unwind unreachable];
++         _15 = opaque::<u64>(_1) -> [return: bb5, unwind unreachable];
       }
   
       bb5: {
--         _15 = Div(move _16, const 0_u64);
-+         _15 = Div(_1, const 0_u64);
           StorageDead(_16);
-          _14 = opaque::<u64>(move _15) -> [return: bb6, unwind unreachable];
-      }
-  
-      bb6: {
           StorageDead(_15);
-          StorageDead(_14);
           StorageLive(_18);
           StorageLive(_19);
           StorageLive(_20);
           _20 = _1;
--         _21 = Eq(const 1_u64, const 0_u64);
--         assert(!move _21, "attempt to divide `{}` by zero", _20) -> [success: bb7, unwind unreachable];
-+         _21 = const false;
-+         assert(!const false, "attempt to divide `{}` by zero", _1) -> [success: bb7, unwind unreachable];
+-         _21 = Eq(const 0_u64, const 0_u64);
+-         assert(!move _21, "attempt to divide `{}` by zero", _20) -> [success: bb6, unwind unreachable];
++         _21 = const true;
++         assert(!const true, "attempt to divide `{}` by zero", _1) -> [success: bb6, unwind unreachable];
       }
   
-      bb7: {
--         _19 = Div(move _20, const 1_u64);
-+         _19 = Div(_1, const 1_u64);
+      bb6: {
+-         _19 = Div(move _20, const 0_u64);
++         _19 = Div(_1, const 0_u64);
           StorageDead(_20);
-          _18 = opaque::<u64>(move _19) -> [return: bb8, unwind unreachable];
+          _18 = opaque::<u64>(move _19) -> [return: bb7, unwind unreachable];
       }
   
-      bb8: {
+      bb7: {
           StorageDead(_19);
           StorageDead(_18);
           StorageLive(_22);
           StorageLive(_23);
           StorageLive(_24);
           _24 = _1;
--         _25 = Eq(_24, const 0_u64);
--         assert(!move _25, "attempt to divide `{}` by zero", const 0_u64) -> [success: bb9, unwind unreachable];
-+         _25 = Eq(_1, const 0_u64);
-+         assert(!_25, "attempt to divide `{}` by zero", const 0_u64) -> [success: bb9, unwind unreachable];
+-         _25 = Eq(const 1_u64, const 0_u64);
+-         assert(!move _25, "attempt to divide `{}` by zero", _24) -> [success: bb8, unwind unreachable];
++         _25 = const false;
++         assert(!const false, "attempt to divide `{}` by zero", _1) -> [success: bb8, unwind unreachable];
       }
   
-      bb9: {
--         _23 = Div(const 0_u64, move _24);
-+         _23 = Div(const 0_u64, _1);
+      bb8: {
+-         _23 = Div(move _24, const 1_u64);
++         _23 = _1;
           StorageDead(_24);
-          _22 = opaque::<u64>(move _23) -> [return: bb10, unwind unreachable];
+-         _22 = opaque::<u64>(move _23) -> [return: bb9, unwind unreachable];
++         _22 = opaque::<u64>(_1) -> [return: bb9, unwind unreachable];
       }
   
-      bb10: {
+      bb9: {
           StorageDead(_23);
           StorageDead(_22);
           StorageLive(_26);
@@ -182,79 +200,81 @@
           StorageLive(_28);
           _28 = _1;
 -         _29 = Eq(_28, const 0_u64);
--         assert(!move _29, "attempt to divide `{}` by zero", const 1_u64) -> [success: bb11, unwind unreachable];
-+         _29 = _25;
-+         assert(!_25, "attempt to divide `{}` by zero", const 1_u64) -> [success: bb11, unwind unreachable];
+-         assert(!move _29, "attempt to divide `{}` by zero", const 0_u64) -> [success: bb10, unwind unreachable];
++         _29 = Eq(_1, const 0_u64);
++         assert(!_29, "attempt to divide `{}` by zero", const 0_u64) -> [success: bb10, unwind unreachable];
       }
   
-      bb11: {
--         _27 = Div(const 1_u64, move _28);
-+         _27 = Div(const 1_u64, _1);
+      bb10: {
+-         _27 = Div(const 0_u64, move _28);
++         _27 = const 0_u64;
           StorageDead(_28);
-          _26 = opaque::<u64>(move _27) -> [return: bb12, unwind unreachable];
+-         _26 = opaque::<u64>(move _27) -> [return: bb11, unwind unreachable];
++         _26 = opaque::<u64>(const 0_u64) -> [return: bb11, unwind unreachable];
       }
   
-      bb12: {
+      bb11: {
           StorageDead(_27);
           StorageDead(_26);
           StorageLive(_30);
           StorageLive(_31);
           StorageLive(_32);
           _32 = _1;
--         _33 = Eq(const 0_u64, const 0_u64);
--         assert(!move _33, "attempt to calculate the remainder of `{}` with a divisor of zero", _32) -> [success: bb13, unwind unreachable];
-+         _33 = const true;
-+         assert(!const true, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb13, unwind unreachable];
+-         _33 = Eq(_32, const 0_u64);
+-         assert(!move _33, "attempt to divide `{}` by zero", const 1_u64) -> [success: bb12, unwind unreachable];
++         _33 = _29;
++         assert(!_29, "attempt to divide `{}` by zero", const 1_u64) -> [success: bb12, unwind unreachable];
       }
   
-      bb13: {
--         _31 = Rem(move _32, const 0_u64);
-+         _31 = Rem(_1, const 0_u64);
+      bb12: {
+-         _31 = Div(const 1_u64, move _32);
++         _31 = Div(const 1_u64, _1);
           StorageDead(_32);
-          _30 = opaque::<u64>(move _31) -> [return: bb14, unwind unreachable];
+          _30 = opaque::<u64>(move _31) -> [return: bb13, unwind unreachable];
       }
   
-      bb14: {
+      bb13: {
           StorageDead(_31);
           StorageDead(_30);
           StorageLive(_34);
           StorageLive(_35);
           StorageLive(_36);
           _36 = _1;
--         _37 = Eq(const 1_u64, const 0_u64);
--         assert(!move _37, "attempt to calculate the remainder of `{}` with a divisor of zero", _36) -> [success: bb15, unwind unreachable];
-+         _37 = const false;
-+         assert(!const false, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb15, unwind unreachable];
+-         _37 = Eq(const 0_u64, const 0_u64);
+-         assert(!move _37, "attempt to calculate the remainder of `{}` with a divisor of zero", _36) -> [success: bb14, unwind unreachable];
++         _37 = const true;
++         assert(!const true, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb14, unwind unreachable];
       }
   
-      bb15: {
--         _35 = Rem(move _36, const 1_u64);
-+         _35 = Rem(_1, const 1_u64);
+      bb14: {
+-         _35 = Rem(move _36, const 0_u64);
++         _35 = Rem(_1, const 0_u64);
           StorageDead(_36);
-          _34 = opaque::<u64>(move _35) -> [return: bb16, unwind unreachable];
+          _34 = opaque::<u64>(move _35) -> [return: bb15, unwind unreachable];
       }
   
-      bb16: {
+      bb15: {
           StorageDead(_35);
           StorageDead(_34);
           StorageLive(_38);
           StorageLive(_39);
           StorageLive(_40);
           _40 = _1;
--         _41 = Eq(_40, const 0_u64);
--         assert(!move _41, "attempt to calculate the remainder of `{}` with a divisor of zero", const 0_u64) -> [success: bb17, unwind unreachable];
-+         _41 = _25;
-+         assert(!_25, "attempt to calculate the remainder of `{}` with a divisor of zero", const 0_u64) -> [success: bb17, unwind unreachable];
+-         _41 = Eq(const 1_u64, const 0_u64);
+-         assert(!move _41, "attempt to calculate the remainder of `{}` with a divisor of zero", _40) -> [success: bb16, unwind unreachable];
++         _41 = const false;
++         assert(!const false, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb16, unwind unreachable];
       }
   
-      bb17: {
--         _39 = Rem(const 0_u64, move _40);
-+         _39 = Rem(const 0_u64, _1);
+      bb16: {
+-         _39 = Rem(move _40, const 1_u64);
++         _39 = const 0_u64;
           StorageDead(_40);
-          _38 = opaque::<u64>(move _39) -> [return: bb18, unwind unreachable];
+-         _38 = opaque::<u64>(move _39) -> [return: bb17, unwind unreachable];
++         _38 = opaque::<u64>(const 0_u64) -> [return: bb17, unwind unreachable];
       }
   
-      bb18: {
+      bb17: {
           StorageDead(_39);
           StorageDead(_38);
           StorageLive(_42);
@@ -262,27 +282,35 @@
           StorageLive(_44);
           _44 = _1;
 -         _45 = Eq(_44, const 0_u64);
--         assert(!move _45, "attempt to calculate the remainder of `{}` with a divisor of zero", const 1_u64) -> [success: bb19, unwind unreachable];
-+         _45 = _25;
-+         assert(!_25, "attempt to calculate the remainder of `{}` with a divisor of zero", const 1_u64) -> [success: bb19, unwind unreachable];
+-         assert(!move _45, "attempt to calculate the remainder of `{}` with a divisor of zero", const 0_u64) -> [success: bb18, unwind unreachable];
++         _45 = _29;
++         assert(!_29, "attempt to calculate the remainder of `{}` with a divisor of zero", const 0_u64) -> [success: bb18, unwind unreachable];
       }
   
-      bb19: {
--         _43 = Rem(const 1_u64, move _44);
-+         _43 = Rem(const 1_u64, _1);
+      bb18: {
+-         _43 = Rem(const 0_u64, move _44);
++         _43 = const 0_u64;
           StorageDead(_44);
-          _42 = opaque::<u64>(move _43) -> [return: bb20, unwind unreachable];
+-         _42 = opaque::<u64>(move _43) -> [return: bb19, unwind unreachable];
++         _42 = opaque::<u64>(const 0_u64) -> [return: bb19, unwind unreachable];
       }
   
-      bb20: {
+      bb19: {
           StorageDead(_43);
           StorageDead(_42);
           StorageLive(_46);
           StorageLive(_47);
           StorageLive(_48);
           _48 = _1;
--         _47 = BitAnd(move _48, const 0_u64);
-+         _47 = BitAnd(_1, const 0_u64);
+-         _49 = Eq(_48, const 0_u64);
+-         assert(!move _49, "attempt to calculate the remainder of `{}` with a divisor of zero", const 1_u64) -> [success: bb20, unwind unreachable];
++         _49 = _29;
++         assert(!_29, "attempt to calculate the remainder of `{}` with a divisor of zero", const 1_u64) -> [success: bb20, unwind unreachable];
+      }
+  
+      bb20: {
+-         _47 = Rem(const 1_u64, move _48);
++         _47 = Rem(const 1_u64, _1);
           StorageDead(_48);
           _46 = opaque::<u64>(move _47) -> [return: bb21, unwind unreachable];
       }
@@ -290,58 +318,121 @@
       bb21: {
           StorageDead(_47);
           StorageDead(_46);
-          StorageLive(_49);
           StorageLive(_50);
           StorageLive(_51);
-          _51 = _1;
--         _50 = BitOr(move _51, const 0_u64);
-+         _50 = BitOr(_1, const 0_u64);
-          StorageDead(_51);
-          _49 = opaque::<u64>(move _50) -> [return: bb22, unwind unreachable];
+          StorageLive(_52);
+          _52 = _1;
+-         _51 = BitAnd(move _52, const 0_u64);
++         _51 = const 0_u64;
+          StorageDead(_52);
+-         _50 = opaque::<u64>(move _51) -> [return: bb22, unwind unreachable];
++         _50 = opaque::<u64>(const 0_u64) -> [return: bb22, unwind unreachable];
       }
   
       bb22: {
+          StorageDead(_51);
           StorageDead(_50);
-          StorageDead(_49);
-          StorageLive(_52);
           StorageLive(_53);
           StorageLive(_54);
-          _54 = _1;
--         _53 = BitXor(move _54, const 0_u64);
-+         _53 = BitXor(_1, const 0_u64);
-          StorageDead(_54);
-          _52 = opaque::<u64>(move _53) -> [return: bb23, unwind unreachable];
+          StorageLive(_55);
+          _55 = _1;
+-         _54 = BitAnd(move _55, const _);
++         _54 = _1;
+          StorageDead(_55);
+-         _53 = opaque::<u64>(move _54) -> [return: bb23, unwind unreachable];
++         _53 = opaque::<u64>(_1) -> [return: bb23, unwind unreachable];
       }
   
       bb23: {
+          StorageDead(_54);
           StorageDead(_53);
-          StorageDead(_52);
-          StorageLive(_55);
           StorageLive(_56);
           StorageLive(_57);
-          _57 = _1;
--         _56 = Shr(move _57, const 0_i32);
-+         _56 = Shr(_1, const 0_i32);
-          StorageDead(_57);
-          _55 = opaque::<u64>(move _56) -> [return: bb24, unwind unreachable];
+          StorageLive(_58);
+          _58 = _1;
+-         _57 = BitOr(move _58, const 0_u64);
++         _57 = _1;
+          StorageDead(_58);
+-         _56 = opaque::<u64>(move _57) -> [return: bb24, unwind unreachable];
++         _56 = opaque::<u64>(_1) -> [return: bb24, unwind unreachable];
       }
   
       bb24: {
+          StorageDead(_57);
           StorageDead(_56);
-          StorageDead(_55);
-          StorageLive(_58);
           StorageLive(_59);
           StorageLive(_60);
-          _60 = _1;
--         _59 = Shl(move _60, const 0_i32);
-+         _59 = Shl(_1, const 0_i32);
-          StorageDead(_60);
-          _58 = opaque::<u64>(move _59) -> [return: bb25, unwind unreachable];
+          StorageLive(_61);
+          _61 = _1;
+-         _60 = BitOr(move _61, const _);
++         _60 = const u64::MAX;
+          StorageDead(_61);
+-         _59 = opaque::<u64>(move _60) -> [return: bb25, unwind unreachable];
++         _59 = opaque::<u64>(const u64::MAX) -> [return: bb25, unwind unreachable];
       }
   
       bb25: {
+          StorageDead(_60);
           StorageDead(_59);
-          StorageDead(_58);
+          StorageLive(_62);
+          StorageLive(_63);
+          StorageLive(_64);
+          _64 = _1;
+-         _63 = BitXor(move _64, const 0_u64);
++         _63 = _1;
+          StorageDead(_64);
+-         _62 = opaque::<u64>(move _63) -> [return: bb26, unwind unreachable];
++         _62 = opaque::<u64>(_1) -> [return: bb26, unwind unreachable];
+      }
+  
+      bb26: {
+          StorageDead(_63);
+          StorageDead(_62);
+          StorageLive(_65);
+          StorageLive(_66);
+          StorageLive(_67);
+          _67 = _1;
+          StorageLive(_68);
+          _68 = _1;
+-         _66 = BitXor(move _67, move _68);
++         _66 = const 0_u64;
+          StorageDead(_68);
+          StorageDead(_67);
+-         _65 = opaque::<u64>(move _66) -> [return: bb27, unwind unreachable];
++         _65 = opaque::<u64>(const 0_u64) -> [return: bb27, unwind unreachable];
+      }
+  
+      bb27: {
+          StorageDead(_66);
+          StorageDead(_65);
+          StorageLive(_69);
+          StorageLive(_70);
+          StorageLive(_71);
+          _71 = _1;
+-         _70 = Shr(move _71, const 0_i32);
++         _70 = _1;
+          StorageDead(_71);
+-         _69 = opaque::<u64>(move _70) -> [return: bb28, unwind unreachable];
++         _69 = opaque::<u64>(_1) -> [return: bb28, unwind unreachable];
+      }
+  
+      bb28: {
+          StorageDead(_70);
+          StorageDead(_69);
+          StorageLive(_72);
+          StorageLive(_73);
+          StorageLive(_74);
+          _74 = _1;
+-         _73 = Shl(move _74, const 0_i32);
++         _73 = _1;
+          StorageDead(_74);
+-         _72 = opaque::<u64>(move _73) -> [return: bb29, unwind unreachable];
++         _72 = opaque::<u64>(_1) -> [return: bb29, unwind unreachable];
+      }
+  
+      bb29: {
+          StorageDead(_73);
+          StorageDead(_72);
           _0 = const ();
           return;
       }
diff --git a/tests/mir-opt/gvn.arithmetic.GVN.panic-unwind.diff b/tests/mir-opt/gvn.arithmetic.GVN.panic-unwind.diff
index 9d69353934c..98e92d2a310 100644
--- a/tests/mir-opt/gvn.arithmetic.GVN.panic-unwind.diff
+++ b/tests/mir-opt/gvn.arithmetic.GVN.panic-unwind.diff
@@ -13,13 +13,13 @@
       let _8: ();
       let mut _9: u64;
       let mut _10: u64;
-      let _11: ();
-      let mut _12: u64;
+      let mut _11: u64;
+      let _12: ();
       let mut _13: u64;
-      let _14: ();
-      let mut _15: u64;
+      let mut _14: u64;
+      let _15: ();
       let mut _16: u64;
-      let mut _17: bool;
+      let mut _17: u64;
       let _18: ();
       let mut _19: u64;
       let mut _20: u64;
@@ -51,18 +51,32 @@
       let _46: ();
       let mut _47: u64;
       let mut _48: u64;
-      let _49: ();
-      let mut _50: u64;
+      let mut _49: bool;
+      let _50: ();
       let mut _51: u64;
-      let _52: ();
-      let mut _53: u64;
+      let mut _52: u64;
+      let _53: ();
       let mut _54: u64;
-      let _55: ();
-      let mut _56: u64;
+      let mut _55: u64;
+      let _56: ();
       let mut _57: u64;
-      let _58: ();
-      let mut _59: u64;
+      let mut _58: u64;
+      let _59: ();
       let mut _60: u64;
+      let mut _61: u64;
+      let _62: ();
+      let mut _63: u64;
+      let mut _64: u64;
+      let _65: ();
+      let mut _66: u64;
+      let mut _67: u64;
+      let mut _68: u64;
+      let _69: ();
+      let mut _70: u64;
+      let mut _71: u64;
+      let _72: ();
+      let mut _73: u64;
+      let mut _74: u64;
   
       bb0: {
           StorageLive(_2);
@@ -70,9 +84,10 @@
           StorageLive(_4);
           _4 = _1;
 -         _3 = Add(move _4, const 0_u64);
-+         _3 = Add(_1, const 0_u64);
++         _3 = _1;
           StorageDead(_4);
-          _2 = opaque::<u64>(move _3) -> [return: bb1, unwind continue];
+-         _2 = opaque::<u64>(move _3) -> [return: bb1, unwind continue];
++         _2 = opaque::<u64>(_1) -> [return: bb1, unwind continue];
       }
   
       bb1: {
@@ -83,98 +98,101 @@
           StorageLive(_7);
           _7 = _1;
 -         _6 = Sub(move _7, const 0_u64);
-+         _6 = Sub(_1, const 0_u64);
++         _6 = _1;
           StorageDead(_7);
-          _5 = opaque::<u64>(move _6) -> [return: bb2, unwind continue];
+-         _5 = opaque::<u64>(move _6) -> [return: bb2, unwind continue];
++         _5 = opaque::<u64>(_1) -> [return: bb2, unwind continue];
       }
   
       bb2: {
           StorageDead(_6);
           StorageDead(_5);
           StorageLive(_8);
-          StorageLive(_9);
+-         StorageLive(_9);
++         nop;
           StorageLive(_10);
           _10 = _1;
--         _9 = Mul(move _10, const 0_u64);
-+         _9 = Mul(_1, const 0_u64);
+          StorageLive(_11);
+          _11 = _1;
+-         _9 = Sub(move _10, move _11);
++         _9 = const 0_u64;
+          StorageDead(_11);
           StorageDead(_10);
-          _8 = opaque::<u64>(move _9) -> [return: bb3, unwind continue];
+-         _8 = opaque::<u64>(move _9) -> [return: bb3, unwind continue];
++         _8 = opaque::<u64>(const 0_u64) -> [return: bb3, unwind continue];
       }
   
       bb3: {
-          StorageDead(_9);
+-         StorageDead(_9);
++         nop;
           StorageDead(_8);
-          StorageLive(_11);
           StorageLive(_12);
           StorageLive(_13);
-          _13 = _1;
--         _12 = Mul(move _13, const 1_u64);
-+         _12 = Mul(_1, const 1_u64);
-          StorageDead(_13);
-          _11 = opaque::<u64>(move _12) -> [return: bb4, unwind continue];
+          StorageLive(_14);
+          _14 = _1;
+-         _13 = Mul(move _14, const 0_u64);
++         _13 = const 0_u64;
+          StorageDead(_14);
+-         _12 = opaque::<u64>(move _13) -> [return: bb4, unwind continue];
++         _12 = opaque::<u64>(const 0_u64) -> [return: bb4, unwind continue];
       }
   
       bb4: {
+          StorageDead(_13);
           StorageDead(_12);
-          StorageDead(_11);
-          StorageLive(_14);
           StorageLive(_15);
           StorageLive(_16);
-          _16 = _1;
--         _17 = Eq(const 0_u64, const 0_u64);
--         assert(!move _17, "attempt to divide `{}` by zero", _16) -> [success: bb5, unwind continue];
-+         _17 = const true;
-+         assert(!const true, "attempt to divide `{}` by zero", _1) -> [success: bb5, unwind continue];
+          StorageLive(_17);
+          _17 = _1;
+-         _16 = Mul(move _17, const 1_u64);
++         _16 = _1;
+          StorageDead(_17);
+-         _15 = opaque::<u64>(move _16) -> [return: bb5, unwind continue];
++         _15 = opaque::<u64>(_1) -> [return: bb5, unwind continue];
       }
   
       bb5: {
--         _15 = Div(move _16, const 0_u64);
-+         _15 = Div(_1, const 0_u64);
           StorageDead(_16);
-          _14 = opaque::<u64>(move _15) -> [return: bb6, unwind continue];
-      }
-  
-      bb6: {
           StorageDead(_15);
-          StorageDead(_14);
           StorageLive(_18);
           StorageLive(_19);
           StorageLive(_20);
           _20 = _1;
--         _21 = Eq(const 1_u64, const 0_u64);
--         assert(!move _21, "attempt to divide `{}` by zero", _20) -> [success: bb7, unwind continue];
-+         _21 = const false;
-+         assert(!const false, "attempt to divide `{}` by zero", _1) -> [success: bb7, unwind continue];
+-         _21 = Eq(const 0_u64, const 0_u64);
+-         assert(!move _21, "attempt to divide `{}` by zero", _20) -> [success: bb6, unwind continue];
++         _21 = const true;
++         assert(!const true, "attempt to divide `{}` by zero", _1) -> [success: bb6, unwind continue];
       }
   
-      bb7: {
--         _19 = Div(move _20, const 1_u64);
-+         _19 = Div(_1, const 1_u64);
+      bb6: {
+-         _19 = Div(move _20, const 0_u64);
++         _19 = Div(_1, const 0_u64);
           StorageDead(_20);
-          _18 = opaque::<u64>(move _19) -> [return: bb8, unwind continue];
+          _18 = opaque::<u64>(move _19) -> [return: bb7, unwind continue];
       }
   
-      bb8: {
+      bb7: {
           StorageDead(_19);
           StorageDead(_18);
           StorageLive(_22);
           StorageLive(_23);
           StorageLive(_24);
           _24 = _1;
--         _25 = Eq(_24, const 0_u64);
--         assert(!move _25, "attempt to divide `{}` by zero", const 0_u64) -> [success: bb9, unwind continue];
-+         _25 = Eq(_1, const 0_u64);
-+         assert(!_25, "attempt to divide `{}` by zero", const 0_u64) -> [success: bb9, unwind continue];
+-         _25 = Eq(const 1_u64, const 0_u64);
+-         assert(!move _25, "attempt to divide `{}` by zero", _24) -> [success: bb8, unwind continue];
++         _25 = const false;
++         assert(!const false, "attempt to divide `{}` by zero", _1) -> [success: bb8, unwind continue];
       }
   
-      bb9: {
--         _23 = Div(const 0_u64, move _24);
-+         _23 = Div(const 0_u64, _1);
+      bb8: {
+-         _23 = Div(move _24, const 1_u64);
++         _23 = _1;
           StorageDead(_24);
-          _22 = opaque::<u64>(move _23) -> [return: bb10, unwind continue];
+-         _22 = opaque::<u64>(move _23) -> [return: bb9, unwind continue];
++         _22 = opaque::<u64>(_1) -> [return: bb9, unwind continue];
       }
   
-      bb10: {
+      bb9: {
           StorageDead(_23);
           StorageDead(_22);
           StorageLive(_26);
@@ -182,79 +200,81 @@
           StorageLive(_28);
           _28 = _1;
 -         _29 = Eq(_28, const 0_u64);
--         assert(!move _29, "attempt to divide `{}` by zero", const 1_u64) -> [success: bb11, unwind continue];
-+         _29 = _25;
-+         assert(!_25, "attempt to divide `{}` by zero", const 1_u64) -> [success: bb11, unwind continue];
+-         assert(!move _29, "attempt to divide `{}` by zero", const 0_u64) -> [success: bb10, unwind continue];
++         _29 = Eq(_1, const 0_u64);
++         assert(!_29, "attempt to divide `{}` by zero", const 0_u64) -> [success: bb10, unwind continue];
       }
   
-      bb11: {
--         _27 = Div(const 1_u64, move _28);
-+         _27 = Div(const 1_u64, _1);
+      bb10: {
+-         _27 = Div(const 0_u64, move _28);
++         _27 = const 0_u64;
           StorageDead(_28);
-          _26 = opaque::<u64>(move _27) -> [return: bb12, unwind continue];
+-         _26 = opaque::<u64>(move _27) -> [return: bb11, unwind continue];
++         _26 = opaque::<u64>(const 0_u64) -> [return: bb11, unwind continue];
       }
   
-      bb12: {
+      bb11: {
           StorageDead(_27);
           StorageDead(_26);
           StorageLive(_30);
           StorageLive(_31);
           StorageLive(_32);
           _32 = _1;
--         _33 = Eq(const 0_u64, const 0_u64);
--         assert(!move _33, "attempt to calculate the remainder of `{}` with a divisor of zero", _32) -> [success: bb13, unwind continue];
-+         _33 = const true;
-+         assert(!const true, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb13, unwind continue];
+-         _33 = Eq(_32, const 0_u64);
+-         assert(!move _33, "attempt to divide `{}` by zero", const 1_u64) -> [success: bb12, unwind continue];
++         _33 = _29;
++         assert(!_29, "attempt to divide `{}` by zero", const 1_u64) -> [success: bb12, unwind continue];
       }
   
-      bb13: {
--         _31 = Rem(move _32, const 0_u64);
-+         _31 = Rem(_1, const 0_u64);
+      bb12: {
+-         _31 = Div(const 1_u64, move _32);
++         _31 = Div(const 1_u64, _1);
           StorageDead(_32);
-          _30 = opaque::<u64>(move _31) -> [return: bb14, unwind continue];
+          _30 = opaque::<u64>(move _31) -> [return: bb13, unwind continue];
       }
   
-      bb14: {
+      bb13: {
           StorageDead(_31);
           StorageDead(_30);
           StorageLive(_34);
           StorageLive(_35);
           StorageLive(_36);
           _36 = _1;
--         _37 = Eq(const 1_u64, const 0_u64);
--         assert(!move _37, "attempt to calculate the remainder of `{}` with a divisor of zero", _36) -> [success: bb15, unwind continue];
-+         _37 = const false;
-+         assert(!const false, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb15, unwind continue];
+-         _37 = Eq(const 0_u64, const 0_u64);
+-         assert(!move _37, "attempt to calculate the remainder of `{}` with a divisor of zero", _36) -> [success: bb14, unwind continue];
++         _37 = const true;
++         assert(!const true, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb14, unwind continue];
       }
   
-      bb15: {
--         _35 = Rem(move _36, const 1_u64);
-+         _35 = Rem(_1, const 1_u64);
+      bb14: {
+-         _35 = Rem(move _36, const 0_u64);
++         _35 = Rem(_1, const 0_u64);
           StorageDead(_36);
-          _34 = opaque::<u64>(move _35) -> [return: bb16, unwind continue];
+          _34 = opaque::<u64>(move _35) -> [return: bb15, unwind continue];
       }
   
-      bb16: {
+      bb15: {
           StorageDead(_35);
           StorageDead(_34);
           StorageLive(_38);
           StorageLive(_39);
           StorageLive(_40);
           _40 = _1;
--         _41 = Eq(_40, const 0_u64);
--         assert(!move _41, "attempt to calculate the remainder of `{}` with a divisor of zero", const 0_u64) -> [success: bb17, unwind continue];
-+         _41 = _25;
-+         assert(!_25, "attempt to calculate the remainder of `{}` with a divisor of zero", const 0_u64) -> [success: bb17, unwind continue];
+-         _41 = Eq(const 1_u64, const 0_u64);
+-         assert(!move _41, "attempt to calculate the remainder of `{}` with a divisor of zero", _40) -> [success: bb16, unwind continue];
++         _41 = const false;
++         assert(!const false, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb16, unwind continue];
       }
   
-      bb17: {
--         _39 = Rem(const 0_u64, move _40);
-+         _39 = Rem(const 0_u64, _1);
+      bb16: {
+-         _39 = Rem(move _40, const 1_u64);
++         _39 = const 0_u64;
           StorageDead(_40);
-          _38 = opaque::<u64>(move _39) -> [return: bb18, unwind continue];
+-         _38 = opaque::<u64>(move _39) -> [return: bb17, unwind continue];
++         _38 = opaque::<u64>(const 0_u64) -> [return: bb17, unwind continue];
       }
   
-      bb18: {
+      bb17: {
           StorageDead(_39);
           StorageDead(_38);
           StorageLive(_42);
@@ -262,27 +282,35 @@
           StorageLive(_44);
           _44 = _1;
 -         _45 = Eq(_44, const 0_u64);
--         assert(!move _45, "attempt to calculate the remainder of `{}` with a divisor of zero", const 1_u64) -> [success: bb19, unwind continue];
-+         _45 = _25;
-+         assert(!_25, "attempt to calculate the remainder of `{}` with a divisor of zero", const 1_u64) -> [success: bb19, unwind continue];
+-         assert(!move _45, "attempt to calculate the remainder of `{}` with a divisor of zero", const 0_u64) -> [success: bb18, unwind continue];
++         _45 = _29;
++         assert(!_29, "attempt to calculate the remainder of `{}` with a divisor of zero", const 0_u64) -> [success: bb18, unwind continue];
       }
   
-      bb19: {
--         _43 = Rem(const 1_u64, move _44);
-+         _43 = Rem(const 1_u64, _1);
+      bb18: {
+-         _43 = Rem(const 0_u64, move _44);
++         _43 = const 0_u64;
           StorageDead(_44);
-          _42 = opaque::<u64>(move _43) -> [return: bb20, unwind continue];
+-         _42 = opaque::<u64>(move _43) -> [return: bb19, unwind continue];
++         _42 = opaque::<u64>(const 0_u64) -> [return: bb19, unwind continue];
       }
   
-      bb20: {
+      bb19: {
           StorageDead(_43);
           StorageDead(_42);
           StorageLive(_46);
           StorageLive(_47);
           StorageLive(_48);
           _48 = _1;
--         _47 = BitAnd(move _48, const 0_u64);
-+         _47 = BitAnd(_1, const 0_u64);
+-         _49 = Eq(_48, const 0_u64);
+-         assert(!move _49, "attempt to calculate the remainder of `{}` with a divisor of zero", const 1_u64) -> [success: bb20, unwind continue];
++         _49 = _29;
++         assert(!_29, "attempt to calculate the remainder of `{}` with a divisor of zero", const 1_u64) -> [success: bb20, unwind continue];
+      }
+  
+      bb20: {
+-         _47 = Rem(const 1_u64, move _48);
++         _47 = Rem(const 1_u64, _1);
           StorageDead(_48);
           _46 = opaque::<u64>(move _47) -> [return: bb21, unwind continue];
       }
@@ -290,58 +318,121 @@
       bb21: {
           StorageDead(_47);
           StorageDead(_46);
-          StorageLive(_49);
           StorageLive(_50);
           StorageLive(_51);
-          _51 = _1;
--         _50 = BitOr(move _51, const 0_u64);
-+         _50 = BitOr(_1, const 0_u64);
-          StorageDead(_51);
-          _49 = opaque::<u64>(move _50) -> [return: bb22, unwind continue];
+          StorageLive(_52);
+          _52 = _1;
+-         _51 = BitAnd(move _52, const 0_u64);
++         _51 = const 0_u64;
+          StorageDead(_52);
+-         _50 = opaque::<u64>(move _51) -> [return: bb22, unwind continue];
++         _50 = opaque::<u64>(const 0_u64) -> [return: bb22, unwind continue];
       }
   
       bb22: {
+          StorageDead(_51);
           StorageDead(_50);
-          StorageDead(_49);
-          StorageLive(_52);
           StorageLive(_53);
           StorageLive(_54);
-          _54 = _1;
--         _53 = BitXor(move _54, const 0_u64);
-+         _53 = BitXor(_1, const 0_u64);
-          StorageDead(_54);
-          _52 = opaque::<u64>(move _53) -> [return: bb23, unwind continue];
+          StorageLive(_55);
+          _55 = _1;
+-         _54 = BitAnd(move _55, const _);
++         _54 = _1;
+          StorageDead(_55);
+-         _53 = opaque::<u64>(move _54) -> [return: bb23, unwind continue];
++         _53 = opaque::<u64>(_1) -> [return: bb23, unwind continue];
       }
   
       bb23: {
+          StorageDead(_54);
           StorageDead(_53);
-          StorageDead(_52);
-          StorageLive(_55);
           StorageLive(_56);
           StorageLive(_57);
-          _57 = _1;
--         _56 = Shr(move _57, const 0_i32);
-+         _56 = Shr(_1, const 0_i32);
-          StorageDead(_57);
-          _55 = opaque::<u64>(move _56) -> [return: bb24, unwind continue];
+          StorageLive(_58);
+          _58 = _1;
+-         _57 = BitOr(move _58, const 0_u64);
++         _57 = _1;
+          StorageDead(_58);
+-         _56 = opaque::<u64>(move _57) -> [return: bb24, unwind continue];
++         _56 = opaque::<u64>(_1) -> [return: bb24, unwind continue];
       }
   
       bb24: {
+          StorageDead(_57);
           StorageDead(_56);
-          StorageDead(_55);
-          StorageLive(_58);
           StorageLive(_59);
           StorageLive(_60);
-          _60 = _1;
--         _59 = Shl(move _60, const 0_i32);
-+         _59 = Shl(_1, const 0_i32);
-          StorageDead(_60);
-          _58 = opaque::<u64>(move _59) -> [return: bb25, unwind continue];
+          StorageLive(_61);
+          _61 = _1;
+-         _60 = BitOr(move _61, const _);
++         _60 = const u64::MAX;
+          StorageDead(_61);
+-         _59 = opaque::<u64>(move _60) -> [return: bb25, unwind continue];
++         _59 = opaque::<u64>(const u64::MAX) -> [return: bb25, unwind continue];
       }
   
       bb25: {
+          StorageDead(_60);
           StorageDead(_59);
-          StorageDead(_58);
+          StorageLive(_62);
+          StorageLive(_63);
+          StorageLive(_64);
+          _64 = _1;
+-         _63 = BitXor(move _64, const 0_u64);
++         _63 = _1;
+          StorageDead(_64);
+-         _62 = opaque::<u64>(move _63) -> [return: bb26, unwind continue];
++         _62 = opaque::<u64>(_1) -> [return: bb26, unwind continue];
+      }
+  
+      bb26: {
+          StorageDead(_63);
+          StorageDead(_62);
+          StorageLive(_65);
+          StorageLive(_66);
+          StorageLive(_67);
+          _67 = _1;
+          StorageLive(_68);
+          _68 = _1;
+-         _66 = BitXor(move _67, move _68);
++         _66 = const 0_u64;
+          StorageDead(_68);
+          StorageDead(_67);
+-         _65 = opaque::<u64>(move _66) -> [return: bb27, unwind continue];
++         _65 = opaque::<u64>(const 0_u64) -> [return: bb27, unwind continue];
+      }
+  
+      bb27: {
+          StorageDead(_66);
+          StorageDead(_65);
+          StorageLive(_69);
+          StorageLive(_70);
+          StorageLive(_71);
+          _71 = _1;
+-         _70 = Shr(move _71, const 0_i32);
++         _70 = _1;
+          StorageDead(_71);
+-         _69 = opaque::<u64>(move _70) -> [return: bb28, unwind continue];
++         _69 = opaque::<u64>(_1) -> [return: bb28, unwind continue];
+      }
+  
+      bb28: {
+          StorageDead(_70);
+          StorageDead(_69);
+          StorageLive(_72);
+          StorageLive(_73);
+          StorageLive(_74);
+          _74 = _1;
+-         _73 = Shl(move _74, const 0_i32);
++         _73 = _1;
+          StorageDead(_74);
+-         _72 = opaque::<u64>(move _73) -> [return: bb29, unwind continue];
++         _72 = opaque::<u64>(_1) -> [return: bb29, unwind continue];
+      }
+  
+      bb29: {
+          StorageDead(_73);
+          StorageDead(_72);
           _0 = const ();
           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 6633df3ae70..a45d9920a68 100644
--- a/tests/mir-opt/gvn.arithmetic_checked.GVN.panic-abort.diff
+++ b/tests/mir-opt/gvn.arithmetic_checked.GVN.panic-abort.diff
@@ -15,11 +15,16 @@
       let _10: ();
       let mut _11: u64;
       let mut _12: u64;
-      let mut _13: (u64, bool);
-      let _14: ();
-      let mut _15: u64;
+      let mut _13: u64;
+      let mut _14: (u64, bool);
+      let _15: ();
       let mut _16: u64;
-      let mut _17: (u64, bool);
+      let mut _17: u64;
+      let mut _18: (u64, bool);
+      let _19: ();
+      let mut _20: u64;
+      let mut _21: u64;
+      let mut _22: (u64, bool);
   
       bb0: {
           StorageLive(_2);
@@ -29,13 +34,15 @@
 -         _5 = CheckedAdd(_4, const 0_u64);
 -         assert(!move (_5.1: bool), "attempt to compute `{} + {}`, which would overflow", move _4, const 0_u64) -> [success: bb1, unwind unreachable];
 +         _5 = CheckedAdd(_1, const 0_u64);
-+         assert(!move (_5.1: bool), "attempt to compute `{} + {}`, which would overflow", _1, const 0_u64) -> [success: bb1, unwind unreachable];
++         assert(!const false, "attempt to compute `{} + {}`, which would overflow", _1, const 0_u64) -> [success: bb1, unwind unreachable];
       }
   
       bb1: {
-          _3 = move (_5.0: u64);
+-         _3 = move (_5.0: u64);
++         _3 = _1;
           StorageDead(_4);
-          _2 = opaque::<u64>(move _3) -> [return: bb2, unwind unreachable];
+-         _2 = opaque::<u64>(move _3) -> [return: bb2, unwind unreachable];
++         _2 = opaque::<u64>(_1) -> [return: bb2, unwind unreachable];
       }
   
       bb2: {
@@ -47,59 +54,95 @@
           _8 = _1;
 -         _9 = CheckedSub(_8, const 0_u64);
 -         assert(!move (_9.1: bool), "attempt to compute `{} - {}`, which would overflow", move _8, const 0_u64) -> [success: bb3, unwind unreachable];
-+         _9 = CheckedSub(_1, const 0_u64);
-+         assert(!move (_9.1: bool), "attempt to compute `{} - {}`, which would overflow", _1, const 0_u64) -> [success: bb3, unwind unreachable];
++         _9 = _5;
++         assert(!const false, "attempt to compute `{} - {}`, which would overflow", _1, const 0_u64) -> [success: bb3, unwind unreachable];
       }
   
       bb3: {
-          _7 = move (_9.0: u64);
+-         _7 = move (_9.0: u64);
++         _7 = _1;
           StorageDead(_8);
-          _6 = opaque::<u64>(move _7) -> [return: bb4, unwind unreachable];
+-         _6 = opaque::<u64>(move _7) -> [return: bb4, unwind unreachable];
++         _6 = opaque::<u64>(_1) -> [return: bb4, unwind unreachable];
       }
   
       bb4: {
           StorageDead(_7);
           StorageDead(_6);
           StorageLive(_10);
-          StorageLive(_11);
+-         StorageLive(_11);
++         nop;
           StorageLive(_12);
           _12 = _1;
--         _13 = CheckedMul(_12, const 0_u64);
--         assert(!move (_13.1: bool), "attempt to compute `{} * {}`, which would overflow", move _12, const 0_u64) -> [success: bb5, unwind unreachable];
-+         _13 = CheckedMul(_1, const 0_u64);
-+         assert(!move (_13.1: bool), "attempt to compute `{} * {}`, which would overflow", _1, const 0_u64) -> [success: bb5, unwind unreachable];
+          StorageLive(_13);
+          _13 = _1;
+-         _14 = CheckedSub(_12, _13);
+-         assert(!move (_14.1: bool), "attempt to compute `{} - {}`, which would overflow", move _12, move _13) -> [success: bb5, unwind unreachable];
++         _14 = const (0_u64, false);
++         assert(!const false, "attempt to compute `{} - {}`, which would overflow", _1, _1) -> [success: bb5, unwind unreachable];
       }
   
       bb5: {
-          _11 = move (_13.0: u64);
+-         _11 = move (_14.0: u64);
++         _11 = const 0_u64;
+          StorageDead(_13);
           StorageDead(_12);
-          _10 = opaque::<u64>(move _11) -> [return: bb6, unwind unreachable];
+-         _10 = opaque::<u64>(move _11) -> [return: bb6, unwind unreachable];
++         _10 = opaque::<u64>(const 0_u64) -> [return: bb6, unwind unreachable];
       }
   
       bb6: {
-          StorageDead(_11);
+-         StorageDead(_11);
++         nop;
           StorageDead(_10);
-          StorageLive(_14);
           StorageLive(_15);
           StorageLive(_16);
-          _16 = _1;
--         _17 = CheckedMul(_16, const 1_u64);
--         assert(!move (_17.1: bool), "attempt to compute `{} * {}`, which would overflow", move _16, const 1_u64) -> [success: bb7, unwind unreachable];
-+         _17 = CheckedMul(_1, const 1_u64);
-+         assert(!move (_17.1: bool), "attempt to compute `{} * {}`, which would overflow", _1, const 1_u64) -> [success: bb7, unwind unreachable];
+          StorageLive(_17);
+          _17 = _1;
+-         _18 = CheckedMul(_17, const 0_u64);
+-         assert(!move (_18.1: bool), "attempt to compute `{} * {}`, which would overflow", move _17, const 0_u64) -> [success: bb7, unwind unreachable];
++         _18 = const (0_u64, false);
++         assert(!const false, "attempt to compute `{} * {}`, which would overflow", _1, const 0_u64) -> [success: bb7, unwind unreachable];
       }
   
       bb7: {
-          _15 = move (_17.0: u64);
-          StorageDead(_16);
-          _14 = opaque::<u64>(move _15) -> [return: bb8, unwind unreachable];
+-         _16 = move (_18.0: u64);
++         _16 = const 0_u64;
+          StorageDead(_17);
+-         _15 = opaque::<u64>(move _16) -> [return: bb8, unwind unreachable];
++         _15 = opaque::<u64>(const 0_u64) -> [return: bb8, unwind unreachable];
       }
   
       bb8: {
+          StorageDead(_16);
           StorageDead(_15);
-          StorageDead(_14);
+          StorageLive(_19);
+          StorageLive(_20);
+          StorageLive(_21);
+          _21 = _1;
+-         _22 = CheckedMul(_21, const 1_u64);
+-         assert(!move (_22.1: bool), "attempt to compute `{} * {}`, which would overflow", move _21, const 1_u64) -> [success: bb9, unwind unreachable];
++         _22 = _5;
++         assert(!const false, "attempt to compute `{} * {}`, which would overflow", _1, const 1_u64) -> [success: bb9, unwind unreachable];
+      }
+  
+      bb9: {
+-         _20 = move (_22.0: u64);
++         _20 = _1;
+          StorageDead(_21);
+-         _19 = opaque::<u64>(move _20) -> [return: bb10, unwind unreachable];
++         _19 = opaque::<u64>(_1) -> [return: bb10, unwind unreachable];
+      }
+  
+      bb10: {
+          StorageDead(_20);
+          StorageDead(_19);
           _0 = const ();
           return;
       }
++ }
++ 
++ ALLOC0 (size: 16, align: 8) {
++     00 00 00 00 00 00 00 00 00 __ __ __ __ __ __ __ │ .........░░░░░░░
   }
   
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 d100a77fee5..9033b392bd4 100644
--- a/tests/mir-opt/gvn.arithmetic_checked.GVN.panic-unwind.diff
+++ b/tests/mir-opt/gvn.arithmetic_checked.GVN.panic-unwind.diff
@@ -15,11 +15,16 @@
       let _10: ();
       let mut _11: u64;
       let mut _12: u64;
-      let mut _13: (u64, bool);
-      let _14: ();
-      let mut _15: u64;
+      let mut _13: u64;
+      let mut _14: (u64, bool);
+      let _15: ();
       let mut _16: u64;
-      let mut _17: (u64, bool);
+      let mut _17: u64;
+      let mut _18: (u64, bool);
+      let _19: ();
+      let mut _20: u64;
+      let mut _21: u64;
+      let mut _22: (u64, bool);
   
       bb0: {
           StorageLive(_2);
@@ -29,13 +34,15 @@
 -         _5 = CheckedAdd(_4, const 0_u64);
 -         assert(!move (_5.1: bool), "attempt to compute `{} + {}`, which would overflow", move _4, const 0_u64) -> [success: bb1, unwind continue];
 +         _5 = CheckedAdd(_1, const 0_u64);
-+         assert(!move (_5.1: bool), "attempt to compute `{} + {}`, which would overflow", _1, const 0_u64) -> [success: bb1, unwind continue];
++         assert(!const false, "attempt to compute `{} + {}`, which would overflow", _1, const 0_u64) -> [success: bb1, unwind continue];
       }
   
       bb1: {
-          _3 = move (_5.0: u64);
+-         _3 = move (_5.0: u64);
++         _3 = _1;
           StorageDead(_4);
-          _2 = opaque::<u64>(move _3) -> [return: bb2, unwind continue];
+-         _2 = opaque::<u64>(move _3) -> [return: bb2, unwind continue];
++         _2 = opaque::<u64>(_1) -> [return: bb2, unwind continue];
       }
   
       bb2: {
@@ -47,59 +54,95 @@
           _8 = _1;
 -         _9 = CheckedSub(_8, const 0_u64);
 -         assert(!move (_9.1: bool), "attempt to compute `{} - {}`, which would overflow", move _8, const 0_u64) -> [success: bb3, unwind continue];
-+         _9 = CheckedSub(_1, const 0_u64);
-+         assert(!move (_9.1: bool), "attempt to compute `{} - {}`, which would overflow", _1, const 0_u64) -> [success: bb3, unwind continue];
++         _9 = _5;
++         assert(!const false, "attempt to compute `{} - {}`, which would overflow", _1, const 0_u64) -> [success: bb3, unwind continue];
       }
   
       bb3: {
-          _7 = move (_9.0: u64);
+-         _7 = move (_9.0: u64);
++         _7 = _1;
           StorageDead(_8);
-          _6 = opaque::<u64>(move _7) -> [return: bb4, unwind continue];
+-         _6 = opaque::<u64>(move _7) -> [return: bb4, unwind continue];
++         _6 = opaque::<u64>(_1) -> [return: bb4, unwind continue];
       }
   
       bb4: {
           StorageDead(_7);
           StorageDead(_6);
           StorageLive(_10);
-          StorageLive(_11);
+-         StorageLive(_11);
++         nop;
           StorageLive(_12);
           _12 = _1;
--         _13 = CheckedMul(_12, const 0_u64);
--         assert(!move (_13.1: bool), "attempt to compute `{} * {}`, which would overflow", move _12, const 0_u64) -> [success: bb5, unwind continue];
-+         _13 = CheckedMul(_1, const 0_u64);
-+         assert(!move (_13.1: bool), "attempt to compute `{} * {}`, which would overflow", _1, const 0_u64) -> [success: bb5, unwind continue];
+          StorageLive(_13);
+          _13 = _1;
+-         _14 = CheckedSub(_12, _13);
+-         assert(!move (_14.1: bool), "attempt to compute `{} - {}`, which would overflow", move _12, move _13) -> [success: bb5, unwind continue];
++         _14 = const (0_u64, false);
++         assert(!const false, "attempt to compute `{} - {}`, which would overflow", _1, _1) -> [success: bb5, unwind continue];
       }
   
       bb5: {
-          _11 = move (_13.0: u64);
+-         _11 = move (_14.0: u64);
++         _11 = const 0_u64;
+          StorageDead(_13);
           StorageDead(_12);
-          _10 = opaque::<u64>(move _11) -> [return: bb6, unwind continue];
+-         _10 = opaque::<u64>(move _11) -> [return: bb6, unwind continue];
++         _10 = opaque::<u64>(const 0_u64) -> [return: bb6, unwind continue];
       }
   
       bb6: {
-          StorageDead(_11);
+-         StorageDead(_11);
++         nop;
           StorageDead(_10);
-          StorageLive(_14);
           StorageLive(_15);
           StorageLive(_16);
-          _16 = _1;
--         _17 = CheckedMul(_16, const 1_u64);
--         assert(!move (_17.1: bool), "attempt to compute `{} * {}`, which would overflow", move _16, const 1_u64) -> [success: bb7, unwind continue];
-+         _17 = CheckedMul(_1, const 1_u64);
-+         assert(!move (_17.1: bool), "attempt to compute `{} * {}`, which would overflow", _1, const 1_u64) -> [success: bb7, unwind continue];
+          StorageLive(_17);
+          _17 = _1;
+-         _18 = CheckedMul(_17, const 0_u64);
+-         assert(!move (_18.1: bool), "attempt to compute `{} * {}`, which would overflow", move _17, const 0_u64) -> [success: bb7, unwind continue];
++         _18 = const (0_u64, false);
++         assert(!const false, "attempt to compute `{} * {}`, which would overflow", _1, const 0_u64) -> [success: bb7, unwind continue];
       }
   
       bb7: {
-          _15 = move (_17.0: u64);
-          StorageDead(_16);
-          _14 = opaque::<u64>(move _15) -> [return: bb8, unwind continue];
+-         _16 = move (_18.0: u64);
++         _16 = const 0_u64;
+          StorageDead(_17);
+-         _15 = opaque::<u64>(move _16) -> [return: bb8, unwind continue];
++         _15 = opaque::<u64>(const 0_u64) -> [return: bb8, unwind continue];
       }
   
       bb8: {
+          StorageDead(_16);
           StorageDead(_15);
-          StorageDead(_14);
+          StorageLive(_19);
+          StorageLive(_20);
+          StorageLive(_21);
+          _21 = _1;
+-         _22 = CheckedMul(_21, const 1_u64);
+-         assert(!move (_22.1: bool), "attempt to compute `{} * {}`, which would overflow", move _21, const 1_u64) -> [success: bb9, unwind continue];
++         _22 = _5;
++         assert(!const false, "attempt to compute `{} * {}`, which would overflow", _1, const 1_u64) -> [success: bb9, unwind continue];
+      }
+  
+      bb9: {
+-         _20 = move (_22.0: u64);
++         _20 = _1;
+          StorageDead(_21);
+-         _19 = opaque::<u64>(move _20) -> [return: bb10, unwind continue];
++         _19 = opaque::<u64>(_1) -> [return: bb10, unwind continue];
+      }
+  
+      bb10: {
+          StorageDead(_20);
+          StorageDead(_19);
           _0 = const ();
           return;
       }
++ }
++ 
++ ALLOC0 (size: 16, align: 8) {
++     00 00 00 00 00 00 00 00 00 __ __ __ __ __ __ __ │ .........░░░░░░░
   }
   
diff --git a/tests/mir-opt/gvn.comparison.GVN.panic-abort.diff b/tests/mir-opt/gvn.comparison.GVN.panic-abort.diff
index ee3b9da2122..fefdf14bddc 100644
--- a/tests/mir-opt/gvn.comparison.GVN.panic-abort.diff
+++ b/tests/mir-opt/gvn.comparison.GVN.panic-abort.diff
@@ -30,10 +30,11 @@
           StorageLive(_6);
           _6 = _1;
 -         _4 = Eq(move _5, move _6);
-+         _4 = Eq(_1, _1);
++         _4 = const true;
           StorageDead(_6);
           StorageDead(_5);
-          _3 = opaque::<bool>(move _4) -> [return: bb1, unwind unreachable];
+-         _3 = opaque::<bool>(move _4) -> [return: bb1, unwind unreachable];
++         _3 = opaque::<bool>(const true) -> [return: bb1, unwind unreachable];
       }
   
       bb1: {
@@ -46,10 +47,11 @@
           StorageLive(_10);
           _10 = _1;
 -         _8 = Ne(move _9, move _10);
-+         _8 = Ne(_1, _1);
++         _8 = const false;
           StorageDead(_10);
           StorageDead(_9);
-          _7 = opaque::<bool>(move _8) -> [return: bb2, unwind unreachable];
+-         _7 = opaque::<bool>(move _8) -> [return: bb2, unwind unreachable];
++         _7 = opaque::<bool>(const false) -> [return: bb2, unwind unreachable];
       }
   
       bb2: {
diff --git a/tests/mir-opt/gvn.comparison.GVN.panic-unwind.diff b/tests/mir-opt/gvn.comparison.GVN.panic-unwind.diff
index a1408fe3434..9f19b2b59fa 100644
--- a/tests/mir-opt/gvn.comparison.GVN.panic-unwind.diff
+++ b/tests/mir-opt/gvn.comparison.GVN.panic-unwind.diff
@@ -30,10 +30,11 @@
           StorageLive(_6);
           _6 = _1;
 -         _4 = Eq(move _5, move _6);
-+         _4 = Eq(_1, _1);
++         _4 = const true;
           StorageDead(_6);
           StorageDead(_5);
-          _3 = opaque::<bool>(move _4) -> [return: bb1, unwind continue];
+-         _3 = opaque::<bool>(move _4) -> [return: bb1, unwind continue];
++         _3 = opaque::<bool>(const true) -> [return: bb1, unwind continue];
       }
   
       bb1: {
@@ -46,10 +47,11 @@
           StorageLive(_10);
           _10 = _1;
 -         _8 = Ne(move _9, move _10);
-+         _8 = Ne(_1, _1);
++         _8 = const false;
           StorageDead(_10);
           StorageDead(_9);
-          _7 = opaque::<bool>(move _8) -> [return: bb2, unwind continue];
+-         _7 = opaque::<bool>(move _8) -> [return: bb2, unwind continue];
++         _7 = opaque::<bool>(const false) -> [return: bb2, unwind continue];
       }
   
       bb2: {
diff --git a/tests/mir-opt/gvn.fn_pointers.GVN.panic-abort.diff b/tests/mir-opt/gvn.fn_pointers.GVN.panic-abort.diff
index d8248d22d38..0901896af53 100644
--- a/tests/mir-opt/gvn.fn_pointers.GVN.panic-abort.diff
+++ b/tests/mir-opt/gvn.fn_pointers.GVN.panic-abort.diff
@@ -8,10 +8,10 @@
       let mut _3: fn(u8) -> u8;
       let _5: ();
       let mut _6: fn(u8) -> u8;
-      let mut _9: {closure@$DIR/gvn.rs:591:19: 591:21};
+      let mut _9: {closure@$DIR/gvn.rs:585:19: 585:21};
       let _10: ();
       let mut _11: fn();
-      let mut _13: {closure@$DIR/gvn.rs:591:19: 591:21};
+      let mut _13: {closure@$DIR/gvn.rs:585:19: 585:21};
       let _14: ();
       let mut _15: fn();
       scope 1 {
@@ -19,7 +19,7 @@
           let _4: fn(u8) -> u8;
           scope 2 {
               debug g => _4;
-              let _7: {closure@$DIR/gvn.rs:591:19: 591:21};
+              let _7: {closure@$DIR/gvn.rs:585:19: 585:21};
               scope 3 {
                   debug closure => _7;
                   let _8: fn();
@@ -62,16 +62,16 @@
           StorageDead(_6);
           StorageDead(_5);
 -         StorageLive(_7);
--         _7 = {closure@$DIR/gvn.rs:591:19: 591:21};
+-         _7 = {closure@$DIR/gvn.rs:585:19: 585:21};
 -         StorageLive(_8);
 +         nop;
-+         _7 = const ZeroSized: {closure@$DIR/gvn.rs:591:19: 591:21};
++         _7 = const ZeroSized: {closure@$DIR/gvn.rs:585:19: 585:21};
 +         nop;
           StorageLive(_9);
 -         _9 = _7;
 -         _8 = move _9 as fn() (PointerCoercion(ClosureFnPointer(Normal)));
-+         _9 = const ZeroSized: {closure@$DIR/gvn.rs:591:19: 591:21};
-+         _8 = const ZeroSized: {closure@$DIR/gvn.rs:591:19: 591:21} as fn() (PointerCoercion(ClosureFnPointer(Normal)));
++         _9 = const ZeroSized: {closure@$DIR/gvn.rs:585:19: 585:21};
++         _8 = const ZeroSized: {closure@$DIR/gvn.rs:585:19: 585:21} as fn() (PointerCoercion(ClosureFnPointer(Normal)));
           StorageDead(_9);
           StorageLive(_10);
           StorageLive(_11);
@@ -88,8 +88,8 @@
           StorageLive(_13);
 -         _13 = _7;
 -         _12 = move _13 as fn() (PointerCoercion(ClosureFnPointer(Normal)));
-+         _13 = const ZeroSized: {closure@$DIR/gvn.rs:591:19: 591:21};
-+         _12 = const ZeroSized: {closure@$DIR/gvn.rs:591:19: 591:21} as fn() (PointerCoercion(ClosureFnPointer(Normal)));
++         _13 = const ZeroSized: {closure@$DIR/gvn.rs:585:19: 585:21};
++         _12 = const ZeroSized: {closure@$DIR/gvn.rs:585:19: 585:21} as fn() (PointerCoercion(ClosureFnPointer(Normal)));
           StorageDead(_13);
           StorageLive(_14);
           StorageLive(_15);
diff --git a/tests/mir-opt/gvn.fn_pointers.GVN.panic-unwind.diff b/tests/mir-opt/gvn.fn_pointers.GVN.panic-unwind.diff
index e38a3d85209..4b95191ba82 100644
--- a/tests/mir-opt/gvn.fn_pointers.GVN.panic-unwind.diff
+++ b/tests/mir-opt/gvn.fn_pointers.GVN.panic-unwind.diff
@@ -8,10 +8,10 @@
       let mut _3: fn(u8) -> u8;
       let _5: ();
       let mut _6: fn(u8) -> u8;
-      let mut _9: {closure@$DIR/gvn.rs:591:19: 591:21};
+      let mut _9: {closure@$DIR/gvn.rs:585:19: 585:21};
       let _10: ();
       let mut _11: fn();
-      let mut _13: {closure@$DIR/gvn.rs:591:19: 591:21};
+      let mut _13: {closure@$DIR/gvn.rs:585:19: 585:21};
       let _14: ();
       let mut _15: fn();
       scope 1 {
@@ -19,7 +19,7 @@
           let _4: fn(u8) -> u8;
           scope 2 {
               debug g => _4;
-              let _7: {closure@$DIR/gvn.rs:591:19: 591:21};
+              let _7: {closure@$DIR/gvn.rs:585:19: 585:21};
               scope 3 {
                   debug closure => _7;
                   let _8: fn();
@@ -62,16 +62,16 @@
           StorageDead(_6);
           StorageDead(_5);
 -         StorageLive(_7);
--         _7 = {closure@$DIR/gvn.rs:591:19: 591:21};
+-         _7 = {closure@$DIR/gvn.rs:585:19: 585:21};
 -         StorageLive(_8);
 +         nop;
-+         _7 = const ZeroSized: {closure@$DIR/gvn.rs:591:19: 591:21};
++         _7 = const ZeroSized: {closure@$DIR/gvn.rs:585:19: 585:21};
 +         nop;
           StorageLive(_9);
 -         _9 = _7;
 -         _8 = move _9 as fn() (PointerCoercion(ClosureFnPointer(Normal)));
-+         _9 = const ZeroSized: {closure@$DIR/gvn.rs:591:19: 591:21};
-+         _8 = const ZeroSized: {closure@$DIR/gvn.rs:591:19: 591:21} as fn() (PointerCoercion(ClosureFnPointer(Normal)));
++         _9 = const ZeroSized: {closure@$DIR/gvn.rs:585:19: 585:21};
++         _8 = const ZeroSized: {closure@$DIR/gvn.rs:585:19: 585:21} as fn() (PointerCoercion(ClosureFnPointer(Normal)));
           StorageDead(_9);
           StorageLive(_10);
           StorageLive(_11);
@@ -88,8 +88,8 @@
           StorageLive(_13);
 -         _13 = _7;
 -         _12 = move _13 as fn() (PointerCoercion(ClosureFnPointer(Normal)));
-+         _13 = const ZeroSized: {closure@$DIR/gvn.rs:591:19: 591:21};
-+         _12 = const ZeroSized: {closure@$DIR/gvn.rs:591:19: 591:21} as fn() (PointerCoercion(ClosureFnPointer(Normal)));
++         _13 = const ZeroSized: {closure@$DIR/gvn.rs:585:19: 585:21};
++         _12 = const ZeroSized: {closure@$DIR/gvn.rs:585:19: 585:21} as fn() (PointerCoercion(ClosureFnPointer(Normal)));
           StorageDead(_13);
           StorageLive(_14);
           StorageLive(_15);
diff --git a/tests/mir-opt/gvn.rs b/tests/mir-opt/gvn.rs
index 23e33a0fa49..8c06e3a6385 100644
--- a/tests/mir-opt/gvn.rs
+++ b/tests/mir-opt/gvn.rs
@@ -169,66 +169,61 @@ fn repeated_index<T: Copy, const N: usize>(x: T, idx: usize) {
 /// Verify symbolic integer arithmetic simplifications.
 fn arithmetic(x: u64) {
     // CHECK-LABEL: fn arithmetic(
-    // CHECK: [[add:_.*]] = Add(_1, const 0_u64);
-    // CHECK: opaque::<u64>(move [[add]])
+    // CHECK: opaque::<u64>(_1)
     opaque(x + 0);
-    // CHECK: [[sub:_.*]] = Sub(_1, const 0_u64);
-    // CHECK: opaque::<u64>(move [[sub]])
+    // CHECK: opaque::<u64>(_1)
     opaque(x - 0);
-    // CHECK: [[mul0:_.*]] = Mul(_1, const 0_u64);
-    // CHECK: opaque::<u64>(move [[mul0]])
+    // CHECK: opaque::<u64>(const 0_u64)
+    opaque(x - x);
+    // CHECK: opaque::<u64>(const 0_u64)
     opaque(x * 0);
-    // CHECK: [[mul1:_.*]] = Mul(_1, const 1_u64);
-    // CHECK: opaque::<u64>(move [[mul1]])
+    // CHECK: opaque::<u64>(_1)
     opaque(x * 1);
+    // CHECK: assert(!const true, "attempt to divide `{}` by zero",
     // CHECK: [[div0:_.*]] = Div(_1, const 0_u64);
     // CHECK: opaque::<u64>(move [[div0]])
     opaque(x / 0);
-    // CHECK: [[div1:_.*]] = Div(_1, const 1_u64);
-    // CHECK: opaque::<u64>(move [[div1]])
+    // CHECK: opaque::<u64>(_1)
     opaque(x / 1);
-    // CHECK: [[zdiv:_.*]] = Div(const 0_u64, _1);
-    // CHECK: opaque::<u64>(move [[zdiv]])
+    // CHECK: opaque::<u64>(const 0_u64)
     opaque(0 / x);
     // CHECK: [[odiv:_.*]] = Div(const 1_u64, _1);
     // CHECK: opaque::<u64>(move [[odiv]])
     opaque(1 / x);
+    // CHECK: assert(!const true, "attempt to calculate the remainder of `{}` with a divisor of zero"
     // CHECK: [[rem0:_.*]] = Rem(_1, const 0_u64);
     // CHECK: opaque::<u64>(move [[rem0]])
     opaque(x % 0);
-    // CHECK: [[rem1:_.*]] = Rem(_1, const 1_u64);
-    // CHECK: opaque::<u64>(move [[rem1]])
+    // CHECK: opaque::<u64>(const 0_u64)
     opaque(x % 1);
-    // CHECK: [[zrem:_.*]] = Rem(const 0_u64, _1);
-    // CHECK: opaque::<u64>(move [[zrem]])
+    // CHECK: opaque::<u64>(const 0_u64)
     opaque(0 % x);
     // CHECK: [[orem:_.*]] = Rem(const 1_u64, _1);
     // CHECK: opaque::<u64>(move [[orem]])
     opaque(1 % x);
-    // CHECK: [[and:_.*]] = BitAnd(_1, const 0_u64);
-    // CHECK: opaque::<u64>(move [[and]])
+    // CHECK: opaque::<u64>(const 0_u64)
     opaque(x & 0);
-    // CHECK: [[or:_.*]] = BitOr(_1, const 0_u64);
-    // CHECK: opaque::<u64>(move [[or]])
+    // CHECK: opaque::<u64>(_1)
+    opaque(x & u64::MAX);
+    // CHECK: opaque::<u64>(_1)
     opaque(x | 0);
-    // CHECK: [[xor:_.*]] = BitXor(_1, const 0_u64);
-    // CHECK: opaque::<u64>(move [[xor]])
+    // CHECK: opaque::<u64>(const u64::MAX)
+    opaque(x | u64::MAX);
+    // CHECK: opaque::<u64>(_1)
     opaque(x ^ 0);
-    // CHECK: [[shr:_.*]] = Shr(_1, const 0_i32);
-    // CHECK: opaque::<u64>(move [[shr]])
+    // CHECK: opaque::<u64>(const 0_u64)
+    opaque(x ^ x);
+    // CHECK: opaque::<u64>(_1)
     opaque(x >> 0);
-    // CHECK: [[shl:_.*]] = Shl(_1, const 0_i32);
-    // CHECK: opaque::<u64>(move [[shl]])
+    // CHECK: opaque::<u64>(_1)
     opaque(x << 0);
 }
 
 fn comparison(x: u64, y: u64) {
     // CHECK-LABEL: fn comparison(
-    // CHECK: [[eqxx:_.*]] = Eq(_1, _1);
-    // CHECK: opaque::<bool>(move [[eqxx]])
+    // CHECK: opaque::<bool>(const true)
     opaque(x == x);
-    // CHECK: [[nexx:_.*]] = Ne(_1, _1);
-    // CHECK: opaque::<bool>(move [[nexx]])
+    // CHECK: opaque::<bool>(const false)
     opaque(x != x);
     // CHECK: [[eqxy:_.*]] = Eq(_1, _2);
     // CHECK: opaque::<bool>(move [[eqxy]])
@@ -242,21 +237,20 @@ fn comparison(x: u64, y: u64) {
 #[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::<u64>(move [[add]])
+    // CHECK: assert(!const false,
+    // CHECK: opaque::<u64>(_1)
     opaque(x + 0);
-    // CHECK: [[csub:_.*]] = CheckedSub(_1, const 0_u64);
-    // CHECK: [[sub:_.*]] = move ([[csub]].0: u64);
-    // CHECK: opaque::<u64>(move [[sub]])
+    // CHECK: assert(!const false,
+    // CHECK: opaque::<u64>(_1)
     opaque(x - 0);
-    // CHECK: [[cmul0:_.*]] = CheckedMul(_1, const 0_u64);
-    // CHECK: [[mul0:_.*]] = move ([[cmul0]].0: u64);
-    // CHECK: opaque::<u64>(move [[mul0]])
+    // CHECK: assert(!const false,
+    // CHECK: opaque::<u64>(const 0_u64)
+    opaque(x - x);
+    // CHECK: assert(!const false,
+    // CHECK: opaque::<u64>(const 0_u64)
     opaque(x * 0);
-    // CHECK: [[cmul1:_.*]] = CheckedMul(_1, const 1_u64);
-    // CHECK: [[mul1:_.*]] = move ([[cmul1]].0: u64);
-    // CHECK: opaque::<u64>(move [[mul1]])
+    // CHECK: assert(!const false,
+    // CHECK: opaque::<u64>(_1)
     opaque(x * 1);
 }
 
diff --git a/tests/mir-opt/issue_101973.inner.GVN.panic-abort.diff b/tests/mir-opt/issue_101973.inner.GVN.panic-abort.diff
index b04728a9b0f..187290785c0 100644
--- a/tests/mir-opt/issue_101973.inner.GVN.panic-abort.diff
+++ b/tests/mir-opt/issue_101973.inner.GVN.panic-abort.diff
@@ -19,7 +19,6 @@
       scope 1 (inlined imm8) {
           debug x => _5;
           let mut _14: u32;
-          let mut _15: u32;
           scope 2 {
               debug out => _4;
           }
@@ -36,14 +35,14 @@
           StorageLive(_5);
           _5 = _1;
           _4 = const 0_u32;
-          StorageLive(_15);
-          StorageLive(_14);
--         _14 = Shr(_5, const 0_i32);
-+         _14 = Shr(_1, const 0_i32);
-          _15 = BitAnd(move _14, const 255_u32);
-          StorageDead(_14);
-          _4 = BitOr(const 0_u32, move _15);
-          StorageDead(_15);
+-         StorageLive(_14);
+-         _14 = BitAnd(_5, const 255_u32);
+-         _4 = BitOr(const 0_u32, move _14);
+-         StorageDead(_14);
++         nop;
++         _14 = BitAnd(_1, const 255_u32);
++         _4 = _14;
++         nop;
           StorageDead(_5);
           StorageLive(_6);
           StorageLive(_7);
diff --git a/tests/mir-opt/issue_101973.inner.GVN.panic-unwind.diff b/tests/mir-opt/issue_101973.inner.GVN.panic-unwind.diff
index fcf99ac6918..99350bac478 100644
--- a/tests/mir-opt/issue_101973.inner.GVN.panic-unwind.diff
+++ b/tests/mir-opt/issue_101973.inner.GVN.panic-unwind.diff
@@ -19,7 +19,6 @@
       scope 1 (inlined imm8) {
           debug x => _5;
           let mut _14: u32;
-          let mut _15: u32;
           scope 2 {
               debug out => _4;
           }
@@ -36,14 +35,14 @@
           StorageLive(_5);
           _5 = _1;
           _4 = const 0_u32;
-          StorageLive(_15);
-          StorageLive(_14);
--         _14 = Shr(_5, const 0_i32);
-+         _14 = Shr(_1, const 0_i32);
-          _15 = BitAnd(move _14, const 255_u32);
-          StorageDead(_14);
-          _4 = BitOr(const 0_u32, move _15);
-          StorageDead(_15);
+-         StorageLive(_14);
+-         _14 = BitAnd(_5, const 255_u32);
+-         _4 = BitOr(const 0_u32, move _14);
+-         StorageDead(_14);
++         nop;
++         _14 = BitAnd(_1, const 255_u32);
++         _4 = _14;
++         nop;
           StorageDead(_5);
           StorageLive(_6);
           StorageLive(_7);