Auto merge of #116707 - cjgillot:slice-id, r=oli-obk,RalfJung

Create an `AllocId` for `ConstValue::Slice`.

This PR modifies `ConstValue::Slice` to use an `AllocId` instead of directly manipulating the allocation. This was originally proposed by https://github.com/rust-lang/rust/pull/115764 but was a perf regression.

Almost 2 years later, enough code has changed to make this a perf improvement: https://github.com/rust-lang/rust/pull/116707#issuecomment-3067158777

55 files changed, 498 insertions, 59 deletions

diff --git a/tests/mir-opt/building/issue_101867.main.built.after.mir b/tests/mir-opt/building/issue_101867.main.built.after.mir
index dd1d093c4db..e59b23fdd20 100644
--- a/tests/mir-opt/building/issue_101867.main.built.after.mir
+++ b/tests/mir-opt/building/issue_101867.main.built.after.mir
@@ -71,3 +71,7 @@ fn main() -> () {
         resume;
     }
 }
+
+ALLOC0 (size: 14, align: 1) {
+    65 78 70 6c 69 63 69 74 20 70 61 6e 69 63       │ explicit panic
+}
diff --git a/tests/mir-opt/building/storage_live_dead_in_statics.XXX.built.after.mir b/tests/mir-opt/building/storage_live_dead_in_statics.XXX.built.after.mir
index 73ead005f8c..4ec12032690 100644
--- a/tests/mir-opt/building/storage_live_dead_in_statics.XXX.built.after.mir
+++ b/tests/mir-opt/building/storage_live_dead_in_statics.XXX.built.after.mir
@@ -198,3 +198,7 @@ static XXX: &Foo = {
         return;
     }
 }
+
+ALLOC0 (size: 2, align: 1) {
+    68 69                                           │ hi
+}
diff --git a/tests/mir-opt/building/user_type_annotations.let_else.built.after.mir b/tests/mir-opt/building/user_type_annotations.let_else.built.after.mir
index 3a515787c10..6369dbec750 100644
--- a/tests/mir-opt/building/user_type_annotations.let_else.built.after.mir
+++ b/tests/mir-opt/building/user_type_annotations.let_else.built.after.mir
@@ -78,3 +78,9 @@ fn let_else() -> () {
         resume;
     }
 }
+
+ALLOC0 (size: 40, align: 1) {
+    0x00 │ 69 6e 74 65 72 6e 61 6c 20 65 72 72 6f 72 3a 20 │ internal error: 
+    0x10 │ 65 6e 74 65 72 65 64 20 75 6e 72 65 61 63 68 61 │ entered unreacha
+    0x20 │ 62 6c 65 20 63 6f 64 65                         │ ble code
+}
diff --git a/tests/mir-opt/building/user_type_annotations.let_else_bindless.built.after.mir b/tests/mir-opt/building/user_type_annotations.let_else_bindless.built.after.mir
index 52a6d904d45..b2a06ae53a8 100644
--- a/tests/mir-opt/building/user_type_annotations.let_else_bindless.built.after.mir
+++ b/tests/mir-opt/building/user_type_annotations.let_else_bindless.built.after.mir
@@ -60,3 +60,9 @@ fn let_else_bindless() -> () {
         resume;
     }
 }
+
+ALLOC0 (size: 40, align: 1) {
+    0x00 │ 69 6e 74 65 72 6e 61 6c 20 65 72 72 6f 72 3a 20 │ internal error: 
+    0x10 │ 65 6e 74 65 72 65 64 20 75 6e 72 65 61 63 68 61 │ entered unreacha
+    0x20 │ 62 6c 65 20 63 6f 64 65                         │ ble code
+}
diff --git a/tests/mir-opt/const_debuginfo.main.SingleUseConsts.diff b/tests/mir-opt/const_debuginfo.main.SingleUseConsts.diff
index 8088984bc77..9baf8439e59 100644
--- a/tests/mir-opt/const_debuginfo.main.SingleUseConsts.diff
+++ b/tests/mir-opt/const_debuginfo.main.SingleUseConsts.diff
@@ -123,3 +123,5 @@
   
   ALLOC1 (size: 4, align: 2) { .. }
   
+  ALLOC2 (size: 13, align: 1) { .. }
+  
diff --git a/tests/mir-opt/const_prop/control_flow_simplification.hello.GVN.panic-abort.diff b/tests/mir-opt/const_prop/control_flow_simplification.hello.GVN.panic-abort.diff
index 417406de39b..24b10217865 100644
--- a/tests/mir-opt/const_prop/control_flow_simplification.hello.GVN.panic-abort.diff
+++ b/tests/mir-opt/const_prop/control_flow_simplification.hello.GVN.panic-abort.diff
@@ -24,3 +24,7 @@
       }
   }
   
+  ALLOC0 (size: 14, align: 1) {
+      65 78 70 6c 69 63 69 74 20 70 61 6e 69 63       │ explicit panic
+  }
+  
diff --git a/tests/mir-opt/const_prop/control_flow_simplification.hello.GVN.panic-unwind.diff b/tests/mir-opt/const_prop/control_flow_simplification.hello.GVN.panic-unwind.diff
index 63ba2c6865f..a73485e7944 100644
--- a/tests/mir-opt/const_prop/control_flow_simplification.hello.GVN.panic-unwind.diff
+++ b/tests/mir-opt/const_prop/control_flow_simplification.hello.GVN.panic-unwind.diff
@@ -24,3 +24,7 @@
       }
   }
   
+  ALLOC0 (size: 14, align: 1) {
+      65 78 70 6c 69 63 69 74 20 70 61 6e 69 63       │ explicit panic
+  }
+  
diff --git a/tests/mir-opt/dead-store-elimination/place_mention.main.DeadStoreElimination-initial.diff b/tests/mir-opt/dead-store-elimination/place_mention.main.DeadStoreElimination-initial.diff
index 5a550285871..8e224e0533a 100644
--- a/tests/mir-opt/dead-store-elimination/place_mention.main.DeadStoreElimination-initial.diff
+++ b/tests/mir-opt/dead-store-elimination/place_mention.main.DeadStoreElimination-initial.diff
@@ -17,3 +17,11 @@
       }
   }
   
+  ALLOC0 (size: 5, align: 1) {
+      57 6f 72 6c 64                                  │ World
+  }
+  
+  ALLOC1 (size: 5, align: 1) {
+      48 65 6c 6c 6f                                  │ Hello
+  }
+  
diff --git a/tests/mir-opt/gvn.duplicate_slice.GVN.panic-abort.diff b/tests/mir-opt/gvn.duplicate_slice.GVN.panic-abort.diff
index 18c2897d528..3bde339a839 100644
--- a/tests/mir-opt/gvn.duplicate_slice.GVN.panic-abort.diff
+++ b/tests/mir-opt/gvn.duplicate_slice.GVN.panic-abort.diff
@@ -16,23 +16,31 @@
   
       bb0: {
           _7 = (const "a",);
-          _1 = copy (_7.0: &str) as u128 (Transmute);
-          _5 = identity::<&str>(copy (_7.0: &str)) -> [return: bb1, unwind unreachable];
+-         _1 = copy (_7.0: &str) as u128 (Transmute);
+-         _5 = identity::<&str>(copy (_7.0: &str)) -> [return: bb1, unwind unreachable];
++         _1 = const "a" as u128 (Transmute);
++         _5 = identity::<&str>(const "a") -> [return: bb1, unwind unreachable];
       }
   
       bb1: {
           _3 = copy _5 as u128 (Transmute);
           _8 = const "a";
-          _2 = copy _8 as u128 (Transmute);
-          _6 = identity::<&str>(copy _8) -> [return: bb2, unwind unreachable];
+-         _2 = copy _8 as u128 (Transmute);
+-         _6 = identity::<&str>(copy _8) -> [return: bb2, unwind unreachable];
++         _2 = copy _1;
++         _6 = identity::<&str>(const "a") -> [return: bb2, unwind unreachable];
       }
   
       bb2: {
           _4 = copy _6 as u128 (Transmute);
-          _9 = Eq(copy _1, copy _2);
+-         _9 = Eq(copy _1, copy _2);
++         _9 = const true;
           _10 = Eq(copy _3, copy _4);
-          _0 = (copy _9, copy _10);
+-         _0 = (copy _9, copy _10);
++         _0 = (const true, copy _10);
           return;
       }
   }
   
