diff options
Diffstat (limited to 'tests/mir-opt/pre-codegen/slice_iter.forward_loop.PreCodegen.after.panic-unwind.mir')
| -rw-r--r-- | tests/mir-opt/pre-codegen/slice_iter.forward_loop.PreCodegen.after.panic-unwind.mir | 192 |
1 files changed, 192 insertions, 0 deletions
diff --git a/tests/mir-opt/pre-codegen/slice_iter.forward_loop.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/slice_iter.forward_loop.PreCodegen.after.panic-unwind.mir new file mode 100644 index 000000000..cfc304987 --- /dev/null +++ b/tests/mir-opt/pre-codegen/slice_iter.forward_loop.PreCodegen.after.panic-unwind.mir @@ -0,0 +1,192 @@ +// MIR for `forward_loop` after PreCodegen + +fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () { + debug slice => _1; + debug f => _2; + let mut _0: (); + let mut _13: std::slice::Iter<'_, T>; + let mut _14: std::slice::Iter<'_, T>; + let mut _15: &mut std::slice::Iter<'_, T>; + let mut _16: std::option::Option<&T>; + let mut _17: isize; + let mut _19: &impl Fn(&T); + let mut _20: (&T,); + let _21: (); + scope 1 { + debug iter => _14; + let _18: &T; + scope 2 { + debug x => _18; + } + } + scope 3 (inlined core::slice::<impl [T]>::iter) { + debug self => _1; + scope 4 (inlined std::slice::Iter::<'_, T>::new) { + debug slice => _1; + let _4: *const T; + let mut _5: bool; + let mut _6: usize; + let mut _8: usize; + let mut _9: *mut T; + let mut _11: std::ptr::NonNull<T>; + let mut _12: *const T; + scope 5 { + debug ptr => _4; + scope 6 { + let _7: *const T; + scope 7 { + debug end => _7; + scope 13 (inlined NonNull::<T>::new_unchecked) { + debug ptr => _9; + let mut _10: *const T; + let mut _22: *mut T; + scope 14 { + scope 15 (inlined NonNull::<T>::new_unchecked::runtime::<T>) { + debug ptr => _22; + scope 16 (inlined ptr::mut_ptr::<impl *mut T>::is_null) { + debug self => _22; + let mut _23: *mut u8; + scope 17 { + scope 18 (inlined ptr::mut_ptr::<impl *mut T>::is_null::runtime_impl) { + debug ptr => _23; + scope 19 (inlined ptr::mut_ptr::<impl *mut u8>::addr) { + debug self => _23; + scope 20 { + scope 21 (inlined ptr::mut_ptr::<impl *mut u8>::cast::<()>) { + debug self => _23; + } + } + } + } + } + } + } + } + } + } + scope 9 (inlined invalid::<T>) { + debug addr => _8; + scope 10 { + } + } + scope 11 (inlined ptr::const_ptr::<impl *const T>::add) { + debug self => _4; + debug count => _6; + scope 12 { + } + } + } + } + scope 8 (inlined core::slice::<impl [T]>::as_ptr) { + debug self => _1; + let mut _3: *const [T]; + } + } + } + scope 22 (inlined <std::slice::Iter<'_, T> as IntoIterator>::into_iter) { + debug self => _13; + } + + bb0: { + StorageLive(_4); + StorageLive(_3); + _3 = &raw const (*_1); + _4 = move _3 as *const T (PtrToPtr); + StorageDead(_3); + StorageLive(_7); + StorageLive(_5); + _5 = const _; + switchInt(move _5) -> [0: bb1, otherwise: bb2]; + } + + bb1: { + StorageLive(_6); + _6 = Len((*_1)); + _7 = Offset(_4, _6); + StorageDead(_6); + goto -> bb3; + } + + bb2: { + StorageLive(_8); + _8 = Len((*_1)); + _7 = _8 as *const T (Transmute); + StorageDead(_8); + goto -> bb3; + } + + bb3: { + StorageDead(_5); + StorageLive(_11); + StorageLive(_9); + _9 = _4 as *mut T (PtrToPtr); + StorageLive(_10); + StorageLive(_22); + StorageLive(_23); + _10 = _9 as *const T (PointerCoercion(MutToConstPointer)); + _11 = NonNull::<T> { pointer: _10 }; + StorageDead(_23); + StorageDead(_22); + StorageDead(_10); + StorageDead(_9); + StorageLive(_12); + _12 = _7; + _13 = std::slice::Iter::<'_, T> { ptr: move _11, end: move _12, _marker: const ZeroSized: PhantomData<&T> }; + StorageDead(_12); + StorageDead(_11); + StorageDead(_7); + StorageDead(_4); + StorageLive(_14); + _14 = move _13; + goto -> bb4; + } + + bb4: { + StorageLive(_16); + _15 = &mut _14; + _16 = <std::slice::Iter<'_, T> as Iterator>::next(_15) -> [return: bb5, unwind: bb11]; + } + + bb5: { + _17 = discriminant(_16); + switchInt(move _17) -> [0: bb6, 1: bb8, otherwise: bb10]; + } + + bb6: { + StorageDead(_16); + StorageDead(_14); + drop(_2) -> [return: bb7, unwind continue]; + } + + bb7: { + return; + } + + bb8: { + _18 = ((_16 as Some).0: &T); + StorageLive(_19); + _19 = &_2; + StorageLive(_20); + _20 = (_18,); + _21 = <impl Fn(&T) as Fn<(&T,)>>::call(move _19, move _20) -> [return: bb9, unwind: bb11]; + } + + bb9: { + StorageDead(_20); + StorageDead(_19); + StorageDead(_16); + goto -> bb4; + } + + bb10: { + unreachable; + } + + bb11 (cleanup): { + drop(_2) -> [return: bb12, unwind terminate]; + } + + bb12 (cleanup): { + resume; + } +} |