Do not read a scalar on a non-scalar layout.

4 files changed, 802 insertions, 2 deletions

diff --git a/compiler/rustc_mir_transform/src/gvn.rs b/compiler/rustc_mir_transform/src/gvn.rs
index afc75ff1313..fc14ea2696f 100644
--- a/compiler/rustc_mir_transform/src/gvn.rs
+++ b/compiler/rustc_mir_transform/src/gvn.rs
@@ -953,8 +953,13 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
 
         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()
+            if layout.abi.is_scalar() {
+                let scalar = self.ecx.read_scalar(constant).ok()?;
+                scalar.to_bits(constant.layout.size).ok()
+            } else {
+                // `constant` is a wide pointer. Do not evaluate to bits.
+                None
+            }
         };
 
         // Represent the values as `Ok(bits)` or `Err(VnIndex)`.
diff --git a/tests/mir-opt/gvn.rs b/tests/mir-opt/gvn.rs
index f8f4fdcd732..31ea237cbec 100644
--- a/tests/mir-opt/gvn.rs
+++ b/tests/mir-opt/gvn.rs
@@ -644,6 +644,27 @@ fn constant_index_overflow<T: Copy>(x: &[T]) {
     opaque(b)
 }
 
+fn wide_ptr_ops() {
+    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;
+
+    let a: *const [u8] = unsafe { transmute((1usize, 1usize)) };
+    let b: *const [u8] = unsafe { transmute((1usize, 2usize)) };
+
+    opaque(!(a == b));
+    opaque(a != b);
+    opaque(a <= b);
+    opaque(a < b);
+    opaque(!(a >= b));
+    opaque(!(a > b));
+}
+
 fn main() {
     subexpression_elimination(2, 4, 5);
     wrap_unwrap(5);
@@ -664,6 +685,7 @@ fn main() {
     fn_pointers();
     indirect_static();
     constant_index_overflow(&[5, 3]);
+    wide_ptr_ops();
 }
 
 #[inline(never)]
@@ -692,3 +714,4 @@ 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
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
new file mode 100644
index 00000000000..e49d759b8fc
--- /dev/null
+++ b/tests/mir-opt/gvn.wide_ptr_ops.GVN.panic-abort.diff
@@ -0,0 +1,386 @@
+- // 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 = Eq(const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8], const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8]);
+          StorageDead(_45);
+          StorageDead(_44);
+          _42 = Not(move _43);
+          StorageDead(_43);
+-         _41 = opaque::<bool>(move _42) -> [return: bb1, unwind unreachable];
++         _41 = opaque::<bool>(_42) -> [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 = _42;
+          StorageDead(_49);
+          StorageDead(_48);
+-         _46 = opaque::<bool>(move _47) -> [return: bb2, unwind unreachable];
++         _46 = opaque::<bool>(_42) -> [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 = Le(const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8], const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8]);
+          StorageDead(_53);
+          StorageDead(_52);
+          _50 = opaque::<bool>(move _51) -> [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 = Lt(const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8], const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8]);
+          StorageDead(_57);
+          StorageDead(_56);
+          _54 = opaque::<bool>(move _55) -> [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 = Ge(const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8], const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8]);
+          StorageDead(_62);
+          StorageDead(_61);
+          _59 = Not(move _60);
+          StorageDead(_60);
+          _58 = opaque::<bool>(move _59) -> [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 = Gt(const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8], const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8]);
+          StorageDead(_67);
+          StorageDead(_66);
+          _64 = Not(move _65);
+          StorageDead(_65);
+          _63 = opaque::<bool>(move _64) -> [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
new file mode 100644
index 00000000000..4e5608a4425
--- /dev/null
+++ b/tests/mir-opt/gvn.wide_ptr_ops.GVN.panic-unwind.diff
@@ -0,0 +1,386 @@
+- // 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 = Eq(const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8], const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8]);
+          StorageDead(_45);
+          StorageDead(_44);
+          _42 = Not(move _43);
+          StorageDead(_43);
+-         _41 = opaque::<bool>(move _42) -> [return: bb1, unwind continue];
++         _41 = opaque::<bool>(_42) -> [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 = _42;
+          StorageDead(_49);
+          StorageDead(_48);
+-         _46 = opaque::<bool>(move _47) -> [return: bb2, unwind continue];
++         _46 = opaque::<bool>(_42) -> [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 = Le(const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8], const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8]);
+          StorageDead(_53);
+          StorageDead(_52);
+          _50 = opaque::<bool>(move _51) -> [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 = Lt(const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8], const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8]);
+          StorageDead(_57);
+          StorageDead(_56);
+          _54 = opaque::<bool>(move _55) -> [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 = Ge(const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8], const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8]);
+          StorageDead(_62);
+          StorageDead(_61);
+          _59 = Not(move _60);
+          StorageDead(_60);
+          _58 = opaque::<bool>(move _59) -> [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 = Gt(const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8], const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8]);
+          StorageDead(_67);
+          StorageDead(_66);
+          _64 = Not(move _65);
+          StorageDead(_65);
+          _63 = opaque::<bool>(move _64) -> [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 │ ................
+  }
+