+  ALLOC0 (size: 1, align: 1) { .. }
+  
diff --git a/tests/mir-opt/gvn.duplicate_slice.GVN.panic-unwind.diff b/tests/mir-opt/gvn.duplicate_slice.GVN.panic-unwind.diff
index 55f382e926e..cccfbf60585 100644
--- a/tests/mir-opt/gvn.duplicate_slice.GVN.panic-unwind.diff
+++ b/tests/mir-opt/gvn.duplicate_slice.GVN.panic-unwind.diff
@@ -16,23 +16,31 @@
   
       bb0: {
           _7 = (const "a",);
-          _1 = copy (_7.0: &str) as u128 (Transmute);
-          _5 = identity::<&str>(copy (_7.0: &str)) -> [return: bb1, unwind continue];
+-         _1 = copy (_7.0: &str) as u128 (Transmute);
+-         _5 = identity::<&str>(copy (_7.0: &str)) -> [return: bb1, unwind continue];
++         _1 = const "a" as u128 (Transmute);
++         _5 = identity::<&str>(const "a") -> [return: bb1, unwind continue];
       }
   
       bb1: {
           _3 = copy _5 as u128 (Transmute);
           _8 = const "a";
-          _2 = copy _8 as u128 (Transmute);
-          _6 = identity::<&str>(copy _8) -> [return: bb2, unwind continue];
+-         _2 = copy _8 as u128 (Transmute);
+-         _6 = identity::<&str>(copy _8) -> [return: bb2, unwind continue];
++         _2 = copy _1;
++         _6 = identity::<&str>(const "a") -> [return: bb2, unwind continue];
       }
   
       bb2: {
           _4 = copy _6 as u128 (Transmute);
-          _9 = Eq(copy _1, copy _2);
+-         _9 = Eq(copy _1, copy _2);
++         _9 = const true;
           _10 = Eq(copy _3, copy _4);
-          _0 = (copy _9, copy _10);
+-         _0 = (copy _9, copy _10);
++         _0 = (const true, copy _10);
           return;
       }
   }
   
+  ALLOC0 (size: 1, align: 1) { .. }
+  
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 3cce35d34e9..f3f63195637 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:620:19: 620:21};
+      let mut _9: {closure@$DIR/gvn.rs:617:19: 617:21};
       let _10: ();
       let mut _11: fn();
-      let mut _13: {closure@$DIR/gvn.rs:620:19: 620:21};
+      let mut _13: {closure@$DIR/gvn.rs:617:19: 617: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:620:19: 620:21};
+              let _7: {closure@$DIR/gvn.rs:617:19: 617:21};
               scope 3 {
                   debug closure => _7;
                   let _8: fn();
@@ -62,16 +62,16 @@
           StorageDead(_6);
           StorageDead(_5);
 -         StorageLive(_7);
--         _7 = {closure@$DIR/gvn.rs:620:19: 620:21};
+-         _7 = {closure@$DIR/gvn.rs:617:19: 617:21};
 -         StorageLive(_8);
 +         nop;
-+         _7 = const ZeroSized: {closure@$DIR/gvn.rs:620:19: 620:21};
++         _7 = const ZeroSized: {closure@$DIR/gvn.rs:617:19: 617:21};
 +         nop;
           StorageLive(_9);
 -         _9 = copy _7;
 -         _8 = move _9 as fn() (PointerCoercion(ClosureFnPointer(Safe), AsCast));
-+         _9 = const ZeroSized: {closure@$DIR/gvn.rs:620:19: 620:21};
-+         _8 = const ZeroSized: {closure@$DIR/gvn.rs:620:19: 620:21} as fn() (PointerCoercion(ClosureFnPointer(Safe), AsCast));
++         _9 = const ZeroSized: {closure@$DIR/gvn.rs:617:19: 617:21};
++         _8 = const ZeroSized: {closure@$DIR/gvn.rs:617:19: 617:21} as fn() (PointerCoercion(ClosureFnPointer(Safe), AsCast));
           StorageDead(_9);
           StorageLive(_10);
           StorageLive(_11);
@@ -88,8 +88,8 @@
           StorageLive(_13);
 -         _13 = copy _7;
 -         _12 = move _13 as fn() (PointerCoercion(ClosureFnPointer(Safe), AsCast));
-+         _13 = const ZeroSized: {closure@$DIR/gvn.rs:620:19: 620:21};
-+         _12 = const ZeroSized: {closure@$DIR/gvn.rs:620:19: 620:21} as fn() (PointerCoercion(ClosureFnPointer(Safe), AsCast));
++         _13 = const ZeroSized: {closure@$DIR/gvn.rs:617:19: 617:21};
++         _12 = const ZeroSized: {closure@$DIR/gvn.rs:617:19: 617:21} as fn() (PointerCoercion(ClosureFnPointer(Safe), AsCast));
           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 d85aca040fe..029e736a979 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:620:19: 620:21};
+      let mut _9: {closure@$DIR/gvn.rs:617:19: 617:21};
       let _10: ();
       let mut _11: fn();
