Add a layout_of_val intrinsic to get the Layout directly

scottmcm · scottmcm · commit 74b8cf703aa9 · 2026-02-17T22:08:34.000-08:00
diff --git a/compiler/rustc_hir_analysis/src/check/intrinsic.rs b/compiler/rustc_hir_analysis/src/check/intrinsic.rs
@@ -296,6 +296,9 @@ pub(crate) fn check_intrinsic_type(
         sym::size_of_val | sym::align_of_val => {
             (1, 0, vec![Ty::new_imm_ptr(tcx, param(0))], tcx.types.usize)
         }
+        sym::layout_of_val => {
+            (1, 0, vec![Ty::new_imm_ptr(tcx, param(0))], tcx.ty_alloc_layout(span))
+        }
         sym::offset_of => (1, 0, vec![tcx.types.u32, tcx.types.u32], tcx.types.usize),
         sym::rustc_peek => (1, 0, vec![param(0)], param(0)),
         sym::caller_location => (0, 0, vec![], tcx.caller_location_ty()),
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
@@ -1079,6 +1079,12 @@ impl<'tcx> TyCtxt<'tcx> {
         self.type_of(ordering_enum).no_bound_vars().unwrap()
     }
 
+    /// Gets a `Ty` representing the [`LangItem::Alignment`]
+    pub fn ty_alloc_layout(self, span: Span) -> Ty<'tcx> {
+        let layout_did = self.require_lang_item(hir::LangItem::AllocLayout, span);
+        self.type_of(layout_did).no_bound_vars().unwrap()
+    }
+
     /// Obtain the given diagnostic item's `DefId`. Use `is_diagnostic_item` if you just want to
     /// compare against another `DefId`, since `is_diagnostic_item` is cheaper.
     pub fn get_diagnostic_item(self, name: Symbol) -> Option<DefId> {
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
@@ -1347,6 +1347,7 @@ symbols! {
         large_assignments,
         last,
         lateout,
+        layout_of_val,
         lazy_normalization_consts,
         lazy_type_alias,
         le,
diff --git a/library/core/src/alloc/layout.rs b/library/core/src/alloc/layout.rs
@@ -5,7 +5,7 @@
 // Your performance intuition is useless. Run perf.
 
 use crate::error::Error;
-use crate::intrinsics::{unchecked_add, unchecked_mul, unchecked_sub};
+use crate::intrinsics::{self, unchecked_add, unchecked_mul, unchecked_sub};
 use crate::mem::SizedTypeProperties;
 use crate::ptr::{Alignment, NonNull};
 use crate::{assert_unsafe_precondition, fmt, mem};
@@ -250,11 +250,9 @@ impl Layout {
     #[unstable(feature = "layout_for_ptr", issue = "69835")]
     #[must_use]
     #[inline]
-    pub const unsafe fn for_value_raw<T: ?Sized>(t: *const T) -> Self {
+    pub const unsafe fn for_value_raw<T: ?Sized>(ptr: *const T) -> Self {
         // SAFETY: we pass along the prerequisites of these functions to the caller
-        let (size, alignment) = unsafe { (mem::size_of_val_raw(t), Alignment::of_val_raw(t)) };
-        // SAFETY: see rationale in `new` for why this is using the unsafe variant
-        unsafe { Layout::from_size_alignment_unchecked(size, alignment) }
+        unsafe { intrinsics::layout_of_val(ptr) }
     }
 
     /// Creates a `NonNull` that is dangling, but well-aligned for this Layout.
diff --git a/library/core/src/intrinsics/mod.rs b/library/core/src/intrinsics/mod.rs
@@ -53,6 +53,7 @@
     issue = "none"
 )]
 
+use crate::alloc::Layout;
 use crate::ffi::va_list::{VaArgSafe, VaList};
 use crate::marker::{ConstParamTy, DiscriminantKind, PointeeSized, Tuple};
 use crate::{mem, ptr};
@@ -2864,6 +2865,26 @@ pub const unsafe fn size_of_val<T: ?Sized>(ptr: *const T) -> usize;
 #[rustc_intrinsic_const_stable_indirect]
 pub const unsafe fn align_of_val<T: ?Sized>(ptr: *const T) -> usize;
 
+/// The size and alignment of the referenced value in bytes.
+///
+/// The stabilized version of this intrinsic is [`Layout::for_value_raw`].
+///
+/// # Safety
+///
+/// See [`Layout::for_value_raw`] for safety conditions.
+#[rustc_nounwind]
+#[unstable(feature = "core_intrinsics", issue = "none")]
+#[rustc_intrinsic]
+// This adds no semantics or UB atop just calling `size_of_val`+`align_of_val`.
+#[miri::intrinsic_fallback_is_spec]
+pub const unsafe fn layout_of_val<T: ?Sized>(ptr: *const T) -> Layout {
+    // SAFETY: we pass along the prerequisites of these functions to the caller
+    let (size, align) = unsafe { (size_of_val(ptr), align_of_val(ptr)) };
+    // SAFETY: The size and alignment of a valid allocation (or type)
+    // always meet the requirements of `Layout`.
+    unsafe { Layout::from_size_align_unchecked(size, align) }
+}
+
 /// Compute the type information of a concrete type.
 /// It can only be called at compile time, the backends do
 /// not implement it.
diff --git a/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.32bit.panic-abort.mir b/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.32bit.panic-abort.mir
@@ -8,33 +8,36 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
             let _2: std::ptr::NonNull<[T]>;
             let mut _3: *mut [T];
             let mut _4: *const [T];
+            let mut _6: usize;
             let _9: ();
             scope 3 {
+                let _5: std::alloc::Layout;
                 scope 4 {
-                    scope 17 (inlined Layout::size) {
+                    scope 8 (inlined Layout::size) {
                     }
-                    scope 18 (inlined std::ptr::Unique::<[T]>::cast::<u8>) {
-                        scope 19 (inlined NonNull::<[T]>::cast::<u8>) {
-                            scope 20 (inlined NonNull::<[T]>::as_ptr) {
+                    scope 9 (inlined std::ptr::Unique::<[T]>::cast::<u8>) {
+                        scope 10 (inlined NonNull::<[T]>::cast::<u8>) {
+                            scope 11 (inlined NonNull::<[T]>::as_ptr) {
                             }
                         }
                     }
-                    scope 21 (inlined <NonNull<u8> as From<std::ptr::Unique<u8>>>::from) {
-                        scope 22 (inlined std::ptr::Unique::<u8>::as_non_null_ptr) {
+                    scope 12 (inlined <NonNull<u8> as From<std::ptr::Unique<u8>>>::from) {
+                        scope 13 (inlined std::ptr::Unique::<u8>::as_non_null_ptr) {
                         }
                     }
-                    scope 23 (inlined <std::alloc::Global as Allocator>::deallocate) {
-                        scope 24 (inlined std::alloc::Global::deallocate_impl) {
-                            scope 25 (inlined std::alloc::Global::deallocate_impl_runtime) {
-                                let mut _8: *mut u8;
-                                scope 26 (inlined Layout::size) {
+                    scope 14 (inlined <std::alloc::Global as Allocator>::deallocate) {
+                        scope 15 (inlined std::alloc::Global::deallocate_impl) {
+                            scope 16 (inlined std::alloc::Global::deallocate_impl_runtime) {
+                                let mut _7: *mut u8;
+                                scope 17 (inlined Layout::size) {
                                 }
-                                scope 27 (inlined NonNull::<u8>::as_ptr) {
+                                scope 18 (inlined NonNull::<u8>::as_ptr) {
                                 }
-                                scope 28 (inlined std::alloc::dealloc) {
-                                    scope 29 (inlined Layout::size) {
+                                scope 19 (inlined std::alloc::dealloc) {
+                                    let mut _8: std::ptr::Alignment;
+                                    scope 20 (inlined Layout::size) {
                                     }
-                                    scope 30 (inlined Layout::alignment) {
+                                    scope 21 (inlined Layout::alignment) {
                                     }
                                 }
                             }
@@ -46,63 +49,44 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
                     }
                 }
                 scope 7 (inlined Layout::for_value_raw::<[T]>) {
-                    let mut _5: usize;
-                    let mut _7: std::ptr::Alignment;
-                    scope 8 {
-                        scope 16 (inlined #[track_caller] Layout::from_size_alignment_unchecked) {
-                        }
-                    }
-                    scope 9 (inlined size_of_val_raw::<[T]>) {
-                    }
-                    scope 10 (inlined std::ptr::Alignment::of_val_raw::<[T]>) {
-                        let _6: usize;
-                        scope 11 {
-                            scope 13 (inlined #[track_caller] std::ptr::Alignment::new_unchecked) {
-                                scope 14 (inlined core::ub_checks::check_language_ub) {
-                                    scope 15 (inlined core::ub_checks::check_language_ub::runtime) {
-                                    }
-                                }
-                            }
-                        }
-                        scope 12 (inlined align_of_val_raw::<[T]>) {
-                        }
-                    }
                 }
             }
         }
     }
 
     bb0: {
+        StorageLive(_5);
         StorageLive(_2);
         _2 = copy (((*_1).0: std::ptr::Unique<[T]>).0: std::ptr::NonNull<[T]>);
         StorageLive(_4);
         _3 = copy _2 as *mut [T] (Transmute);
         _4 = copy _2 as *const [T] (Transmute);
-        _5 = std::intrinsics::size_of_val::<[T]>(move _4) -> [return: bb1, unwind unreachable];
+        _5 = layout_of_val::<[T]>(move _4) -> [return: bb1, unwind unreachable];
     }
 
     bb1: {
-        StorageLive(_6);
-        _6 = const <T as std::mem::SizedTypeProperties>::ALIGN;
-        _7 = copy _6 as std::ptr::Alignment (Transmute);
-        StorageDead(_6);
         StorageDead(_4);
-        switchInt(copy _5) -> [0: bb4, otherwise: bb2];
+        _6 = copy (_5.0: usize);
+        switchInt(copy _6) -> [0: bb4, otherwise: bb2];
     }
 
     bb2: {
+        StorageLive(_7);
+        _7 = copy _3 as *mut u8 (PtrToPtr);
         StorageLive(_8);
-        _8 = copy _3 as *mut u8 (PtrToPtr);
-        _9 = alloc::alloc::__rust_dealloc(move _8, move _5, move _7) -> [return: bb3, unwind unreachable];
+        _8 = copy (_5.1: std::ptr::Alignment);
+        _9 = alloc::alloc::__rust_dealloc(move _7, move _6, move _8) -> [return: bb3, unwind unreachable];
     }
 
     bb3: {
         StorageDead(_8);
+        StorageDead(_7);
         goto -> bb4;
     }
 
     bb4: {
         StorageDead(_2);
+        StorageDead(_5);
         return;
     }
 }
diff --git a/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.32bit.panic-unwind.mir b/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.32bit.panic-unwind.mir
@@ -8,33 +8,36 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
             let _2: std::ptr::NonNull<[T]>;
             let mut _3: *mut [T];
             let mut _4: *const [T];
+            let mut _6: usize;
             let _9: ();
             scope 3 {
+                let _5: std::alloc::Layout;
                 scope 4 {
-                    scope 17 (inlined Layout::size) {
+                    scope 8 (inlined Layout::size) {
                     }
-                    scope 18 (inlined std::ptr::Unique::<[T]>::cast::<u8>) {
-                        scope 19 (inlined NonNull::<[T]>::cast::<u8>) {
-                            scope 20 (inlined NonNull::<[T]>::as_ptr) {
+                    scope 9 (inlined std::ptr::Unique::<[T]>::cast::<u8>) {
+                        scope 10 (inlined NonNull::<[T]>::cast::<u8>) {
+                            scope 11 (inlined NonNull::<[T]>::as_ptr) {
                             }
                         }
                     }
-                    scope 21 (inlined <NonNull<u8> as From<std::ptr::Unique<u8>>>::from) {
-                        scope 22 (inlined std::ptr::Unique::<u8>::as_non_null_ptr) {
+                    scope 12 (inlined <NonNull<u8> as From<std::ptr::Unique<u8>>>::from) {
+                        scope 13 (inlined std::ptr::Unique::<u8>::as_non_null_ptr) {
                         }
                     }
-                    scope 23 (inlined <std::alloc::Global as Allocator>::deallocate) {
-                        scope 24 (inlined std::alloc::Global::deallocate_impl) {
-                            scope 25 (inlined std::alloc::Global::deallocate_impl_runtime) {
-                                let mut _8: *mut u8;
-                                scope 26 (inlined Layout::size) {
+                    scope 14 (inlined <std::alloc::Global as Allocator>::deallocate) {
+                        scope 15 (inlined std::alloc::Global::deallocate_impl) {
+                            scope 16 (inlined std::alloc::Global::deallocate_impl_runtime) {
+                                let mut _7: *mut u8;
+                                scope 17 (inlined Layout::size) {
                                 }
-                                scope 27 (inlined NonNull::<u8>::as_ptr) {
+                                scope 18 (inlined NonNull::<u8>::as_ptr) {
                                 }
-                                scope 28 (inlined std::alloc::dealloc) {
-                                    scope 29 (inlined Layout::size) {
+                                scope 19 (inlined std::alloc::dealloc) {
+                                    let mut _8: std::ptr::Alignment;
+                                    scope 20 (inlined Layout::size) {
                                     }
-                                    scope 30 (inlined Layout::alignment) {
+                                    scope 21 (inlined Layout::alignment) {
                                     }
                                 }
                             }
@@ -46,63 +49,44 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
                     }
                 }
                 scope 7 (inlined Layout::for_value_raw::<[T]>) {
-                    let mut _5: usize;
-                    let mut _7: std::ptr::Alignment;
-                    scope 8 {
-                        scope 16 (inlined #[track_caller] Layout::from_size_alignment_unchecked) {
-                        }
-                    }
-                    scope 9 (inlined size_of_val_raw::<[T]>) {
-                    }
-                    scope 10 (inlined std::ptr::Alignment::of_val_raw::<[T]>) {
-                        let _6: usize;
-                        scope 11 {
-                            scope 13 (inlined #[track_caller] std::ptr::Alignment::new_unchecked) {
-                                scope 14 (inlined core::ub_checks::check_language_ub) {
-                                    scope 15 (inlined core::ub_checks::check_language_ub::runtime) {
-                                    }
-                                }
-                            }
-                        }
-                        scope 12 (inlined align_of_val_raw::<[T]>) {
-                        }
-                    }
                 }
             }
         }
     }
 
     bb0: {
+        StorageLive(_5);
         StorageLive(_2);
         _2 = copy (((*_1).0: std::ptr::Unique<[T]>).0: std::ptr::NonNull<[T]>);
         StorageLive(_4);
         _3 = copy _2 as *mut [T] (Transmute);
         _4 = copy _2 as *const [T] (Transmute);
-        _5 = std::intrinsics::size_of_val::<[T]>(move _4) -> [return: bb1, unwind unreachable];
+        _5 = layout_of_val::<[T]>(move _4) -> [return: bb1, unwind unreachable];
     }
 
     bb1: {
-        StorageLive(_6);
-        _6 = const <T as std::mem::SizedTypeProperties>::ALIGN;
-        _7 = copy _6 as std::ptr::Alignment (Transmute);
-        StorageDead(_6);
         StorageDead(_4);
-        switchInt(copy _5) -> [0: bb4, otherwise: bb2];
+        _6 = copy (_5.0: usize);
+        switchInt(copy _6) -> [0: bb4, otherwise: bb2];
     }
 
     bb2: {
+        StorageLive(_7);
+        _7 = copy _3 as *mut u8 (PtrToPtr);
         StorageLive(_8);
-        _8 = copy _3 as *mut u8 (PtrToPtr);
-        _9 = alloc::alloc::__rust_dealloc(move _8, move _5, move _7) -> [return: bb3, unwind unreachable];
+        _8 = copy (_5.1: std::ptr::Alignment);
+        _9 = alloc::alloc::__rust_dealloc(move _7, move _6, move _8) -> [return: bb3, unwind unreachable];
     }
 
     bb3: {
         StorageDead(_8);
+        StorageDead(_7);
         goto -> bb4;
     }
 
     bb4: {
         StorageDead(_2);
+        StorageDead(_5);
         return;
     }
 }
diff --git a/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.64bit.panic-abort.mir b/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.64bit.panic-abort.mir
diff --git a/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.64bit.panic-unwind.mir b/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.64bit.panic-unwind.mir
diff --git a/tests/mir-opt/pre-codegen/drop_boxed_slice.rs b/tests/mir-opt/pre-codegen/drop_boxed_slice.rs

Original file line number	Diff line number	Diff line change
`@@ -8,33 +8,36 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {`
`8`	`8`	`let _2: std::ptr::NonNull<[T]>;`
`9`	`9`	`let mut _3: *mut [T];`
`10`	`10`	`let mut _4: *const [T];`
	`11`	`+ let mut _6: usize;`
`11`	`12`	`let _9: ();`
`12`	`13`	`scope 3 {`
	`14`	`+ let _5: std::alloc::Layout;`
`13`	`15`	`scope 4 {`
`14`		`- scope 17 (inlined Layout::size) {`
	`16`	`+ scope 8 (inlined Layout::size) {`
`15`	`17`	`}`
`16`		`- scope 18 (inlined std::ptr::Unique::<[T]>::cast::<u8>) {`
`17`		`- scope 19 (inlined NonNull::<[T]>::cast::<u8>) {`
`18`		`- scope 20 (inlined NonNull::<[T]>::as_ptr) {`
	`18`	`+ scope 9 (inlined std::ptr::Unique::<[T]>::cast::<u8>) {`
	`19`	`+ scope 10 (inlined NonNull::<[T]>::cast::<u8>) {`
	`20`	`+ scope 11 (inlined NonNull::<[T]>::as_ptr) {`
`19`	`21`	`}`
`20`	`22`	`}`
`21`	`23`	`}`
`22`		`- scope 21 (inlined <NonNull<u8> as From<std::ptr::Unique<u8>>>::from) {`
`23`		`- scope 22 (inlined std::ptr::Unique::<u8>::as_non_null_ptr) {`
	`24`	`+ scope 12 (inlined <NonNull<u8> as From<std::ptr::Unique<u8>>>::from) {`
	`25`	`+ scope 13 (inlined std::ptr::Unique::<u8>::as_non_null_ptr) {`
`24`	`26`	`}`
`25`	`27`	`}`
`26`		`- scope 23 (inlined <std::alloc::Global as Allocator>::deallocate) {`
`27`		`- scope 24 (inlined std::alloc::Global::deallocate_impl) {`
`28`		`- scope 25 (inlined std::alloc::Global::deallocate_impl_runtime) {`
`29`		`- let mut _8: *mut u8;`
`30`		`- scope 26 (inlined Layout::size) {`
	`28`	`+ scope 14 (inlined <std::alloc::Global as Allocator>::deallocate) {`
	`29`	`+ scope 15 (inlined std::alloc::Global::deallocate_impl) {`
	`30`	`+ scope 16 (inlined std::alloc::Global::deallocate_impl_runtime) {`
	`31`	`+ let mut _7: *mut u8;`
	`32`	`+ scope 17 (inlined Layout::size) {`
`31`	`33`	`}`
`32`		`- scope 27 (inlined NonNull::<u8>::as_ptr) {`
	`34`	`+ scope 18 (inlined NonNull::<u8>::as_ptr) {`
`33`	`35`	`}`
`34`		`- scope 28 (inlined std::alloc::dealloc) {`
`35`		`- scope 29 (inlined Layout::size) {`
	`36`	`+ scope 19 (inlined std::alloc::dealloc) {`
	`37`	`+ let mut _8: std::ptr::Alignment;`
	`38`	`+ scope 20 (inlined Layout::size) {`
`36`	`39`	`}`
`37`		`- scope 30 (inlined Layout::alignment) {`
	`40`	`+ scope 21 (inlined Layout::alignment) {`
`38`	`41`	`}`
`39`	`42`	`}`
`40`	`43`	`}`
`@@ -46,63 +49,44 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {`
`46`	`49`	`}`
`47`	`50`	`}`
`48`	`51`	`scope 7 (inlined Layout::for_value_raw::<[T]>) {`
`49`		`- let mut _5: usize;`
`50`		`- let mut _7: std::ptr::Alignment;`
`51`		`- scope 8 {`
`52`		`- scope 16 (inlined #[track_caller] Layout::from_size_alignment_unchecked) {`
`53`		`- }`
`54`		`- }`
`55`		`- scope 9 (inlined size_of_val_raw::<[T]>) {`
`56`		`- }`
`57`		`- scope 10 (inlined std::ptr::Alignment::of_val_raw::<[T]>) {`
`58`		`- let _6: usize;`
`59`		`- scope 11 {`
`60`		`- scope 13 (inlined #[track_caller] std::ptr::Alignment::new_unchecked) {`
`61`		`- scope 14 (inlined core::ub_checks::check_language_ub) {`
`62`		`- scope 15 (inlined core::ub_checks::check_language_ub::runtime) {`
`63`		`- }`
`64`		`- }`
`65`		`- }`
`66`		`- }`
`67`		`- scope 12 (inlined align_of_val_raw::<[T]>) {`
`68`		`- }`
`69`		`- }`
`70`	`52`	`}`
`71`	`53`	`}`
`72`	`54`	`}`
`73`	`55`	`}`
`74`	`56`
`75`	`57`	`bb0: {`
	`58`	`+ StorageLive(_5);`
`76`	`59`	`StorageLive(_2);`
`77`	`60`	`_2 = copy (((*_1).0: std::ptr::Unique<[T]>).0: std::ptr::NonNull<[T]>);`
`78`	`61`	`StorageLive(_4);`
`79`	`62`	`_3 = copy _2 as *mut [T] (Transmute);`
`80`	`63`	`_4 = copy _2 as *const [T] (Transmute);`
`81`		`- _5 = std::intrinsics::size_of_val::<[T]>(move _4) -> [return: bb1, unwind unreachable];`
	`64`	`+ _5 = layout_of_val::<[T]>(move _4) -> [return: bb1, unwind unreachable];`
`82`	`65`	`}`
`83`	`66`
`84`	`67`	`bb1: {`
`85`		`- StorageLive(_6);`
`86`		`- _6 = const <T as std::mem::SizedTypeProperties>::ALIGN;`
`87`		`- _7 = copy _6 as std::ptr::Alignment (Transmute);`
`88`		`- StorageDead(_6);`
`89`	`68`	`StorageDead(_4);`
`90`		`- switchInt(copy _5) -> [0: bb4, otherwise: bb2];`
	`69`	`+ _6 = copy (_5.0: usize);`
	`70`	`+ switchInt(copy _6) -> [0: bb4, otherwise: bb2];`
`91`	`71`	`}`
`92`	`72`
`93`	`73`	`bb2: {`
	`74`	`+ StorageLive(_7);`
	`75`	`+ _7 = copy _3 as *mut u8 (PtrToPtr);`
`94`	`76`	`StorageLive(_8);`
`95`		`- _8 = copy _3 as *mut u8 (PtrToPtr);`
`96`		`- _9 = alloc::alloc::__rust_dealloc(move _8, move _5, move _7) -> [return: bb3, unwind unreachable];`
	`77`	`+ _8 = copy (_5.1: std::ptr::Alignment);`
	`78`	`+ _9 = alloc::alloc::__rust_dealloc(move _7, move _6, move _8) -> [return: bb3, unwind unreachable];`
`97`	`79`	`}`
`98`	`80`
`99`	`81`	`bb3: {`
`100`	`82`	`StorageDead(_8);`
	`83`	`+ StorageDead(_7);`
`101`	`84`	`goto -> bb4;`
`102`	`85`	`}`
`103`	`86`
`104`	`87`	`bb4: {`
`105`	`88`	`StorageDead(_2);`
	`89`	`+ StorageDead(_5);`
`106`	`90`	`return;`
`107`	`91`	`}`
`108`	`92`	`}`