Split gvn wide ptr tests.

8 files changed, 894 insertions, 799 deletions

diff --git a/compiler/rustc_mir_transform/src/gvn.rs b/compiler/rustc_mir_transform/src/gvn.rs
index 0ef3cdbb337..1c5ab35281a 100644
--- a/compiler/rustc_mir_transform/src/gvn.rs
+++ b/compiler/rustc_mir_transform/src/gvn.rs
@@ -1046,6 +1046,9 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
 
         let mut from = operand.ty(self.local_decls, self.tcx);
         let mut value = self.simplify_operand(operand, location)?;
+        if from == to {
+            return Some(value);
+        }
 
         if let CastKind::PointerCoercion(ReifyFnPointer | ClosureFnPointer(_)) = kind {
             // Each reification of a generic fn may get a different pointer.
diff --git a/tests/mir-opt/gvn.rs b/tests/mir-opt/gvn.rs
index 31ea237cbec..7f7189c72d5 100644
--- a/tests/mir-opt/gvn.rs
+++ b/tests/mir-opt/gvn.rs
@@ -644,25 +644,53 @@ fn constant_index_overflow<T: Copy>(x: &[T]) {
     opaque(b)
 }
 
-fn wide_ptr_ops() {
+/// Check that we do not attempt to simplify anything when there is provenance.
+fn wide_ptr_provenance() {
+    // CHECK-LABEL: fn wide_ptr_provenance(
     let a: *const dyn Send = &1 as &dyn Send;
     let b: *const dyn Send = &1 as &dyn Send;
-    let _val = a == b;
-    let _val = a != b;
-    let _val = a < b;
-    let _val = a <= b;
-    let _val = a > b;
-    let _val = a >= b;
+
+    // CHECK: [[eqp:_.*]] = Eq([[a:_.*]], [[b:_.*]]);
+    // CHECK: opaque::<bool>(move [[eqp]])
+    opaque(a == b);
+    // CHECK: [[nep:_.*]] = Ne([[a]], [[b]]);
+    // CHECK: opaque::<bool>(move [[nep]])
+    opaque(a != b);
+    // CHECK: [[ltp:_.*]] = Lt([[a]], [[b]]);
+    // CHECK: opaque::<bool>(move [[ltp]])
+    opaque(a < b);
+    // CHECK: [[lep:_.*]] = Le([[a]], [[b]]);
+    // CHECK: opaque::<bool>(move [[lep]])
+    opaque(a <= b);
+    // CHECK: [[gtp:_.*]] = Gt([[a]], [[b]]);
+    // CHECK: opaque::<bool>(move [[gtp]])
+    opaque(a > b);
+    // CHECK: [[gep:_.*]] = Ge([[a]], [[b]]);
+    // CHECK: opaque::<bool>(move [[gep]])
+    opaque(a >= b);
+}
+
+/// Check that we do simplify when there is no provenance, and do not ICE.
+fn wide_ptr_integer() {
+    // CHECK-LABEL: fn wide_ptr_integer(
+    // CHECK: debug a => [[a:_.*]];
+    // CHECK: debug b => [[b:_.*]];
 
     let a: *const [u8] = unsafe { transmute((1usize, 1usize)) };
     let b: *const [u8] = unsafe { transmute((1usize, 2usize)) };
 
-    opaque(!(a == b));
+    // CHECK: opaque::<bool>(const false)
+    opaque(a == b);
+    // CHECK: opaque::<bool>(const true)
     opaque(a != b);
-    opaque(a <= b);
+    // CHECK: opaque::<bool>(const true)
     opaque(a < b);
-    opaque(!(a >= b));
-    opaque(!(a > b));
+    // CHECK: opaque::<bool>(const true)
+    opaque(a <= b);
+    // CHECK: opaque::<bool>(const false)
+    opaque(a > b);
+    // CHECK: opaque::<bool>(const false)
+    opaque(a >= b);
 }
 
 fn main() {
@@ -685,7 +713,8 @@ fn main() {
     fn_pointers();
     indirect_static();
     constant_index_overflow(&[5, 3]);
-    wide_ptr_ops();
+    wide_ptr_provenance();
+    wide_ptr_integer();
 }
 
 #[inline(never)]
@@ -714,4 +743,5 @@ fn identity<T>(x: T) -> T {
 // EMIT_MIR gvn.fn_pointers.GVN.diff
 // EMIT_MIR gvn.indirect_static.GVN.diff
 // EMIT_MIR gvn.constant_index_overflow.GVN.diff
-// EMIT_MIR gvn.wide_ptr_ops.GVN.diff
+// EMIT_MIR gvn.wide_ptr_provenance.GVN.diff
+// EMIT_MIR gvn.wide_ptr_integer.GVN.diff
diff --git a/tests/mir-opt/gvn.wide_ptr_integer.GVN.panic-abort.diff b/tests/mir-opt/gvn.wide_ptr_integer.GVN.panic-abort.diff
new file mode 100644
index 00000000000..11cd43fc0e0
--- /dev/null
+++ b/tests/mir-opt/gvn.wide_ptr_integer.GVN.panic-abort.diff
@@ -0,0 +1,192 @@
+- // MIR for `wide_ptr_integer` before GVN
++ // MIR for `wide_ptr_integer` after GVN
+  
+  fn wide_ptr_integer() -> () {
+      let mut _0: ();
+      let _1: *const [u8];
+      let mut _2: (usize, usize);
+      let mut _4: (usize, usize);
+      let _5: ();
+      let mut _6: bool;
+      let mut _7: *const [u8];
+      let mut _8: *const [u8];
+      let _9: ();
+      let mut _10: bool;
+      let mut _11: *const [u8];
+      let mut _12: *const [u8];
+      let _13: ();
+      let mut _14: bool;
+      let mut _15: *const [u8];
+      let mut _16: *const [u8];
+      let _17: ();
+      let mut _18: bool;
+      let mut _19: *const [u8];
+      let mut _20: *const [u8];
+      let _21: ();
+      let mut _22: bool;
+      let mut _23: *const [u8];
+      let mut _24: *const [u8];
+      let _25: ();
+      let mut _26: bool;
+      let mut _27: *const [u8];
+      let mut _28: *const [u8];
+      scope 1 {
+          debug a => _1;
+          let _3: *const [u8];
+          scope 3 {
+              debug b => _3;
+          }
+          scope 4 {
+          }
+      }
+      scope 2 {
+      }
+  
+      bb0: {
+-         StorageLive(_1);
++         nop;
+          StorageLive(_2);
+-         _2 = (const 1_usize, const 1_usize);
+-         _1 = move _2 as *const [u8] (Transmute);
++         _2 = const (1_usize, 1_usize);
++         _1 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
+          StorageDead(_2);
+-         StorageLive(_3);
++         nop;
+          StorageLive(_4);
+-         _4 = (const 1_usize, const 2_usize);
+-         _3 = move _4 as *const [u8] (Transmute);
++         _4 = const (1_usize, 2_usize);
++         _3 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
+          StorageDead(_4);
+          StorageLive(_5);
+          StorageLive(_6);
+          StorageLive(_7);
+-         _7 = _1;
++         _7 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
+          StorageLive(_8);
+-         _8 = _3;
+-         _6 = Eq(move _7, move _8);
++         _8 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
++         _6 = const false;
+          StorageDead(_8);
+          StorageDead(_7);
+-         _5 = opaque::<bool>(move _6) -> [return: bb1, unwind unreachable];
++         _5 = opaque::<bool>(const false) -> [return: bb1, unwind unreachable];
+      }
+  
+      bb1: {
+          StorageDead(_6);
+          StorageDead(_5);
+          StorageLive(_9);
+          StorageLive(_10);
+          StorageLive(_11);
+-         _11 = _1;
++         _11 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
+          StorageLive(_12);
+-         _12 = _3;
+-         _10 = Ne(move _11, move _12);
++         _12 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
++         _10 = const true;
+          StorageDead(_12);
+          StorageDead(_11);
+-         _9 = opaque::<bool>(move _10) -> [return: bb2, unwind unreachable];
++         _9 = opaque::<bool>(const true) -> [return: bb2, unwind unreachable];
+      }
+  
+      bb2: {
+          StorageDead(_10);
+          StorageDead(_9);
+          StorageLive(_13);
+          StorageLive(_14);
+          StorageLive(_15);
+-         _15 = _1;
++         _15 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
+          StorageLive(_16);
+-         _16 = _3;
+-         _14 = Lt(move _15, move _16);
++         _16 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
++         _14 = const true;
+          StorageDead(_16);
+          StorageDead(_15);
+-         _13 = opaque::<bool>(move _14) -> [return: bb3, unwind unreachable];
++         _13 = opaque::<bool>(const true) -> [return: bb3, unwind unreachable];
+      }
+  
+      bb3: {
+          StorageDead(_14);
+          StorageDead(_13);
+          StorageLive(_17);
+          StorageLive(_18);
+          StorageLive(_19);
+-         _19 = _1;
++         _19 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
+          StorageLive(_20);
+-         _20 = _3;
+-         _18 = Le(move _19, move _20);
++         _20 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
++         _18 = const true;
+          StorageDead(_20);
+          StorageDead(_19);
+-         _17 = opaque::<bool>(move _18) -> [return: bb4, unwind unreachable];
++         _17 = opaque::<bool>(const true) -> [return: bb4, unwind unreachable];
+      }
+  
+      bb4: {
+          StorageDead(_18);
+          StorageDead(_17);
+          StorageLive(_21);
+          StorageLive(_22);
+          StorageLive(_23);
+-         _23 = _1;
++         _23 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
+          StorageLive(_24);
+-         _24 = _3;
+-         _22 = Gt(move _23, move _24);
++         _24 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
++         _22 = const false;
+          StorageDead(_24);
+          StorageDead(_23);
+-         _21 = opaque::<bool>(move _22) -> [return: bb5, unwind unreachable];
++         _21 = opaque::<bool>(const false) -> [return: bb5, unwind unreachable];
+      }
+  
+      bb5: {
+          StorageDead(_22);
+          StorageDead(_21);
+          StorageLive(_25);
+          StorageLive(_26);
+          StorageLive(_27);
+-         _27 = _1;
++         _27 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
+          StorageLive(_28);
+-         _28 = _3;
+-         _26 = Ge(move _27, move _28);
++         _28 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
++         _26 = const false;
+          StorageDead(_28);
+          StorageDead(_27);
+-         _25 = opaque::<bool>(move _26) -> [return: bb6, unwind unreachable];
++         _25 = opaque::<bool>(const false) -> [return: bb6, unwind unreachable];
+      }
+  
+      bb6: {
+          StorageDead(_26);
+          StorageDead(_25);
+          _0 = const ();
+-         StorageDead(_3);
+-         StorageDead(_1);
++         nop;
++         nop;
+          return;
+      }
++ }
++ 
++ ALLOC1 (size: 16, align: 8) {
++     01 00 00 00 00 00 00 00 02 00 00 00 00 00 00 00 │ ................
++ }
++ 
++ ALLOC0 (size: 16, align: 8) {
++     01 00 00 00 00 00 00 00 01 00 00 00 00 00 00 00 │ ................
+  }
+  
diff --git a/tests/mir-opt/gvn.wide_ptr_integer.GVN.panic-unwind.diff b/tests/mir-opt/gvn.wide_ptr_integer.GVN.panic-unwind.diff
new file mode 100644
index 00000000000..c77cd07c60c
--- /dev/null
+++ b/tests/mir-opt/gvn.wide_ptr_integer.GVN.panic-unwind.diff
@@ -0,0 +1,192 @@
+- // MIR for `wide_ptr_integer` before GVN
++ // MIR for `wide_ptr_integer` after GVN
+  
+  fn wide_ptr_integer() -> () {
+      let mut _0: ();
+      let _1: *const [u8];
+      let mut _2: (usize, usize);
+      let mut _4: (usize, usize);
+      let _5: ();
+      let mut _6: bool;
+      let mut _7: *const [u8];
+      let mut _8: *const [u8];
+      let _9: ();
+      let mut _10: bool;
+      let mut _11: *const [u8];
+      let mut _12: *const [u8];
+      let _13: ();
+      let mut _14: bool;
+      let mut _15: *const [u8];
+      let mut _16: *const [u8];
+      let _17: ();
+      let mut _18: bool;
+      let mut _19: *const [u8];
+      let mut _20: *const [u8];
+      let _21: ();
+      let mut _22: bool;
+      let mut _23: *const [u8];
+      let mut _24: *const [u8];
+      let _25: ();
+      let mut _26: bool;
+      let mut _27: *const [u8];
+      let mut _28: *const [u8];
+      scope 1 {
+          debug a => _1;
+          let _3: *const [u8];
+          scope 3 {
+              debug b => _3;
+          }
+          scope 4 {
+          }
+      }
+      scope 2 {
+      }
+  
+      bb0: {
+-         StorageLive(_1);
++         nop;
+          StorageLive(_2);
+-         _2 = (const 1_usize, const 1_usize);
+-         _1 = move _2 as *const [u8] (Transmute);
++         _2 = const (1_usize, 1_usize);
++         _1 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
+          StorageDead(_2);
+-         StorageLive(_3);
++         nop;
+          StorageLive(_4);
+-         _4 = (const 1_usize, const 2_usize);
+-         _3 = move _4 as *const [u8] (Transmute);
++         _4 = const (1_usize, 2_usize);
++         _3 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
+          StorageDead(_4);
+          StorageLive(_5);
+          StorageLive(_6);
+          StorageLive(_7);
+-         _7 = _1;
++         _7 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
+          StorageLive(_8);
+-         _8 = _3;
+-         _6 = Eq(move _7, move _8);
++         _8 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
++         _6 = const false;
+          StorageDead(_8);
+          StorageDead(_7);
+-         _5 = opaque::<bool>(move _6) -> [return: bb1, unwind continue];
++         _5 = opaque::<bool>(const false) -> [return: bb1, unwind continue];
+      }
+  
+      bb1: {
+          StorageDead(_6);
+          StorageDead(_5);
+          StorageLive(_9);
+          StorageLive(_10);
+          StorageLive(_11);
+-         _11 = _1;
++         _11 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
+          StorageLive(_12);
+-         _12 = _3;
+-         _10 = Ne(move _11, move _12);
++         _12 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
++         _10 = const true;
+          StorageDead(_12);
+          StorageDead(_11);
+-         _9 = opaque::<bool>(move _10) -> [return: bb2, unwind continue];
++         _9 = opaque::<bool>(const true) -> [return: bb2, unwind continue];
+      }
+  
+      bb2: {
+          StorageDead(_10);
+          StorageDead(_9);
+          StorageLive(_13);
+          StorageLive(_14);
+          StorageLive(_15);
+-         _15 = _1;
++         _15 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
+          StorageLive(_16);
+-         _16 = _3;
+-         _14 = Lt(move _15, move _16);
++         _16 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
++         _14 = const true;
+          StorageDead(_16);
+          StorageDead(_15);
+-         _13 = opaque::<bool>(move _14) -> [return: bb3, unwind continue];
++         _13 = opaque::<bool>(const true) -> [return: bb3, unwind continue];
+      }
+  
+      bb3: {
+          StorageDead(_14);
+          StorageDead(_13);
+          StorageLive(_17);
+          StorageLive(_18);
+          StorageLive(_19);
+-         _19 = _1;
++         _19 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
+          StorageLive(_20);
+-         _20 = _3;
+-         _18 = Le(move _19, move _20);
++         _20 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
++         _18 = const true;
+          StorageDead(_20);
+          StorageDead(_19);
+-         _17 = opaque::<bool>(move _18) -> [return: bb4, unwind continue];
++         _17 = opaque::<bool>(const true) -> [return: bb4, unwind continue];
+      }
+  
+      bb4: {
+          StorageDead(_18);
+          StorageDead(_17);
+          StorageLive(_21);
+          StorageLive(_22);
+          StorageLive(_23);
+-         _23 = _1;
++         _23 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
+          StorageLive(_24);
+-         _24 = _3;
+-         _22 = Gt(move _23, move _24);
++         _24 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
++         _22 = const false;
+          StorageDead(_24);
+          StorageDead(_23);
+-         _21 = opaque::<bool>(move _22) -> [return: bb5, unwind continue];
++         _21 = opaque::<bool>(const false) -> [return: bb5, unwind continue];
+      }
+  
+      bb5: {
+          StorageDead(_22);
+          StorageDead(_21);
+          StorageLive(_25);
+          StorageLive(_26);
+          StorageLive(_27);
+-         _27 = _1;
++         _27 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
+          StorageLive(_28);
+-         _28 = _3;
+-         _26 = Ge(move _27, move _28);
++         _28 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
++         _26 = const false;
+          StorageDead(_28);
+          StorageDead(_27);
+-         _25 = opaque::<bool>(move _26) -> [return: bb6, unwind continue];
++         _25 = opaque::<bool>(const false) -> [return: bb6, unwind continue];
+      }
+  
+      bb6: {
+          StorageDead(_26);
+          StorageDead(_25);
+          _0 = const ();
+-         StorageDead(_3);
+-         StorageDead(_1);
++         nop;
++         nop;
+          return;
+      }
++ }
++ 
++ ALLOC1 (size: 16, align: 8) {
++     01 00 00 00 00 00 00 00 02 00 00 00 00 00 00 00 │ ................
++ }
++ 
++ ALLOC0 (size: 16, align: 8) {
++     01 00 00 00 00 00 00 00 01 00 00 00 00 00 00 00 │ ................
+  }
+  
diff --git a/tests/mir-opt/gvn.wide_ptr_ops.GVN.panic-abort.diff b/tests/mir-opt/gvn.wide_ptr_ops.GVN.panic-abort.diff
deleted file mode 100644
index 9ffac0f88de..00000000000
--- a/tests/mir-opt/gvn.wide_ptr_ops.GVN.panic-abort.diff
+++ /dev/null
@@ -1,393 +0,0 @@
-- // MIR for `wide_ptr_ops` before GVN
-+ // MIR for `wide_ptr_ops` after GVN
-  
-  fn wide_ptr_ops() -> () {
-      let mut _0: ();
-      let _1: *const dyn std::marker::Send;
-      let mut _2: *const dyn std::marker::Send;
-      let _3: &dyn std::marker::Send;
-      let mut _4: &i32;
-      let _5: &i32;
-      let _6: i32;
-      let mut _8: *const dyn std::marker::Send;
-      let _9: &dyn std::marker::Send;
-      let mut _10: &i32;
-      let _11: &i32;
-      let _12: i32;
-      let mut _14: *const dyn std::marker::Send;
-      let mut _15: *const dyn std::marker::Send;
-      let mut _16: *const dyn std::marker::Send;
-      let mut _18: *const dyn std::marker::Send;
-      let mut _19: *const dyn std::marker::Send;
-      let mut _20: *const dyn std::marker::Send;
-      let mut _22: *const dyn std::marker::Send;
-      let mut _23: *const dyn std::marker::Send;
-      let mut _24: *const dyn std::marker::Send;
-      let mut _26: *const dyn std::marker::Send;
-      let mut _27: *const dyn std::marker::Send;
-      let mut _28: *const dyn std::marker::Send;
-      let mut _30: *const dyn std::marker::Send;
-      let mut _31: *const dyn std::marker::Send;
-      let mut _32: *const dyn std::marker::Send;
-      let mut _34: *const dyn std::marker::Send;
-      let mut _35: *const dyn std::marker::Send;
-      let mut _36: *const dyn std::marker::Send;
-      let mut _38: (usize, usize);
-      let mut _40: (usize, usize);
-      let _41: ();
-      let mut _42: bool;
-      let mut _43: bool;
-      let mut _44: *const [u8];
-      let mut _45: *const [u8];
-      let _46: ();
-      let mut _47: bool;
-      let mut _48: *const [u8];
-      let mut _49: *const [u8];
-      let _50: ();
-      let mut _51: bool;
-      let mut _52: *const [u8];
-      let mut _53: *const [u8];
-      let _54: ();
-      let mut _55: bool;
-      let mut _56: *const [u8];
-      let mut _57: *const [u8];
-      let _58: ();
-      let mut _59: bool;
-      let mut _60: bool;
-      let mut _61: *const [u8];
-      let mut _62: *const [u8];
-      let _63: ();
-      let mut _64: bool;
-      let mut _65: bool;
-      let mut _66: *const [u8];
-      let mut _67: *const [u8];
-      let mut _69: &i32;
-      scope 1 {
-          debug a => _1;
-          let _7: *const dyn std::marker::Send;
-          let mut _68: &i32;
-          scope 2 {
-              debug b => _7;
-              let _13: bool;
-              scope 3 {
-                  debug _val => _13;
-                  let _17: bool;
-                  scope 4 {
-                      debug _val => _17;
-                      let _21: bool;
-                      scope 5 {
-                          debug _val => _21;
-                          let _25: bool;
-                          scope 6 {
-                              debug _val => _25;
-                              let _29: bool;
-                              scope 7 {
-                                  debug _val => _29;
-                                  let _33: bool;
-                                  scope 8 {
-                                      debug _val => _33;
-                                      let _37: *const [u8];
-                                      scope 9 {
-                                          debug a => _37;
-                                          let _39: *const [u8];
-                                          scope 11 {
-                                              debug b => _39;
-                                          }
-                                          scope 12 {
-                                          }
-                                      }
-                                      scope 10 {
-                                      }
-                                  }
-                              }
-                          }
-                      }
-                  }
-              }
-          }
-      }
-  
-      bb0: {
--         StorageLive(_1);
-+         nop;
-          StorageLive(_2);
-          StorageLive(_3);
-          StorageLive(_4);
-          StorageLive(_5);
-          _69 = const _;
-          _5 = &(*_69);
-          _4 = &(*_5);
-          _3 = move _4 as &dyn std::marker::Send (PointerCoercion(Unsize));
-          StorageDead(_4);
-          _2 = &raw const (*_3);
-          _1 = move _2 as *const dyn std::marker::Send (PointerCoercion(Unsize));
-          StorageDead(_2);
-          StorageDead(_5);
-          StorageDead(_3);
--         StorageLive(_7);
-+         nop;
-          StorageLive(_8);
-          StorageLive(_9);
-          StorageLive(_10);
-          StorageLive(_11);
-          _68 = const _;
-          _11 = &(*_68);
-          _10 = &(*_11);
-          _9 = move _10 as &dyn std::marker::Send (PointerCoercion(Unsize));
-          StorageDead(_10);
-          _8 = &raw const (*_9);
-          _7 = move _8 as *const dyn std::marker::Send (PointerCoercion(Unsize));
-          StorageDead(_8);
-          StorageDead(_11);
-          StorageDead(_9);
-          StorageLive(_13);
-          StorageLive(_14);
-          _14 = _1;
--         StorageLive(_15);
-+         nop;
-          StorageLive(_16);
-          _16 = _7;
--         _15 = move _16 as *const dyn std::marker::Send (PointerCoercion(Unsize));
-+         _15 = _7 as *const dyn std::marker::Send (PointerCoercion(Unsize));
-          StorageDead(_16);
--         _13 = Eq(move _14, move _15);
--         StorageDead(_15);
-+         _13 = Eq(_1, _15);
-+         nop;
-          StorageDead(_14);
-          StorageLive(_17);
-          StorageLive(_18);
-          _18 = _1;
-          StorageLive(_19);
-          StorageLive(_20);
-          _20 = _7;
--         _19 = move _20 as *const dyn std::marker::Send (PointerCoercion(Unsize));
-+         _19 = _15;
-          StorageDead(_20);
--         _17 = Ne(move _18, move _19);
-+         _17 = Ne(_1, _15);
-          StorageDead(_19);
-          StorageDead(_18);
-          StorageLive(_21);
-          StorageLive(_22);
-          _22 = _1;
-          StorageLive(_23);
-          StorageLive(_24);
-          _24 = _7;
--         _23 = move _24 as *const dyn std::marker::Send (PointerCoercion(Unsize));
-+         _23 = _15;
-          StorageDead(_24);
--         _21 = Lt(move _22, move _23);
-+         _21 = Lt(_1, _15);
-          StorageDead(_23);
-          StorageDead(_22);
-          StorageLive(_25);
-          StorageLive(_26);
-          _26 = _1;
-          StorageLive(_27);
-          StorageLive(_28);
-          _28 = _7;
--         _27 = move _28 as *const dyn std::marker::Send (PointerCoercion(Unsize));
-+         _27 = _15;
-          StorageDead(_28);
--         _25 = Le(move _26, move _27);
-+         _25 = Le(_1, _15);
-          StorageDead(_27);
-          StorageDead(_26);
-          StorageLive(_29);
-          StorageLive(_30);
-          _30 = _1;
-          StorageLive(_31);
-          StorageLive(_32);
-          _32 = _7;
--         _31 = move _32 as *const dyn std::marker::Send (PointerCoercion(Unsize));
-+         _31 = _15;
-          StorageDead(_32);
--         _29 = Gt(move _30, move _31);
-+         _29 = Gt(_1, _15);
-          StorageDead(_31);
-          StorageDead(_30);
-          StorageLive(_33);
-          StorageLive(_34);
-          _34 = _1;
-          StorageLive(_35);
-          StorageLive(_36);
-          _36 = _7;
--         _35 = move _36 as *const dyn std::marker::Send (PointerCoercion(Unsize));
-+         _35 = _15;
-          StorageDead(_36);
--         _33 = Ge(move _34, move _35);
-+         _33 = Ge(_1, _15);
-          StorageDead(_35);
-          StorageDead(_34);
--         StorageLive(_37);
-+         nop;
-          StorageLive(_38);
--         _38 = (const 1_usize, const 1_usize);
--         _37 = move _38 as *const [u8] (Transmute);
-+         _38 = const (1_usize, 1_usize);
-+         _37 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
-          StorageDead(_38);
--         StorageLive(_39);
-+         nop;
-          StorageLive(_40);
--         _40 = (const 1_usize, const 2_usize);
--         _39 = move _40 as *const [u8] (Transmute);
-+         _40 = const (1_usize, 2_usize);
-+         _39 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
-          StorageDead(_40);
-          StorageLive(_41);
--         StorageLive(_42);
-+         nop;
-          StorageLive(_43);
-          StorageLive(_44);
--         _44 = _37;
-+         _44 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
-          StorageLive(_45);
--         _45 = _39;
--         _43 = Eq(move _44, move _45);
-+         _45 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
-+         _43 = const false;
-          StorageDead(_45);
-          StorageDead(_44);
--         _42 = Not(move _43);
-+         _42 = const true;
-          StorageDead(_43);
--         _41 = opaque::<bool>(move _42) -> [return: bb1, unwind unreachable];
-+         _41 = opaque::<bool>(const true) -> [return: bb1, unwind unreachable];
-      }
-  
-      bb1: {
--         StorageDead(_42);
-+         nop;
-          StorageDead(_41);
-          StorageLive(_46);
-          StorageLive(_47);
-          StorageLive(_48);
--         _48 = _37;
-+         _48 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
-          StorageLive(_49);
--         _49 = _39;
--         _47 = Ne(move _48, move _49);
-+         _49 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
-+         _47 = const true;
-          StorageDead(_49);
-          StorageDead(_48);
--         _46 = opaque::<bool>(move _47) -> [return: bb2, unwind unreachable];
-+         _46 = opaque::<bool>(const true) -> [return: bb2, unwind unreachable];
-      }
-  
-      bb2: {
-          StorageDead(_47);
-          StorageDead(_46);
-          StorageLive(_50);
-          StorageLive(_51);
-          StorageLive(_52);
--         _52 = _37;
-+         _52 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
-          StorageLive(_53);
--         _53 = _39;
--         _51 = Le(move _52, move _53);
-+         _53 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
-+         _51 = const true;
-          StorageDead(_53);
-          StorageDead(_52);
--         _50 = opaque::<bool>(move _51) -> [return: bb3, unwind unreachable];
-+         _50 = opaque::<bool>(const true) -> [return: bb3, unwind unreachable];
-      }
-  
-      bb3: {
-          StorageDead(_51);
-          StorageDead(_50);
-          StorageLive(_54);
-          StorageLive(_55);
-          StorageLive(_56);
--         _56 = _37;
-+         _56 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
-          StorageLive(_57);
--         _57 = _39;
--         _55 = Lt(move _56, move _57);
-+         _57 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
-+         _55 = const true;
-          StorageDead(_57);
-          StorageDead(_56);
--         _54 = opaque::<bool>(move _55) -> [return: bb4, unwind unreachable];
-+         _54 = opaque::<bool>(const true) -> [return: bb4, unwind unreachable];
-      }
-  
-      bb4: {
-          StorageDead(_55);
-          StorageDead(_54);
-          StorageLive(_58);
-          StorageLive(_59);
-          StorageLive(_60);
-          StorageLive(_61);
--         _61 = _37;
-+         _61 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
-          StorageLive(_62);
--         _62 = _39;
--         _60 = Ge(move _61, move _62);
-+         _62 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
-+         _60 = const false;
-          StorageDead(_62);
-          StorageDead(_61);
--         _59 = Not(move _60);
-+         _59 = const true;
-          StorageDead(_60);
--         _58 = opaque::<bool>(move _59) -> [return: bb5, unwind unreachable];
-+         _58 = opaque::<bool>(const true) -> [return: bb5, unwind unreachable];
-      }
-  
-      bb5: {
-          StorageDead(_59);
-          StorageDead(_58);
-          StorageLive(_63);
-          StorageLive(_64);
-          StorageLive(_65);
-          StorageLive(_66);
--         _66 = _37;
-+         _66 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
-          StorageLive(_67);
--         _67 = _39;
--         _65 = Gt(move _66, move _67);
-+         _67 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
-+         _65 = const false;
-          StorageDead(_67);
-          StorageDead(_66);
--         _64 = Not(move _65);
-+         _64 = const true;
-          StorageDead(_65);
--         _63 = opaque::<bool>(move _64) -> [return: bb6, unwind unreachable];
-+         _63 = opaque::<bool>(const true) -> [return: bb6, unwind unreachable];
-      }
-  
-      bb6: {
-          StorageDead(_64);
-          StorageDead(_63);
-          _0 = const ();
--         StorageDead(_39);
--         StorageDead(_37);
-+         nop;
-+         nop;
-          StorageDead(_33);
-          StorageDead(_29);
-          StorageDead(_25);
-          StorageDead(_21);
-          StorageDead(_17);
-          StorageDead(_13);
--         StorageDead(_7);
--         StorageDead(_1);
-+         nop;
-+         nop;
-          return;
-      }
-+ }
-+ 
-+ ALLOC1 (size: 16, align: 8) {
-+     01 00 00 00 00 00 00 00 02 00 00 00 00 00 00 00 │ ................
-+ }
-+ 
-+ ALLOC0 (size: 16, align: 8) {
-+     01 00 00 00 00 00 00 00 01 00 00 00 00 00 00 00 │ ................
-  }
-  
diff --git a/tests/mir-opt/gvn.wide_ptr_ops.GVN.panic-unwind.diff b/tests/mir-opt/gvn.wide_ptr_ops.GVN.panic-unwind.diff
deleted file mode 100644
index 96234cb14ef..00000000000
--- a/tests/mir-opt/gvn.wide_ptr_ops.GVN.panic-unwind.diff
+++ /dev/null
@@ -1,393 +0,0 @@
-- // MIR for `wide_ptr_ops` before GVN
-+ // MIR for `wide_ptr_ops` after GVN
-  
-  fn wide_ptr_ops() -> () {
-      let mut _0: ();
-      let _1: *const dyn std::marker::Send;
-      let mut _2: *const dyn std::marker::Send;
-      let _3: &dyn std::marker::Send;
-      let mut _4: &i32;
-      let _5: &i32;
-      let _6: i32;
-      let mut _8: *const dyn std::marker::Send;
-      let _9: &dyn std::marker::Send;
-      let mut _10: &i32;
-      let _11: &i32;
-      let _12: i32;
-      let mut _14: *const dyn std::marker::Send;
-      let mut _15: *const dyn std::marker::Send;
-      let mut _16: *const dyn std::marker::Send;
-      let mut _18: *const dyn std::marker::Send;
-      let mut _19: *const dyn std::marker::Send;
-      let mut _20: *const dyn std::marker::Send;
-      let mut _22: *const dyn std::marker::Send;
-      let mut _23: *const dyn std::marker::Send;
-      let mut _24: *const dyn std::marker::Send;
-      let mut _26: *const dyn std::marker::Send;
-      let mut _27: *const dyn std::marker::Send;
-      let mut _28: *const dyn std::marker::Send;
-      let mut _30: *const dyn std::marker::Send;
-      let mut _31: *const dyn std::marker::Send;
-      let mut _32: *const dyn std::marker::Send;
-      let mut _34: *const dyn std::marker::Send;
-      let mut _35: *const dyn std::marker::Send;
-      let mut _36: *const dyn std::marker::Send;
-      let mut _38: (usize, usize);
-      let mut _40: (usize, usize);
-      let _41: ();
-      let mut _42: bool;
-      let mut _43: bool;
-      let mut _44: *const [u8];
-      let mut _45: *const [u8];
-      let _46: ();
-      let mut _47: bool;
-      let mut _48: *const [u8];
-      let mut _49: *const [u8];
-      let _50: ();
-      let mut _51: bool;
-      let mut _52: *const [u8];
-      let mut _53: *const [u8];
-      let _54: ();
-      let mut _55: bool;
-      let mut _56: *const [u8];
-      let mut _57: *const [u8];
-      let _58: ();
-      let mut _59: bool;
-      let mut _60: bool;
-      let mut _61: *const [u8];
-      let mut _62: *const [u8];
-      let _63: ();
-      let mut _64: bool;
-      let mut _65: bool;
-      let mut _66: *const [u8];
-      let mut _67: *const [u8];
-      let mut _69: &i32;
-      scope 1 {
-          debug a => _1;
-          let _7: *const dyn std::marker::Send;
-          let mut _68: &i32;
-          scope 2 {
-              debug b => _7;
-              let _13: bool;
-              scope 3 {
-                  debug _val => _13;
-                  let _17: bool;
-                  scope 4 {
-                      debug _val => _17;
-                      let _21: bool;
-                      scope 5 {
-                          debug _val => _21;
-                          let _25: bool;
-                          scope 6 {
-                              debug _val => _25;
-                              let _29: bool;
-                              scope 7 {
-                                  debug _val => _29;
-                                  let _33: bool;
-                                  scope 8 {
-                                      debug _val => _33;
-                                      let _37: *const [u8];
-                                      scope 9 {
-                                          debug a => _37;
-                                          let _39: *const [u8];
-                                          scope 11 {
-                                              debug b => _39;
-                                          }
-                                          scope 12 {
-                                          }
-                                      }
-                                      scope 10 {
-                                      }
-                                  }
-                              }
-                          }
-                      }
-                  }
-              }
-          }
-      }
-  
-      bb0: {
--         StorageLive(_1);
-+         nop;
-          StorageLive(_2);
-          StorageLive(_3);
-          StorageLive(_4);
-          StorageLive(_5);
-          _69 = const _;
-          _5 = &(*_69);
-          _4 = &(*_5);
-          _3 = move _4 as &dyn std::marker::Send (PointerCoercion(Unsize));
-          StorageDead(_4);
-          _2 = &raw const (*_3);
-          _1 = move _2 as *const dyn std::marker::Send (PointerCoercion(Unsize));
-          StorageDead(_2);
-          StorageDead(_5);
-          StorageDead(_3);
--         StorageLive(_7);
-+         nop;
-          StorageLive(_8);
-          StorageLive(_9);
-          StorageLive(_10);
-          StorageLive(_11);
-          _68 = const _;
-          _11 = &(*_68);
-          _10 = &(*_11);
-          _9 = move _10 as &dyn std::marker::Send (PointerCoercion(Unsize));
-          StorageDead(_10);
-          _8 = &raw const (*_9);
-          _7 = move _8 as *const dyn std::marker::Send (PointerCoercion(Unsize));
-          StorageDead(_8);
-          StorageDead(_11);
-          StorageDead(_9);
-          StorageLive(_13);
-          StorageLive(_14);
-          _14 = _1;
--         StorageLive(_15);
-+         nop;
-          StorageLive(_16);
-          _16 = _7;
--         _15 = move _16 as *const dyn std::marker::Send (PointerCoercion(Unsize));
-+         _15 = _7 as *const dyn std::marker::Send (PointerCoercion(Unsize));
-          StorageDead(_16);
--         _13 = Eq(move _14, move _15);
--         StorageDead(_15);
-+         _13 = Eq(_1, _15);
-+         nop;
-          StorageDead(_14);
-          StorageLive(_17);
-          StorageLive(_18);
-          _18 = _1;
-          StorageLive(_19);
-          StorageLive(_20);
-          _20 = _7;
--         _19 = move _20 as *const dyn std::marker::Send (PointerCoercion(Unsize));
-+         _19 = _15;
-          StorageDead(_20);
--         _17 = Ne(move _18, move _19);
-+         _17 = Ne(_1, _15);
-          StorageDead(_19);
-          StorageDead(_18);
-          StorageLive(_21);
-          StorageLive(_22);
-          _22 = _1;
-          StorageLive(_23);
-          StorageLive(_24);
-          _24 = _7;
--         _23 = move _24 as *const dyn std::marker::Send (PointerCoercion(Unsize));
-+         _23 = _15;
-          StorageDead(_24);
--         _21 = Lt(move _22, move _23);
-+         _21 = Lt(_1, _15);
-          StorageDead(_23);
-          StorageDead(_22);
-          StorageLive(_25);
-          StorageLive(_26);
-          _26 = _1;
-          StorageLive(_27);
-          StorageLive(_28);
-          _28 = _7;
--         _27 = move _28 as *const dyn std::marker::Send (PointerCoercion(Unsize));
-+         _27 = _15;
-          StorageDead(_28);
--         _25 = Le(move _26, move _27);
-+         _25 = Le(_1, _15);
-          StorageDead(_27);
-          StorageDead(_26);
-          StorageLive(_29);
-          StorageLive(_30);
-          _30 = _1;
-          StorageLive(_31);
-          StorageLive(_32);
-          _32 = _7;
--         _31 = move _32 as *const dyn std::marker::Send (PointerCoercion(Unsize));
-+         _31 = _15;
-          StorageDead(_32);
--         _29 = Gt(move _30, move _31);
-+         _29 = Gt(_1, _15);
-          StorageDead(_31);
-          StorageDead(_30);
-          StorageLive(_33);
-          StorageLive(_34);
-          _34 = _1;
-          StorageLive(_35);
-          StorageLive(_36);
-          _36 = _7;
--         _35 = move _36 as *const dyn std::marker::Send (PointerCoercion(Unsize));
-+         _35 = _15;
-          StorageDead(_36);
--         _33 = Ge(move _34, move _35);
-+         _33 = Ge(_1, _15);
-          StorageDead(_35);
-          StorageDead(_34);
--         StorageLive(_37);
-+         nop;
-          StorageLive(_38);
--         _38 = (const 1_usize, const 1_usize);
--         _37 = move _38 as *const [u8] (Transmute);
-+         _38 = const (1_usize, 1_usize);
-+         _37 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
-          StorageDead(_38);
--         StorageLive(_39);
-+         nop;
-          StorageLive(_40);
--         _40 = (const 1_usize, const 2_usize);
--         _39 = move _40 as *const [u8] (Transmute);
-+         _40 = const (1_usize, 2_usize);
-+         _39 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
-          StorageDead(_40);
-          StorageLive(_41);
--         StorageLive(_42);
-+         nop;
-          StorageLive(_43);
-          StorageLive(_44);
--         _44 = _37;
-+         _44 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
-          StorageLive(_45);
--         _45 = _39;
--         _43 = Eq(move _44, move _45);
-+         _45 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
-+         _43 = const false;
-          StorageDead(_45);
-          StorageDead(_44);
--         _42 = Not(move _43);
-+         _42 = const true;
-          StorageDead(_43);
--         _41 = opaque::<bool>(move _42) -> [return: bb1, unwind continue];
-+         _41 = opaque::<bool>(const true) -> [return: bb1, unwind continue];
-      }
-  
-      bb1: {
--         StorageDead(_42);
-+         nop;
-          StorageDead(_41);
-          StorageLive(_46);
-          StorageLive(_47);
-          StorageLive(_48);
--         _48 = _37;
-+         _48 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
-          StorageLive(_49);
--         _49 = _39;
--         _47 = Ne(move _48, move _49);
-+         _49 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
-+         _47 = const true;
-          StorageDead(_49);
-          StorageDead(_48);
--         _46 = opaque::<bool>(move _47) -> [return: bb2, unwind continue];
-+         _46 = opaque::<bool>(const true) -> [return: bb2, unwind continue];
-      }
-  
-      bb2: {
-          StorageDead(_47);
-          StorageDead(_46);
-          StorageLive(_50);
-          StorageLive(_51);
-          StorageLive(_52);
--         _52 = _37;
-+         _52 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
-          StorageLive(_53);
--         _53 = _39;
--         _51 = Le(move _52, move _53);
-+         _53 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
-+         _51 = const true;
-          StorageDead(_53);
-          StorageDead(_52);
--         _50 = opaque::<bool>(move _51) -> [return: bb3, unwind continue];
-+         _50 = opaque::<bool>(const true) -> [return: bb3, unwind continue];
-      }
-  
-      bb3: {
-          StorageDead(_51);
-          StorageDead(_50);
-          StorageLive(_54);
-          StorageLive(_55);
-          StorageLive(_56);
--         _56 = _37;
-+         _56 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
-          StorageLive(_57);
--         _57 = _39;
--         _55 = Lt(move _56, move _57);
-+         _57 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
-+         _55 = const true;
-          StorageDead(_57);
-          StorageDead(_56);
--         _54 = opaque::<bool>(move _55) -> [return: bb4, unwind continue];
-+         _54 = opaque::<bool>(const true) -> [return: bb4, unwind continue];
-      }
-  
-      bb4: {
-          StorageDead(_55);
-          StorageDead(_54);
-          StorageLive(_58);
-          StorageLive(_59);
-          StorageLive(_60);
-          StorageLive(_61);
--         _61 = _37;
-+         _61 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
-          StorageLive(_62);
--         _62 = _39;
--         _60 = Ge(move _61, move _62);
-+         _62 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
-+         _60 = const false;
-          StorageDead(_62);
-          StorageDead(_61);
--         _59 = Not(move _60);
-+         _59 = const true;
-          StorageDead(_60);
--         _58 = opaque::<bool>(move _59) -> [return: bb5, unwind continue];
-+         _58 = opaque::<bool>(const true) -> [return: bb5, unwind continue];
-      }
-  
-      bb5: {
-          StorageDead(_59);
-          StorageDead(_58);
-          StorageLive(_63);
-          StorageLive(_64);
-          StorageLive(_65);
-          StorageLive(_66);
--         _66 = _37;
-+         _66 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
-          StorageLive(_67);
--         _67 = _39;
--         _65 = Gt(move _66, move _67);
-+         _67 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
-+         _65 = const false;
-          StorageDead(_67);
-          StorageDead(_66);
--         _64 = Not(move _65);
-+         _64 = const true;
-          StorageDead(_65);
--         _63 = opaque::<bool>(move _64) -> [return: bb6, unwind continue];
-+         _63 = opaque::<bool>(const true) -> [return: bb6, unwind continue];
-      }
-  
-      bb6: {
-          StorageDead(_64);
-          StorageDead(_63);
-          _0 = const ();
--         StorageDead(_39);
--         StorageDead(_37);
-+         nop;
-+         nop;
-          StorageDead(_33);
-          StorageDead(_29);
-          StorageDead(_25);
-          StorageDead(_21);
-          StorageDead(_17);
-          StorageDead(_13);
--         StorageDead(_7);
--         StorageDead(_1);
-+         nop;
-+         nop;
-          return;
-      }
-+ }
-+ 
-+ ALLOC1 (size: 16, align: 8) {
-+     01 00 00 00 00 00 00 00 02 00 00 00 00 00 00 00 │ ................
-+ }
-+ 
-+ ALLOC0 (size: 16, align: 8) {
-+     01 00 00 00 00 00 00 00 01 00 00 00 00 00 00 00 │ ................
-  }
-  
diff --git a/tests/mir-opt/gvn.wide_ptr_provenance.GVN.panic-abort.diff b/tests/mir-opt/gvn.wide_ptr_provenance.GVN.panic-abort.diff
new file mode 100644
index 00000000000..efb3dbec6f2
--- /dev/null
+++ b/tests/mir-opt/gvn.wide_ptr_provenance.GVN.panic-abort.diff
@@ -0,0 +1,232 @@
+- // MIR for `wide_ptr_provenance` before GVN
++ // MIR for `wide_ptr_provenance` after GVN
+  
+  fn wide_ptr_provenance() -> () {
+      let mut _0: ();
+      let _1: *const dyn std::marker::Send;
+      let mut _2: *const dyn std::marker::Send;
+      let _3: &dyn std::marker::Send;
+      let mut _4: &i32;
+      let _5: &i32;
+      let _6: i32;
+      let mut _8: *const dyn std::marker::Send;
+      let _9: &dyn std::marker::Send;
+      let mut _10: &i32;
+      let _11: &i32;
+      let _12: i32;
+      let _13: ();
+      let mut _14: bool;
+      let mut _15: *const dyn std::marker::Send;
+      let mut _16: *const dyn std::marker::Send;
+      let mut _17: *const dyn std::marker::Send;
+      let _18: ();
+      let mut _19: bool;
+      let mut _20: *const dyn std::marker::Send;
+      let mut _21: *const dyn std::marker::Send;
+      let mut _22: *const dyn std::marker::Send;
+      let _23: ();
+      let mut _24: bool;
+      let mut _25: *const dyn std::marker::Send;
+      let mut _26: *const dyn std::marker::Send;
+      let mut _27: *const dyn std::marker::Send;
+      let _28: ();
+      let mut _29: bool;
+      let mut _30: *const dyn std::marker::Send;
+      let mut _31: *const dyn std::marker::Send;
+      let mut _32: *const dyn std::marker::Send;
+      let _33: ();
+      let mut _34: bool;
+      let mut _35: *const dyn std::marker::Send;
+      let mut _36: *const dyn std::marker::Send;
+      let mut _37: *const dyn std::marker::Send;
+      let _38: ();
+      let mut _39: bool;
+      let mut _40: *const dyn std::marker::Send;
+      let mut _41: *const dyn std::marker::Send;
+      let mut _42: *const dyn std::marker::Send;
+      let mut _44: &i32;
+      scope 1 {
+          debug a => _1;
+          let _7: *const dyn std::marker::Send;
+          let mut _43: &i32;
+          scope 2 {
+              debug b => _7;
+          }
+      }
+  
+      bb0: {
+          StorageLive(_1);
+-         StorageLive(_2);
++         nop;
+          StorageLive(_3);
+          StorageLive(_4);
+          StorageLive(_5);
+          _44 = const _;
+          _5 = &(*_44);
+          _4 = &(*_5);
+          _3 = move _4 as &dyn std::marker::Send (PointerCoercion(Unsize));
+          StorageDead(_4);
+          _2 = &raw const (*_3);
+-         _1 = move _2 as *const dyn std::marker::Send (PointerCoercion(Unsize));
+-         StorageDead(_2);
++         _1 = _2;
++         nop;
+          StorageDead(_5);
+          StorageDead(_3);
+          StorageLive(_7);
+-         StorageLive(_8);
++         nop;
+          StorageLive(_9);
+          StorageLive(_10);
+          StorageLive(_11);
+          _43 = const _;
+          _11 = &(*_43);
+          _10 = &(*_11);
+          _9 = move _10 as &dyn std::marker::Send (PointerCoercion(Unsize));
+          StorageDead(_10);
+          _8 = &raw const (*_9);
+-         _7 = move _8 as *const dyn std::marker::Send (PointerCoercion(Unsize));
+-         StorageDead(_8);
++         _7 = _8;
++         nop;
+          StorageDead(_11);
+          StorageDead(_9);
+          StorageLive(_13);
+          StorageLive(_14);
+          StorageLive(_15);
+-         _15 = _1;
++         _15 = _2;
+          StorageLive(_16);
+          StorageLive(_17);
+-         _17 = _7;
+-         _16 = move _17 as *const dyn std::marker::Send (PointerCoercion(Unsize));
++         _17 = _8;
++         _16 = _8;
+          StorageDead(_17);
+-         _14 = Eq(move _15, move _16);
++         _14 = Eq(_2, _8);
+          StorageDead(_16);
+          StorageDead(_15);
+          _13 = opaque::<bool>(move _14) -> [return: bb1, unwind unreachable];
+      }
+  
+      bb1: {
+          StorageDead(_14);
+          StorageDead(_13);
+          StorageLive(_18);
+          StorageLive(_19);
+          StorageLive(_20);
+-         _20 = _1;
++         _20 = _2;
+          StorageLive(_21);
+          StorageLive(_22);
+-         _22 = _7;
+-         _21 = move _22 as *const dyn std::marker::Send (PointerCoercion(Unsize));
++         _22 = _8;
++         _21 = _8;
+          StorageDead(_22);
+-         _19 = Ne(move _20, move _21);
++         _19 = Ne(_2, _8);
+          StorageDead(_21);
+          StorageDead(_20);
+          _18 = opaque::<bool>(move _19) -> [return: bb2, unwind unreachable];
+      }
+  
+      bb2: {
+          StorageDead(_19);
+          StorageDead(_18);
+          StorageLive(_23);
+          StorageLive(_24);
+          StorageLive(_25);
+-         _25 = _1;
++         _25 = _2;
+          StorageLive(_26);
+          StorageLive(_27);
+-         _27 = _7;
+-         _26 = move _27 as *const dyn std::marker::Send (PointerCoercion(Unsize));
++         _27 = _8;
++         _26 = _8;
+          StorageDead(_27);
+-         _24 = Lt(move _25, move _26);
++         _24 = Lt(_2, _8);
+          StorageDead(_26);
+          StorageDead(_25);
+          _23 = opaque::<bool>(move _24) -> [return: bb3, unwind unreachable];
+      }
+  
+      bb3: {
+          StorageDead(_24);
+          StorageDead(_23);
+          StorageLive(_28);
+          StorageLive(_29);
+          StorageLive(_30);
+-         _30 = _1;
++         _30 = _2;
+          StorageLive(_31);
+          StorageLive(_32);
+-         _32 = _7;
+-         _31 = move _32 as *const dyn std::marker::Send (PointerCoercion(Unsize));
++         _32 = _8;
++         _31 = _8;
+          StorageDead(_32);
+-         _29 = Le(move _30, move _31);
++         _29 = Le(_2, _8);
+          StorageDead(_31);
+          StorageDead(_30);
+          _28 = opaque::<bool>(move _29) -> [return: bb4, unwind unreachable];
+      }
+  
+      bb4: {
+          StorageDead(_29);
+          StorageDead(_28);
+          StorageLive(_33);
+          StorageLive(_34);
+          StorageLive(_35);
+-         _35 = _1;
++         _35 = _2;
+          StorageLive(_36);
+          StorageLive(_37);
+-         _37 = _7;
+-         _36 = move _37 as *const dyn std::marker::Send (PointerCoercion(Unsize));
++         _37 = _8;
++         _36 = _8;
+          StorageDead(_37);
+-         _34 = Gt(move _35, move _36);
++         _34 = Gt(_2, _8);
+          StorageDead(_36);
+          StorageDead(_35);
+          _33 = opaque::<bool>(move _34) -> [return: bb5, unwind unreachable];
+      }
+  
+      bb5: {
+          StorageDead(_34);
+          StorageDead(_33);
+          StorageLive(_38);
+          StorageLive(_39);
+          StorageLive(_40);
+-         _40 = _1;
++         _40 = _2;
+          StorageLive(_41);
+          StorageLive(_42);
+-         _42 = _7;
+-         _41 = move _42 as *const dyn std::marker::Send (PointerCoercion(Unsize));
++         _42 = _8;
++         _41 = _8;
+          StorageDead(_42);
+-         _39 = Ge(move _40, move _41);
++         _39 = Ge(_2, _8);
+          StorageDead(_41);
+          StorageDead(_40);
+          _38 = opaque::<bool>(move _39) -> [return: bb6, unwind unreachable];
+      }
+  
+      bb6: {
+          StorageDead(_39);
+          StorageDead(_38);
+          _0 = const ();
+          StorageDead(_7);
+          StorageDead(_1);
+          return;
+      }
+  }
+  
diff --git a/tests/mir-opt/gvn.wide_ptr_provenance.GVN.panic-unwind.diff b/tests/mir-opt/gvn.wide_ptr_provenance.GVN.panic-unwind.diff
new file mode 100644
index 00000000000..ce8415e75ea
--- /dev/null
+++ b/tests/mir-opt/gvn.wide_ptr_provenance.GVN.panic-unwind.diff
@@ -0,0 +1,232 @@
+- // MIR for `wide_ptr_provenance` before GVN
++ // MIR for `wide_ptr_provenance` after GVN
+  
+  fn wide_ptr_provenance() -> () {
+      let mut _0: ();
+      let _1: *const dyn std::marker::Send;
+      let mut _2: *const dyn std::marker::Send;
+      let _3: &dyn std::marker::Send;
+      let mut _4: &i32;
+      let _5: &i32;
+      let _6: i32;
+      let mut _8: *const dyn std::marker::Send;
+      let _9: &dyn std::marker::Send;
+      let mut _10: &i32;
+      let _11: &i32;
+      let _12: i32;
+      let _13: ();
+      let mut _14: bool;
+      let mut _15: *const dyn std::marker::Send;
+      let mut _16: *const dyn std::marker::Send;
+      let mut _17: *const dyn std::marker::Send;
+      let _18: ();
+      let mut _19: bool;
+      let mut _20: *const dyn std::marker::Send;
+      let mut _21: *const dyn std::marker::Send;
+      let mut _22: *const dyn std::marker::Send;
+      let _23: ();
+      let mut _24: bool;
+      let mut _25: *const dyn std::marker::Send;
+      let mut _26: *const dyn std::marker::Send;
+      let mut _27: *const dyn std::marker::Send;
+      let _28: ();
+      let mut _29: bool;
+      let mut _30: *const dyn std::marker::Send;
+      let mut _31: *const dyn std::marker::Send;
+      let mut _32: *const dyn std::marker::Send;
+      let _33: ();
+      let mut _34: bool;
+      let mut _35: *const dyn std::marker::Send;
+      let mut _36: *const dyn std::marker::Send;
+      let mut _37: *const dyn std::marker::Send;
+      let _38: ();
+      let mut _39: bool;
+      let mut _40: *const dyn std::marker::Send;
+      let mut _41: *const dyn std::marker::Send;
+      let mut _42: *const dyn std::marker::Send;
+      let mut _44: &i32;
+      scope 1 {
+          debug a => _1;
+          let _7: *const dyn std::marker::Send;
+          let mut _43: &i32;
+          scope 2 {
+              debug b => _7;
+          }
+      }
+  
+      bb0: {
+          StorageLive(_1);
+-         StorageLive(_2);
++         nop;
+          StorageLive(_3);
+          StorageLive(_4);
+          StorageLive(_5);
+          _44 = const _;
+          _5 = &(*_44);
+          _4 = &(*_5);
+          _3 = move _4 as &dyn std::marker::Send (PointerCoercion(Unsize));
+          StorageDead(_4);
+          _2 = &raw const (*_3);
+-         _1 = move _2 as *const dyn std::marker::Send (PointerCoercion(Unsize));
+-         StorageDead(_2);
++         _1 = _2;
++         nop;
+          StorageDead(_5);
+          StorageDead(_3);
+          StorageLive(_7);
+-         StorageLive(_8);
++         nop;
+          StorageLive(_9);
+          StorageLive(_10);
+          StorageLive(_11);
+          _43 = const _;
+          _11 = &(*_43);
+          _10 = &(*_11);
+          _9 = move _10 as &dyn std::marker::Send (PointerCoercion(Unsize));
+          StorageDead(_10);
+          _8 = &raw const (*_9);
+-         _7 = move _8 as *const dyn std::marker::Send (PointerCoercion(Unsize));
+-         StorageDead(_8);
++         _7 = _8;
++         nop;
+          StorageDead(_11);
+          StorageDead(_9);
+          StorageLive(_13);
+          StorageLive(_14);
+          StorageLive(_15);
+-         _15 = _1;
++         _15 = _2;
+          StorageLive(_16);
+          StorageLive(_17);
+-         _17 = _7;
+-         _16 = move _17 as *const dyn std::marker::Send (PointerCoercion(Unsize));
++         _17 = _8;
++         _16 = _8;
+          StorageDead(_17);
+-         _14 = Eq(move _15, move _16);
++         _14 = Eq(_2, _8);
+          StorageDead(_16);
+          StorageDead(_15);
+          _13 = opaque::<bool>(move _14) -> [return: bb1, unwind continue];
+      }
+  
+      bb1: {
+          StorageDead(_14);
+          StorageDead(_13);
+          StorageLive(_18);
+          StorageLive(_19);
+          StorageLive(_20);
+-         _20 = _1;
++         _20 = _2;
+          StorageLive(_21);
+          StorageLive(_22);
+-         _22 = _7;
+-         _21 = move _22 as *const dyn std::marker::Send (PointerCoercion(Unsize));
++         _22 = _8;
++         _21 = _8;
+          StorageDead(_22);
+-         _19 = Ne(move _20, move _21);
++         _19 = Ne(_2, _8);
+          StorageDead(_21);
+          StorageDead(_20);
+          _18 = opaque::<bool>(move _19) -> [return: bb2, unwind continue];
+      }
+  
+      bb2: {
+          StorageDead(_19);
+          StorageDead(_18);
+          StorageLive(_23);
+          StorageLive(_24);
+          StorageLive(_25);
+-         _25 = _1;
++         _25 = _2;
+          StorageLive(_26);
+          StorageLive(_27);
+-         _27 = _7;
+-         _26 = move _27 as *const dyn std::marker::Send (PointerCoercion(Unsize));
++         _27 = _8;
++         _26 = _8;
+          StorageDead(_27);
+-         _24 = Lt(move _25, move _26);
++         _24 = Lt(_2, _8);
+          StorageDead(_26);
+          StorageDead(_25);
+          _23 = opaque::<bool>(move _24) -> [return: bb3, unwind continue];
+      }
+  
+      bb3: {
+          StorageDead(_24);
+          StorageDead(_23);
+          StorageLive(_28);
+          StorageLive(_29);
+          StorageLive(_30);
+-         _30 = _1;
++         _30 = _2;
+          StorageLive(_31);
+          StorageLive(_32);
+-         _32 = _7;
+-         _31 = move _32 as *const dyn std::marker::Send (PointerCoercion(Unsize));
++         _32 = _8;
++         _31 = _8;
+          StorageDead(_32);
+-         _29 = Le(move _30, move _31);
++         _29 = Le(_2, _8);
+          StorageDead(_31);
+          StorageDead(_30);
+          _28 = opaque::<bool>(move _29) -> [return: bb4, unwind continue];
+      }
+  
+      bb4: {
+          StorageDead(_29);
+          StorageDead(_28);
+          StorageLive(_33);
+          StorageLive(_34);
+          StorageLive(_35);
+-         _35 = _1;
++         _35 = _2;
+          StorageLive(_36);
+          StorageLive(_37);
+-         _37 = _7;
+-         _36 = move _37 as *const dyn std::marker::Send (PointerCoercion(Unsize));
++         _37 = _8;
++         _36 = _8;
+          StorageDead(_37);
+-         _34 = Gt(move _35, move _36);
++         _34 = Gt(_2, _8);
+          StorageDead(_36);
+          StorageDead(_35);
+          _33 = opaque::<bool>(move _34) -> [return: bb5, unwind continue];
+      }
+  
+      bb5: {
+          StorageDead(_34);
+          StorageDead(_33);
+          StorageLive(_38);
+          StorageLive(_39);
+          StorageLive(_40);
+-         _40 = _1;
++         _40 = _2;
+          StorageLive(_41);
+          StorageLive(_42);
+-         _42 = _7;
+-         _41 = move _42 as *const dyn std::marker::Send (PointerCoercion(Unsize));
++         _42 = _8;
++         _41 = _8;
+          StorageDead(_42);
+-         _39 = Ge(move _40, move _41);
++         _39 = Ge(_2, _8);
+          StorageDead(_41);
+          StorageDead(_40);
+          _38 = opaque::<bool>(move _39) -> [return: bb6, unwind continue];
+      }
+  
+      bb6: {
+          StorageDead(_39);
+          StorageDead(_38);
+          _0 = const ();
+          StorageDead(_7);
+          StorageDead(_1);
+          return;
+      }
+  }
+