-      let mut _13: {closure@$DIR/gvn.rs:620:19: 620:21};
+      let mut _13: {closure@$DIR/gvn.rs:617:19: 617: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:620:19: 620:21};
+              let _7: {closure@$DIR/gvn.rs:617:19: 617:21};
               scope 3 {
                   debug closure => _7;
                   let _8: fn();
@@ -62,16 +62,16 @@
           StorageDead(_6);
           StorageDead(_5);
 -         StorageLive(_7);
--         _7 = {closure@$DIR/gvn.rs:620:19: 620:21};
+-         _7 = {closure@$DIR/gvn.rs:617:19: 617:21};
 -         StorageLive(_8);
 +         nop;
-+         _7 = const ZeroSized: {closure@$DIR/gvn.rs:620:19: 620:21};
++         _7 = const ZeroSized: {closure@$DIR/gvn.rs:617:19: 617:21};
 +         nop;
           StorageLive(_9);
 -         _9 = copy _7;
 -         _8 = move _9 as fn() (PointerCoercion(ClosureFnPointer(Safe), AsCast));
-+         _9 = const ZeroSized: {closure@$DIR/gvn.rs:620:19: 620:21};
-+         _8 = const ZeroSized: {closure@$DIR/gvn.rs:620:19: 620:21} as fn() (PointerCoercion(ClosureFnPointer(Safe), AsCast));
++         _9 = const ZeroSized: {closure@$DIR/gvn.rs:617:19: 617:21};
++         _8 = const ZeroSized: {closure@$DIR/gvn.rs:617:19: 617:21} as fn() (PointerCoercion(ClosureFnPointer(Safe), AsCast));
           StorageDead(_9);
           StorageLive(_10);
           StorageLive(_11);
@@ -88,8 +88,8 @@
           StorageLive(_13);
 -         _13 = copy _7;
 -         _12 = move _13 as fn() (PointerCoercion(ClosureFnPointer(Safe), AsCast));
-+         _13 = const ZeroSized: {closure@$DIR/gvn.rs:620:19: 620:21};
-+         _12 = const ZeroSized: {closure@$DIR/gvn.rs:620:19: 620:21} as fn() (PointerCoercion(ClosureFnPointer(Safe), AsCast));
++         _13 = const ZeroSized: {closure@$DIR/gvn.rs:617:19: 617:21};
++         _12 = const ZeroSized: {closure@$DIR/gvn.rs:617:19: 617:21} as fn() (PointerCoercion(ClosureFnPointer(Safe), AsCast));
           StorageDead(_13);
           StorageLive(_14);
           StorageLive(_15);
diff --git a/tests/mir-opt/gvn.rs b/tests/mir-opt/gvn.rs
index 5d348bc3c1e..407980fd0fd 100644
--- a/tests/mir-opt/gvn.rs
+++ b/tests/mir-opt/gvn.rs
@@ -533,10 +533,10 @@ fn dereferences(t: &mut u32, u: &impl Copy, s: &S<u32>) {
 fn slices() {
     // CHECK-LABEL: fn slices(
     // CHECK: {{_.*}} = const "
-    // CHECK-NOT: {{_.*}} = const "
-    let s = "my favourite slice"; // This is a `Const::Slice` in MIR.
+    // CHECK: {{_.*}} = const "
+    let s = "my favourite slice";
     opaque(s);
-    let t = s; // This should be the same pointer, so cannot be a `Const::Slice`.
+    let t = s; // This should be the same pointer.
     opaque(t);
     assert_eq!(s.as_ptr(), t.as_ptr());
     let u = unsafe { transmute::<&str, &[u8]>(s) };
@@ -556,12 +556,12 @@ fn duplicate_slice() -> (bool, bool) {
         let d: &str;
         {
             // CHECK: [[a:_.*]] = (const "a",);
-            // CHECK: [[au:_.*]] = copy ([[a]].0: &str) as u128 (Transmute);
+            // CHECK: [[au:_.*]] = const "a" as u128 (Transmute);
             let a = ("a",);
             Call(au = transmute::<_, u128>(a.0), ReturnTo(bb1), UnwindContinue())
         }
         bb1 = {
-            // CHECK: [[c:_.*]] = identity::<&str>(copy ([[a]].0: &str))
+            // CHECK: [[c:_.*]] = identity::<&str>(const "a")
             Call(c = identity(a.0), ReturnTo(bb2), UnwindContinue())
         }
         bb2 = {
@@ -569,15 +569,13 @@ fn duplicate_slice() -> (bool, bool) {
             Call(cu = transmute::<_, u128>(c), ReturnTo(bb3), UnwindContinue())
         }
         bb3 = {
-            // This slice is different from `a.0`. Hence `bu` is not `au`.
             // CHECK: [[b:_.*]] = const "a";
-            // CHECK: [[bu:_.*]] = copy [[b]] as u128 (Transmute);
+            // CHECK: [[bu:_.*]] = copy [[au]];
             let b = "a";
             Call(bu = transmute::<_, u128>(b), ReturnTo(bb4), UnwindContinue())
         }
         bb4 = {
-            // This returns a copy of `b`, which is not `a`.
-            // CHECK: [[d:_.*]] = identity::<&str>(copy [[b]])
+            // CHECK: [[d:_.*]] = identity::<&str>(const "a")
             Call(d = identity(b), ReturnTo(bb5), UnwindContinue())
         }
         bb5 = {
@@ -585,8 +583,7 @@ fn duplicate_slice() -> (bool, bool) {
             Call(du = transmute::<_, u128>(d), ReturnTo(bb6), UnwindContinue())
         }
         bb6 = {
-            // `direct` must not fold to `true`, as `indirect` will not.
-            // CHECK: = Eq(copy [[au]], copy [[bu]]);
+            // CHECK: = const true;
             // CHECK: = Eq(copy [[cu]], copy [[du]]);
             let direct = au == bu;
             let indirect = cu == du;
diff --git a/tests/mir-opt/gvn.slices.GVN.panic-abort.diff b/tests/mir-opt/gvn.slices.GVN.panic-abort.diff
index e8e99b44e72..091c3bd5c7b 100644
--- a/tests/mir-opt/gvn.slices.GVN.panic-abort.diff
+++ b/tests/mir-opt/gvn.slices.GVN.panic-abort.diff
@@ -87,22 +87,24 @@
           _1 = const "my favourite slice";
           StorageLive(_2);
           StorageLive(_3);
-          _3 = copy _1;
+-         _3 = copy _1;
 -         _2 = opaque::<&str>(move _3) -> [return: bb1, unwind unreachable];
-+         _2 = opaque::<&str>(copy _1) -> [return: bb1, unwind unreachable];
++         _3 = const "my favourite slice";
++         _2 = opaque::<&str>(const "my favourite slice") -> [return: bb1, unwind unreachable];
       }
   
       bb1: {
           StorageDead(_3);
           StorageDead(_2);
           StorageLive(_4);
-          _4 = copy _1;
+-         _4 = copy _1;
++         _4 = const "my favourite slice";
           StorageLive(_5);
           StorageLive(_6);
 -         _6 = copy _4;
 -         _5 = opaque::<&str>(move _6) -> [return: bb2, unwind unreachable];
-+         _6 = copy _1;
-+         _5 = opaque::<&str>(copy _1) -> [return: bb2, unwind unreachable];
++         _6 = const "my favourite slice";
++         _5 = opaque::<&str>(const "my favourite slice") -> [return: bb2, unwind unreachable];
       }
   
       bb2: {
@@ -315,3 +317,5 @@
       }
   }
   
+  ALLOC0 (size: 18, align: 1) { .. }
+  
diff --git a/tests/mir-opt/gvn.slices.GVN.panic-unwind.diff b/tests/mir-opt/gvn.slices.GVN.panic-unwind.diff
index 4296d4d4a59..9768956c9c8 100644
--- a/tests/mir-opt/gvn.slices.GVN.panic-unwind.diff
+++ b/tests/mir-opt/gvn.slices.GVN.panic-unwind.diff
@@ -87,22 +87,24 @@
           _1 = const "my favourite slice";
           StorageLive(_2);
           StorageLive(_3);
-          _3 = copy _1;
+-         _3 = copy _1;
 -         _2 = opaque::<&str>(move _3) -> [return: bb1, unwind continue];
-+         _2 = opaque::<&str>(copy _1) -> [return: bb1, unwind continue];
++         _3 = const "my favourite slice";
++         _2 = opaque::<&str>(const "my favourite slice") -> [return: bb1, unwind continue];
       }
   
       bb1: {
           StorageDead(_3);
           StorageDead(_2);
           StorageLive(_4);
-          _4 = copy _1;
+-         _4 = copy _1;
++         _4 = const "my favourite slice";
           StorageLive(_5);
           StorageLive(_6);
 -         _6 = copy _4;
 -         _5 = opaque::<&str>(move _6) -> [return: bb2, unwind continue];
-+         _6 = copy _1;
-+         _5 = opaque::<&str>(copy _1) -> [return: bb2, unwind continue];
++         _6 = const "my favourite slice";
++         _5 = opaque::<&str>(const "my favourite slice") -> [return: bb2, unwind continue];
       }
   
       bb2: {
@@ -315,3 +317,5 @@
       }
   }
   
+  ALLOC0 (size: 18, align: 1) { .. }
+  
diff --git a/tests/mir-opt/gvn.wrap_unwrap.GVN.panic-abort.diff b/tests/mir-opt/gvn.wrap_unwrap.GVN.panic-abort.diff
index 0433152bb4f..3bbfd3a891e 100644
--- a/tests/mir-opt/gvn.wrap_unwrap.GVN.panic-abort.diff
+++ b/tests/mir-opt/gvn.wrap_unwrap.GVN.panic-abort.diff
@@ -47,3 +47,5 @@
       }
   }
   
+  ALLOC0 (size: 14, align: 1) { .. }
+  
diff --git a/tests/mir-opt/gvn.wrap_unwrap.GVN.panic-unwind.diff b/tests/mir-opt/gvn.wrap_unwrap.GVN.panic-unwind.diff
index 5722c865c2f..03464f43f81 100644
--- a/tests/mir-opt/gvn.wrap_unwrap.GVN.panic-unwind.diff
+++ b/tests/mir-opt/gvn.wrap_unwrap.GVN.panic-unwind.diff
@@ -47,3 +47,5 @@
       }
   }
   
+  ALLOC0 (size: 14, align: 1) { .. }
+  
diff --git a/tests/mir-opt/inline/inline_diverging.g.Inline.panic-abort.diff b/tests/mir-opt/inline/inline_diverging.g.Inline.panic-abort.diff
index bda85586515..423de59e575 100644
--- a/tests/mir-opt/inline/inline_diverging.g.Inline.panic-abort.diff
+++ b/tests/mir-opt/inline/inline_diverging.g.Inline.panic-abort.diff
@@ -38,5 +38,9 @@
 +         StorageLive(_7);
 +         _7 = begin_panic::<&str>(const "explicit panic") -> unwind unreachable;
       }
++ }
++ 
++ ALLOC0 (size: 14, align: 1) {
++     65 78 70 6c 69 63 69 74 20 70 61 6e 69 63       │ explicit panic
   }
   
diff --git a/tests/mir-opt/inline/inline_diverging.g.Inline.panic-unwind.diff b/tests/mir-opt/inline/inline_diverging.g.Inline.panic-unwind.diff
index ecd72d2b37f..3689744dcb0 100644
--- a/tests/mir-opt/inline/inline_diverging.g.Inline.panic-unwind.diff
+++ b/tests/mir-opt/inline/inline_diverging.g.Inline.panic-unwind.diff
@@ -38,5 +38,9 @@
 +         StorageLive(_7);
 +         _7 = begin_panic::<&str>(const "explicit panic") -> unwind continue;
       }
++ }
++ 
++ ALLOC0 (size: 14, align: 1) {
++     65 78 70 6c 69 63 69 74 20 70 61 6e 69 63       │ explicit panic
   }
   
diff --git a/tests/mir-opt/inline_coroutine_body.run2-{closure#0}.Inline.panic-abort.diff b/tests/mir-opt/inline_coroutine_body.run2-{closure#0}.Inline.panic-abort.diff
index 1e9a6dd4f5c..169a6768448 100644
--- a/tests/mir-opt/inline_coroutine_body.run2-{closure#0}.Inline.panic-abort.diff
+++ b/tests/mir-opt/inline_coroutine_body.run2-{closure#0}.Inline.panic-abort.diff
@@ -251,7 +251,7 @@
 +         StorageLive(_50);
 +         _50 = discriminant(_43);
 +         switchInt(move _50) -> [0: bb11, 1: bb12, otherwise: bb5];
-+     }
+      }
 + 
 +     bb5: {
 +         unreachable;
@@ -329,6 +329,11 @@
 +         StorageDead(_19);
 +         _25 = discriminant(_18);
 +         switchInt(move _25) -> [0: bb7, 1: bb6, otherwise: bb5];
-      }
++     }
++ }
++ 
++ ALLOC0 (size: 31, align: 1) {
++     0x00 │ 60 52 65 61 64 79 60 20 70 6f 6c 6c 65 64 20 61 │ `Ready` polled a
++     0x10 │ 66 74 65 72 20 63 6f 6d 70 6c 65 74 69 6f 6e    │ fter completion
   }
   
diff --git a/tests/mir-opt/inline_coroutine_body.run2-{closure#0}.Inline.panic-unwind.diff b/tests/mir-opt/inline_coroutine_body.run2-{closure#0}.Inline.panic-unwind.diff
index 94b89a310ba..14ba3311d2d 100644
--- a/tests/mir-opt/inline_coroutine_body.run2-{closure#0}.Inline.panic-unwind.diff
+++ b/tests/mir-opt/inline_coroutine_body.run2-{closure#0}.Inline.panic-unwind.diff
@@ -274,7 +274,7 @@
 -         resume;
 +     bb7: {
 +         unreachable;
-+     }
+      }
 + 
 +     bb8: {
 +         _17 = const ();
@@ -370,6 +370,11 @@
 +         StorageDead(_19);
 +         _25 = discriminant(_18);
 +         switchInt(move _25) -> [0: bb9, 1: bb8, otherwise: bb7];
-      }
++     }
++ }
++ 
++ ALLOC0 (size: 31, align: 1) {
++     0x00 │ 60 52 65 61 64 79 60 20 70 6f 6c 6c 65 64 20 61 │ `Ready` polled a
++     0x10 │ 66 74 65 72 20 63 6f 6d 70 6c 65 74 69 6f 6e    │ fter completion
   }
   
diff --git a/tests/mir-opt/instsimplify/aggregate_array.strs.InstSimplify-after-simplifycfg.diff b/tests/mir-opt/instsimplify/aggregate_array.strs.InstSimplify-after-simplifycfg.diff
index f8884881756..ca5573cf97f 100644
--- a/tests/mir-opt/instsimplify/aggregate_array.strs.InstSimplify-after-simplifycfg.diff
+++ b/tests/mir-opt/instsimplify/aggregate_array.strs.InstSimplify-after-simplifycfg.diff
@@ -11,3 +11,7 @@
       }
   }
   
+  ALLOC0 (size: 1, align: 1) {
+      61                                              │ a
+  }
+  
diff --git a/tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-abort.diff b/tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-abort.diff
index c02bab3524b..08dee3697e0 100644
--- a/tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-abort.diff
+++ b/tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-abort.diff
@@ -51,3 +51,9 @@
       }
   }
   
+  ALLOC0 (size: 40, align: 1) {
+      0x00 │ 69 6e 74 65 72 6e 61 6c 20 65 72 72 6f 72 3a 20 │ internal error: 
+      0x10 │ 65 6e 74 65 72 65 64 20 75 6e 72 65 61 63 68 61 │ entered unreacha
+      0x20 │ 62 6c 65 20 63 6f 64 65                         │ ble code
+  }
+  
diff --git a/tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-unwind.diff b/tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-unwind.diff
index 49be042588c..aa44a2ad532 100644
--- a/tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-unwind.diff
+++ b/tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-unwind.diff
@@ -51,3 +51,9 @@
       }
   }
   
+  ALLOC0 (size: 40, align: 1) {
+      0x00 │ 69 6e 74 65 72 6e 61 6c 20 65 72 72 6f 72 3a 20 │ internal error: 
+      0x10 │ 65 6e 74 65 72 65 64 20 75 6e 72 65 61 63 68 61 │ entered unreacha
+      0x20 │ 62 6c 65 20 63 6f 64 65                         │ ble code
+  }
+  
diff --git a/tests/mir-opt/no_drop_for_inactive_variant.unwrap.SimplifyCfg-pre-optimizations.after.panic-abort.mir b/tests/mir-opt/no_drop_for_inactive_variant.unwrap.SimplifyCfg-pre-optimizations.after.panic-abort.mir
index fa6c6ce8e57..6e5f6dc9ea8 100644
--- a/tests/mir-opt/no_drop_for_inactive_variant.unwrap.SimplifyCfg-pre-optimizations.after.panic-abort.mir
+++ b/tests/mir-opt/no_drop_for_inactive_variant.unwrap.SimplifyCfg-pre-optimizations.after.panic-abort.mir
@@ -36,3 +36,7 @@ fn unwrap(_1: Option<T>) -> T {
         return;
     }
 }
+
+ALLOC0 (size: 14, align: 1) {
+    65 78 70 6c 69 63 69 74 20 70 61 6e 69 63       │ explicit panic
+}
diff --git a/tests/mir-opt/no_drop_for_inactive_variant.unwrap.SimplifyCfg-pre-optimizations.after.panic-unwind.mir b/tests/mir-opt/no_drop_for_inactive_variant.unwrap.SimplifyCfg-pre-optimizations.after.panic-unwind.mir
index 54fec3c0f98..758aa45f2a2 100644
--- a/tests/mir-opt/no_drop_for_inactive_variant.unwrap.SimplifyCfg-pre-optimizations.after.panic-unwind.mir
+++ b/tests/mir-opt/no_drop_for_inactive_variant.unwrap.SimplifyCfg-pre-optimizations.after.panic-unwind.mir
@@ -41,3 +41,7 @@ fn unwrap(_1: Option<T>) -> T {
         resume;
     }
 }
+
+ALLOC0 (size: 14, align: 1) {
+    65 78 70 6c 69 63 69 74 20 70 61 6e 69 63       │ explicit panic
+}
diff --git a/tests/mir-opt/no_spurious_drop_after_call.main.ElaborateDrops.before.panic-abort.mir b/tests/mir-opt/no_spurious_drop_after_call.main.ElaborateDrops.before.panic-abort.mir
index 99a7a6b6154..404de884ab5 100644
--- a/tests/mir-opt/no_spurious_drop_after_call.main.ElaborateDrops.before.panic-abort.mir
+++ b/tests/mir-opt/no_spurious_drop_after_call.main.ElaborateDrops.before.panic-abort.mir
@@ -38,3 +38,5 @@ fn main() -> () {
         resume;
     }
 }
+
+ALLOC0 (size: 0, align: 1) {}
diff --git a/tests/mir-opt/no_spurious_drop_after_call.main.ElaborateDrops.before.panic-unwind.mir b/tests/mir-opt/no_spurious_drop_after_call.main.ElaborateDrops.before.panic-unwind.mir
index 7364b329e12..47a0878ffae 100644
--- a/tests/mir-opt/no_spurious_drop_after_call.main.ElaborateDrops.before.panic-unwind.mir
+++ b/tests/mir-opt/no_spurious_drop_after_call.main.ElaborateDrops.before.panic-unwind.mir
@@ -38,3 +38,5 @@ fn main() -> () {
         resume;
     }
 }
+
+ALLOC0 (size: 0, align: 1) {}
diff --git a/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.32bit.panic-abort.diff b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.32bit.panic-abort.diff
index 027c71dfaae..c2d144c98c3 100644
--- a/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.32bit.panic-abort.diff
+++ b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.32bit.panic-abort.diff
@@ -110,9 +110,16 @@
 +         nop;
           return;
       }
-+ }
-+ 
+  }
+  
+- ALLOC0 (size: 43, align: 1) {
 + ALLOC0 (size: 8, align: 4) {
 +     00 00 00 00 __ __ __ __                         │ ....░░░░
++ }
++ 
++ ALLOC1 (size: 43, align: 1) {
+      0x00 │ 63 61 6c 6c 65 64 20 60 52 65 73 75 6c 74 3a 3a │ called `Result::
+      0x10 │ 75 6e 77 72 61 70 28 29 60 20 6f 6e 20 61 6e 20 │ unwrap()` on an 
+      0x20 │ 60 45 72 72 60 20 76 61 6c 75 65                │ `Err` value
   }
   
diff --git a/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-abort.diff b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-abort.diff
index ebf305a6f1b..8641d2d6fa8 100644
--- a/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-abort.diff
+++ b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-abort.diff
@@ -110,9 +110,16 @@
 +         nop;
           return;
       }
-+ }
-+ 
+  }
+  
+- ALLOC0 (size: 43, align: 1) {
 + ALLOC0 (size: 16, align: 8) {
 +     00 00 00 00 00 00 00 00 __ __ __ __ __ __ __ __ │ ........░░░░░░░░
++ }
++ 
++ ALLOC1 (size: 43, align: 1) {
+      0x00 │ 63 61 6c 6c 65 64 20 60 52 65 73 75 6c 74 3a 3a │ called `Result::
+      0x10 │ 75 6e 77 72 61 70 28 29 60 20 6f 6e 20 61 6e 20 │ unwrap()` on an 
+      0x20 │ 60 45 72 72 60 20 76 61 6c 75 65                │ `Err` value
   }
   
diff --git a/tests/mir-opt/single_use_consts.match_const.SingleUseConsts.panic-abort.diff b/tests/mir-opt/single_use_consts.match_const.SingleUseConsts.panic-abort.diff
index 354e0988a00..1ba5e47b81b 100644
--- a/tests/mir-opt/single_use_consts.match_const.SingleUseConsts.panic-abort.diff
+++ b/tests/mir-opt/single_use_consts.match_const.SingleUseConsts.panic-abort.diff
@@ -34,3 +34,15 @@
       }
   }
   
+  ALLOC0 (size: 5, align: 1) {
+      77 6f 72 6c 64                                  │ world
+  }
+  
+  ALLOC1 (size: 5, align: 1) {
+      74 6f 77 65 6c                                  │ towel
+  }
+  
+  ALLOC2 (size: 5, align: 1) {
+      68 65 6c 6c 6f                                  │ hello
+  }
+  
diff --git a/tests/mir-opt/single_use_consts.match_const.SingleUseConsts.panic-unwind.diff b/tests/mir-opt/single_use_consts.match_const.SingleUseConsts.panic-unwind.diff
index 354e0988a00..1ba5e47b81b 100644
--- a/tests/mir-opt/single_use_consts.match_const.SingleUseConsts.panic-unwind.diff
+++ b/tests/mir-opt/single_use_consts.match_const.SingleUseConsts.panic-unwind.diff
@@ -34,3 +34,15 @@
       }
   }
   
+  ALLOC0 (size: 5, align: 1) {
+      77 6f 72 6c 64                                  │ world
+  }
+  
+  ALLOC1 (size: 5, align: 1) {
+      74 6f 77 65 6c                                  │ towel
+  }
+  
+  ALLOC2 (size: 5, align: 1) {
+      68 65 6c 6c 6f                                  │ hello
+  }
+  
diff --git a/tests/mir-opt/single_use_consts.match_const_debug.SingleUseConsts.panic-abort.diff b/tests/mir-opt/single_use_consts.match_const_debug.SingleUseConsts.panic-abort.diff
index 5cf37dc97cb..e0fabe5a90e 100644
--- a/tests/mir-opt/single_use_consts.match_const_debug.SingleUseConsts.panic-abort.diff
+++ b/tests/mir-opt/single_use_consts.match_const_debug.SingleUseConsts.panic-abort.diff
@@ -45,3 +45,15 @@
       }
   }
   
+  ALLOC0 (size: 5, align: 1) {
+      77 6f 72 6c 64                                  │ world
+  }
+  
+  ALLOC1 (size: 5, align: 1) {
+      74 6f 77 65 6c                                  │ towel
+  }
+  
+  ALLOC2 (size: 5, align: 1) {
+      68 65 6c 6c 6f                                  │ hello
+  }
+  
diff --git a/tests/mir-opt/single_use_consts.match_const_debug.SingleUseConsts.panic-unwind.diff b/tests/mir-opt/single_use_consts.match_const_debug.SingleUseConsts.panic-unwind.diff
index bdcf086e8d9..26799ae6629 100644
--- a/tests/mir-opt/single_use_consts.match_const_debug.SingleUseConsts.panic-unwind.diff
+++ b/tests/mir-opt/single_use_consts.match_const_debug.SingleUseConsts.panic-unwind.diff
@@ -45,3 +45,15 @@
       }
   }
   
+  ALLOC0 (size: 5, align: 1) {
+      77 6f 72 6c 64                                  │ world
+  }
+  
+  ALLOC1 (size: 5, align: 1) {
+      74 6f 77 65 6c                                  │ towel
+  }
+  
+  ALLOC2 (size: 5, align: 1) {
+      68 65 6c 6c 6f                                  │ hello
+  }
+  
diff --git a/tests/mir-opt/sroa/structs.flat.ScalarReplacementOfAggregates.diff b/tests/mir-opt/sroa/structs.flat.ScalarReplacementOfAggregates.diff
index 77c7c1a9012..ecd89d14ace 100644
--- a/tests/mir-opt/sroa/structs.flat.ScalarReplacementOfAggregates.diff
+++ b/tests/mir-opt/sroa/structs.flat.ScalarReplacementOfAggregates.diff
@@ -75,3 +75,7 @@
       }
   }
   
+  ALLOC0 (size: 1, align: 1) {
+      61                                              │ a
+  }
+  
diff --git a/tests/mir-opt/unreachable_enum_branching.byref.UnreachableEnumBranching.panic-abort.diff b/tests/mir-opt/unreachable_enum_branching.byref.UnreachableEnumBranching.panic-abort.diff
index ed54a38f70b..610a1a4624f 100644
--- a/tests/mir-opt/unreachable_enum_branching.byref.UnreachableEnumBranching.panic-abort.diff
+++ b/tests/mir-opt/unreachable_enum_branching.byref.UnreachableEnumBranching.panic-abort.diff
@@ -113,3 +113,19 @@
       }
   }
   
+  ALLOC0 (size: 1, align: 1) {
+      44                                              │ D
+  }
+  
+  ALLOC1 (size: 1, align: 1) {
+      43                                              │ C
+  }
+  
+  ALLOC2 (size: 8, align: 1) {
+      42 28 45 6d 70 74 79 29                         │ B(Empty)
+  }
+  
+  ALLOC3 (size: 8, align: 1) {
+      41 28 45 6d 70 74 79 29                         │ A(Empty)
+  }
+  
diff --git a/tests/mir-opt/unreachable_enum_branching.byref.UnreachableEnumBranching.panic-unwind.diff b/tests/mir-opt/unreachable_enum_branching.byref.UnreachableEnumBranching.panic-unwind.diff
index ed54a38f70b..610a1a4624f 100644
--- a/tests/mir-opt/unreachable_enum_branching.byref.UnreachableEnumBranching.panic-unwind.diff
+++ b/tests/mir-opt/unreachable_enum_branching.byref.UnreachableEnumBranching.panic-unwind.diff
@@ -113,3 +113,19 @@
       }
   }
   
+  ALLOC0 (size: 1, align: 1) {
+      44                                              │ D
+  }
+  
+  ALLOC1 (size: 1, align: 1) {
+      43                                              │ C
+  }
+  
+  ALLOC2 (size: 8, align: 1) {
+      42 28 45 6d 70 74 79 29                         │ B(Empty)
+  }
+  
+  ALLOC3 (size: 8, align: 1) {
+      41 28 45 6d 70 74 79 29                         │ A(Empty)
+  }
+  
diff --git a/tests/mir-opt/unreachable_enum_branching.custom_discriminant.UnreachableEnumBranching.panic-abort.diff b/tests/mir-opt/unreachable_enum_branching.custom_discriminant.UnreachableEnumBranching.panic-abort.diff
index ea6cdbfbe66..97c71762f22 100644
--- a/tests/mir-opt/unreachable_enum_branching.custom_discriminant.UnreachableEnumBranching.panic-abort.diff
+++ b/tests/mir-opt/unreachable_enum_branching.custom_discriminant.UnreachableEnumBranching.panic-abort.diff
@@ -41,3 +41,11 @@
       }
   }
   
+  ALLOC0 (size: 1, align: 1) {
+      45                                              │ E
+  }
+  
+  ALLOC1 (size: 1, align: 1) {
+      44                                              │ D
+  }
+  
diff --git a/tests/mir-opt/unreachable_enum_branching.custom_discriminant.UnreachableEnumBranching.panic-unwind.diff b/tests/mir-opt/unreachable_enum_branching.custom_discriminant.UnreachableEnumBranching.panic-unwind.diff
index ea6cdbfbe66..97c71762f22 100644
--- a/tests/mir-opt/unreachable_enum_branching.custom_discriminant.UnreachableEnumBranching.panic-unwind.diff
+++ b/tests/mir-opt/unreachable_enum_branching.custom_discriminant.UnreachableEnumBranching.panic-unwind.diff
@@ -41,3 +41,11 @@
       }
   }
   
+  ALLOC0 (size: 1, align: 1) {
+      45                                              │ E
+  }
+  
+  ALLOC1 (size: 1, align: 1) {
+      44                                              │ D
+  }
+  
diff --git a/tests/mir-opt/unreachable_enum_branching.otherwise_t1.UnreachableEnumBranching.panic-abort.diff b/tests/mir-opt/unreachable_enum_branching.otherwise_t1.UnreachableEnumBranching.panic-abort.diff
index be934ac688b..7e798abcd4e 100644
--- a/tests/mir-opt/unreachable_enum_branching.otherwise_t1.UnreachableEnumBranching.panic-abort.diff
+++ b/tests/mir-opt/unreachable_enum_branching.otherwise_t1.UnreachableEnumBranching.panic-abort.diff
@@ -51,3 +51,15 @@
       }
   }
   
+  ALLOC0 (size: 1, align: 1) {
+      43                                              │ C
+  }
+  
+  ALLOC1 (size: 8, align: 1) {
+      42 28 45 6d 70 74 79 29                         │ B(Empty)
+  }
+  
+  ALLOC2 (size: 8, align: 1) {
+      41 28 45 6d 70 74 79 29                         │ A(Empty)
+  }
+  
diff --git a/tests/mir-opt/unreachable_enum_branching.otherwise_t1.UnreachableEnumBranching.panic-unwind.diff b/tests/mir-opt/unreachable_enum_branching.otherwise_t1.UnreachableEnumBranching.panic-unwind.diff
index be934ac688b..7e798abcd4e 100644
--- a/tests/mir-opt/unreachable_enum_branching.otherwise_t1.UnreachableEnumBranching.panic-unwind.diff
+++ b/tests/mir-opt/unreachable_enum_branching.otherwise_t1.UnreachableEnumBranching.panic-unwind.diff
@@ -51,3 +51,15 @@
       }
   }
   
+  ALLOC0 (size: 1, align: 1) {
+      43                                              │ C
+  }
+  
+  ALLOC1 (size: 8, align: 1) {
+      42 28 45 6d 70 74 79 29                         │ B(Empty)
+  }
+  
+  ALLOC2 (size: 8, align: 1) {
+      41 28 45 6d 70 74 79 29                         │ A(Empty)
+  }
+  
diff --git a/tests/mir-opt/unreachable_enum_branching.otherwise_t2.UnreachableEnumBranching.panic-abort.diff b/tests/mir-opt/unreachable_enum_branching.otherwise_t2.UnreachableEnumBranching.panic-abort.diff
index a6d6e0861b1..ac9b047624b 100644
--- a/tests/mir-opt/unreachable_enum_branching.otherwise_t2.UnreachableEnumBranching.panic-abort.diff
+++ b/tests/mir-opt/unreachable_enum_branching.otherwise_t2.UnreachableEnumBranching.panic-abort.diff
@@ -42,3 +42,11 @@
       }
   }
   
+  ALLOC0 (size: 1, align: 1) {
+      45                                              │ E
+  }
+  
+  ALLOC1 (size: 1, align: 1) {
+      44                                              │ D
+  }
+  
diff --git a/tests/mir-opt/unreachable_enum_branching.otherwise_t2.UnreachableEnumBranching.panic-unwind.diff b/tests/mir-opt/unreachable_enum_branching.otherwise_t2.UnreachableEnumBranching.panic-unwind.diff
index a6d6e0861b1..ac9b047624b 100644
--- a/tests/mir-opt/unreachable_enum_branching.otherwise_t2.UnreachableEnumBranching.panic-unwind.diff
+++ b/tests/mir-opt/unreachable_enum_branching.otherwise_t2.UnreachableEnumBranching.panic-unwind.diff
@@ -42,3 +42,11 @@
       }
   }
   
+  ALLOC0 (size: 1, align: 1) {
+      45                                              │ E
+  }
+  
+  ALLOC1 (size: 1, align: 1) {
+      44                                              │ D
+  }
+  
diff --git a/tests/mir-opt/unreachable_enum_branching.otherwise_t3.UnreachableEnumBranching.panic-abort.diff b/tests/mir-opt/unreachable_enum_branching.otherwise_t3.UnreachableEnumBranching.panic-abort.diff
index 120061841a0..9e85e56c583 100644
--- a/tests/mir-opt/unreachable_enum_branching.otherwise_t3.UnreachableEnumBranching.panic-abort.diff
+++ b/tests/mir-opt/unreachable_enum_branching.otherwise_t3.UnreachableEnumBranching.panic-abort.diff
@@ -51,3 +51,15 @@
       }
   }
   
+  ALLOC0 (size: 1, align: 1) {
+      43                                              │ C
+  }
+  
+  ALLOC1 (size: 8, align: 1) {
+      42 28 45 6d 70 74 79 29                         │ B(Empty)
+  }
+  
+  ALLOC2 (size: 8, align: 1) {
+      41 28 45 6d 70 74 79 29                         │ A(Empty)
+  }
+  
diff --git a/tests/mir-opt/unreachable_enum_branching.otherwise_t3.UnreachableEnumBranching.panic-unwind.diff b/tests/mir-opt/unreachable_enum_branching.otherwise_t3.UnreachableEnumBranching.panic-unwind.diff
index 120061841a0..9e85e56c583 100644
--- a/tests/mir-opt/unreachable_enum_branching.otherwise_t3.UnreachableEnumBranching.panic-unwind.diff
+++ b/tests/mir-opt/unreachable_enum_branching.otherwise_t3.UnreachableEnumBranching.panic-unwind.diff
@@ -51,3 +51,15 @@
       }
   }
   
+  ALLOC0 (size: 1, align: 1) {
+      43                                              │ C
+  }
+  
+  ALLOC1 (size: 8, align: 1) {
+      42 28 45 6d 70 74 79 29                         │ B(Empty)
+  }
+  
+  ALLOC2 (size: 8, align: 1) {
+      41 28 45 6d 70 74 79 29                         │ A(Empty)
+  }
+  
diff --git a/tests/mir-opt/unreachable_enum_branching.otherwise_t4.UnreachableEnumBranching.panic-abort.diff b/tests/mir-opt/unreachable_enum_branching.otherwise_t4.UnreachableEnumBranching.panic-abort.diff
index b86814d6119..e83c6131fa5 100644
--- a/tests/mir-opt/unreachable_enum_branching.otherwise_t4.UnreachableEnumBranching.panic-abort.diff
+++ b/tests/mir-opt/unreachable_enum_branching.otherwise_t4.UnreachableEnumBranching.panic-abort.diff
@@ -46,3 +46,15 @@
       }
   }
   
+  ALLOC0 (size: 2, align: 1) {
+      43 44                                           │ CD
+  }
+  
+  ALLOC1 (size: 6, align: 1) {
+      42 28 69 33 32 29                               │ B(i32)
+  }
+  
+  ALLOC2 (size: 6, align: 1) {
+      41 28 69 33 32 29                               │ A(i32)
+  }
+  
diff --git a/tests/mir-opt/unreachable_enum_branching.otherwise_t4.UnreachableEnumBranching.panic-unwind.diff b/tests/mir-opt/unreachable_enum_branching.otherwise_t4.UnreachableEnumBranching.panic-unwind.diff
index b86814d6119..e83c6131fa5 100644
--- a/tests/mir-opt/unreachable_enum_branching.otherwise_t4.UnreachableEnumBranching.panic-unwind.diff
+++ b/tests/mir-opt/unreachable_enum_branching.otherwise_t4.UnreachableEnumBranching.panic-unwind.diff
@@ -46,3 +46,15 @@
       }
   }
   
+  ALLOC0 (size: 2, align: 1) {
+      43 44                                           │ CD
+  }
+  
+  ALLOC1 (size: 6, align: 1) {
+      42 28 69 33 32 29                               │ B(i32)
+  }
+  
+  ALLOC2 (size: 6, align: 1) {
+      41 28 69 33 32 29                               │ A(i32)
+  }
+  
diff --git a/tests/mir-opt/unreachable_enum_branching.otherwise_t4_unreachable_default.UnreachableEnumBranching.panic-abort.diff b/tests/mir-opt/unreachable_enum_branching.otherwise_t4_unreachable_default.UnreachableEnumBranching.panic-abort.diff
index 424ac6ba651..33e33ebddec 100644
--- a/tests/mir-opt/unreachable_enum_branching.otherwise_t4_unreachable_default.UnreachableEnumBranching.panic-abort.diff
+++ b/tests/mir-opt/unreachable_enum_branching.otherwise_t4_unreachable_default.UnreachableEnumBranching.panic-abort.diff
@@ -60,3 +60,19 @@
       }
   }
   
+  ALLOC0 (size: 6, align: 1) {
+      42 28 69 33 32 29                               │ B(i32)
+  }
+  
+  ALLOC1 (size: 6, align: 1) {
+      41 28 69 33 32 29                               │ A(i32)
+  }
+  
+  ALLOC2 (size: 1, align: 1) {
+      44                                              │ D
+  }
+  
+  ALLOC3 (size: 1, align: 1) {
+      43                                              │ C
+  }
+  
diff --git a/tests/mir-opt/unreachable_enum_branching.otherwise_t4_unreachable_default.UnreachableEnumBranching.panic-unwind.diff b/tests/mir-opt/unreachable_enum_branching.otherwise_t4_unreachable_default.UnreachableEnumBranching.panic-unwind.diff
index 424ac6ba651..33e33ebddec 100644
--- a/tests/mir-opt/unreachable_enum_branching.otherwise_t4_unreachable_default.UnreachableEnumBranching.panic-unwind.diff
+++ b/tests/mir-opt/unreachable_enum_branching.otherwise_t4_unreachable_default.UnreachableEnumBranching.panic-unwind.diff
@@ -60,3 +60,19 @@
       }
   }
   
+  ALLOC0 (size: 6, align: 1) {
+      42 28 69 33 32 29                               │ B(i32)
+  }
+  
+  ALLOC1 (size: 6, align: 1) {
+      41 28 69 33 32 29                               │ A(i32)
+  }
+  
+  ALLOC2 (size: 1, align: 1) {
+      44                                              │ D
+  }
+  
+  ALLOC3 (size: 1, align: 1) {
+      43                                              │ C
+  }
+  
diff --git a/tests/mir-opt/unreachable_enum_branching.otherwise_t4_unreachable_default_2.UnreachableEnumBranching.panic-abort.diff b/tests/mir-opt/unreachable_enum_branching.otherwise_t4_unreachable_default_2.UnreachableEnumBranching.panic-abort.diff
index 17e01f38f4e..d11c07c4ba3 100644
--- a/tests/mir-opt/unreachable_enum_branching.otherwise_t4_unreachable_default_2.UnreachableEnumBranching.panic-abort.diff
+++ b/tests/mir-opt/unreachable_enum_branching.otherwise_t4_unreachable_default_2.UnreachableEnumBranching.panic-abort.diff
@@ -73,3 +73,23 @@
       }
   }
   
+  ALLOC0 (size: 9, align: 1) {
+      41 28 6f 74 68 65 72 29 44                      │ A(other)D
+  }
+  
+  ALLOC1 (size: 4, align: 1) {
+      41 28 32 29                                     │ A(2)
+  }
+  
+  ALLOC2 (size: 4, align: 1) {
+      41 28 31 29                                     │ A(1)
+  }
+  
+  ALLOC3 (size: 6, align: 1) {
+      42 28 69 33 32 29                               │ B(i32)
+  }
+  
+  ALLOC4 (size: 1, align: 1) {
+      43                                              │ C
+  }
+  
diff --git a/tests/mir-opt/unreachable_enum_branching.otherwise_t4_unreachable_default_2.UnreachableEnumBranching.panic-unwind.diff b/tests/mir-opt/unreachable_enum_branching.otherwise_t4_unreachable_default_2.UnreachableEnumBranching.panic-unwind.diff
index 17e01f38f4e..d11c07c4ba3 100644
--- a/tests/mir-opt/unreachable_enum_branching.otherwise_t4_unreachable_default_2.UnreachableEnumBranching.panic-unwind.diff
+++ b/tests/mir-opt/unreachable_enum_branching.otherwise_t4_unreachable_default_2.UnreachableEnumBranching.panic-unwind.diff
@@ -73,3 +73,23 @@
       }
   }
   
+  ALLOC0 (size: 9, align: 1) {
+      41 28 6f 74 68 65 72 29 44                      │ A(other)D
+  }
+  
+  ALLOC1 (size: 4, align: 1) {
+      41 28 32 29                                     │ A(2)
+  }
+  
+  ALLOC2 (size: 4, align: 1) {
+      41 28 31 29                                     │ A(1)
+  }
+  
+  ALLOC3 (size: 6, align: 1) {
+      42 28 69 33 32 29                               │ B(i32)
+  }
+  
+  ALLOC4 (size: 1, align: 1) {
+      43                                              │ C
+  }
+  
diff --git a/tests/mir-opt/unreachable_enum_branching.otherwise_t5_unreachable_default.UnreachableEnumBranching.panic-abort.diff b/tests/mir-opt/unreachable_enum_branching.otherwise_t5_unreachable_default.UnreachableEnumBranching.panic-abort.diff
index 2de1f77eeec..ae1ca6efd43 100644
--- a/tests/mir-opt/unreachable_enum_branching.otherwise_t5_unreachable_default.UnreachableEnumBranching.panic-abort.diff
+++ b/tests/mir-opt/unreachable_enum_branching.otherwise_t5_unreachable_default.UnreachableEnumBranching.panic-abort.diff
@@ -64,3 +64,19 @@
       }
   }
   
+  ALLOC0 (size: 4, align: 1) {
+      42 28 54 29                                     │ B(T)
+  }
+  
+  ALLOC1 (size: 4, align: 1) {
+      41 28 54 29                                     │ A(T)
+  }
+  
+  ALLOC2 (size: 1, align: 1) {
+      44                                              │ D
+  }
+  
+  ALLOC3 (size: 1, align: 1) {
+      43                                              │ C
+  }
+  
diff --git a/tests/mir-opt/unreachable_enum_branching.otherwise_t5_unreachable_default.UnreachableEnumBranching.panic-unwind.diff b/tests/mir-opt/unreachable_enum_branching.otherwise_t5_unreachable_default.UnreachableEnumBranching.panic-unwind.diff
index 5afb78c58a3..1e660036e46 100644
--- a/tests/mir-opt/unreachable_enum_branching.otherwise_t5_unreachable_default.UnreachableEnumBranching.panic-unwind.diff
+++ b/tests/mir-opt/unreachable_enum_branching.otherwise_t5_unreachable_default.UnreachableEnumBranching.panic-unwind.diff
@@ -68,3 +68,19 @@
       }
   }
   
+  ALLOC0 (size: 4, align: 1) {
+      42 28 54 29                                     │ B(T)
+  }
+  
+  ALLOC1 (size: 4, align: 1) {
+      41 28 54 29                                     │ A(T)
+  }
+  
+  ALLOC2 (size: 1, align: 1) {
+      44                                              │ D
+  }
+  
+  ALLOC3 (size: 1, align: 1) {
+      43                                              │ C
+  }
+  
diff --git a/tests/mir-opt/unreachable_enum_branching.simple.UnreachableEnumBranching.panic-abort.diff b/tests/mir-opt/unreachable_enum_branching.simple.UnreachableEnumBranching.panic-abort.diff
index 5c08648fac3..c24bd7e7446 100644
--- a/tests/mir-opt/unreachable_enum_branching.simple.UnreachableEnumBranching.panic-abort.diff
+++ b/tests/mir-opt/unreachable_enum_branching.simple.UnreachableEnumBranching.panic-abort.diff
@@ -51,3 +51,15 @@
       }
   }
   
+  ALLOC0 (size: 1, align: 1) {
+      43                                              │ C
+  }
+  
+  ALLOC1 (size: 8, align: 1) {
+      42 28 45 6d 70 74 79 29                         │ B(Empty)
+  }
+  
+  ALLOC2 (size: 8, align: 1) {
+      41 28 45 6d 70 74 79 29                         │ A(Empty)
+  }
+  
diff --git a/tests/mir-opt/unreachable_enum_branching.simple.UnreachableEnumBranching.panic-unwind.diff b/tests/mir-opt/unreachable_enum_branching.simple.UnreachableEnumBranching.panic-unwind.diff
index 5c08648fac3..c24bd7e7446 100644
--- a/tests/mir-opt/unreachable_enum_branching.simple.UnreachableEnumBranching.panic-unwind.diff
+++ b/tests/mir-opt/unreachable_enum_branching.simple.UnreachableEnumBranching.panic-unwind.diff
@@ -51,3 +51,15 @@
       }
   }
   
+  ALLOC0 (size: 1, align: 1) {
+      43                                              │ C
+  }
+  
+  ALLOC1 (size: 8, align: 1) {
+      42 28 45 6d 70 74 79 29                         │ B(Empty)
+  }
+  
+  ALLOC2 (size: 8, align: 1) {
+      41 28 45 6d 70 74 79 29                         │ A(Empty)
+  }
+