diff options
Diffstat (limited to 'tests/mir-opt/pre-codegen/slice_iter.reverse_loop.PreCodegen.after.panic-unwind.mir')
| -rw-r--r-- | tests/mir-opt/pre-codegen/slice_iter.reverse_loop.PreCodegen.after.panic-unwind.mir | 209 |
1 files changed, 209 insertions, 0 deletions
diff --git a/tests/mir-opt/pre-codegen/slice_iter.reverse_loop.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/slice_iter.reverse_loop.PreCodegen.after.panic-unwind.mir new file mode 100644 index 000000000..f75a9a03d --- /dev/null +++ b/tests/mir-opt/pre-codegen/slice_iter.reverse_loop.PreCodegen.after.panic-unwind.mir @@ -0,0 +1,209 @@ +// MIR for `reverse_loop` after PreCodegen + +fn reverse_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::iter::Rev<std::slice::Iter<'_, T>>; + let mut _15: std::iter::Rev<std::slice::Iter<'_, T>>; + let mut _16: &mut std::iter::Rev<std::slice::Iter<'_, T>>; + let mut _18: std::option::Option<&T>; + let mut _19: isize; + let mut _21: &impl Fn(&T); + let mut _22: (&T,); + let _23: (); + scope 1 { + debug iter => _15; + let _20: &T; + scope 2 { + debug x => _20; + } + scope 25 (inlined <Rev<std::slice::Iter<'_, T>> as Iterator>::next) { + debug self => _16; + let mut _17: &mut std::slice::Iter<'_, T>; + } + } + 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 _24: *mut T; + scope 14 { + scope 15 (inlined NonNull::<T>::new_unchecked::runtime::<T>) { + debug ptr => _24; + scope 16 (inlined ptr::mut_ptr::<impl *mut T>::is_null) { + debug self => _24; + let mut _25: *mut u8; + scope 17 { + scope 18 (inlined ptr::mut_ptr::<impl *mut T>::is_null::runtime_impl) { + debug ptr => _25; + scope 19 (inlined ptr::mut_ptr::<impl *mut u8>::addr) { + debug self => _25; + scope 20 { + scope 21 (inlined ptr::mut_ptr::<impl *mut u8>::cast::<()>) { + debug self => _25; + } + } + } + } + } + } + } + } + } + } + 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 Iterator>::rev) { + debug self => _13; + scope 23 (inlined Rev::<std::slice::Iter<'_, T>>::new) { + debug iter => _13; + } + } + scope 24 (inlined <Rev<std::slice::Iter<'_, T>> as IntoIterator>::into_iter) { + debug self => _14; + } + + bb0: { + StorageLive(_13); + 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(_24); + StorageLive(_25); + _10 = _9 as *const T (PointerCoercion(MutToConstPointer)); + _11 = NonNull::<T> { pointer: _10 }; + StorageDead(_25); + StorageDead(_24); + 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); + _14 = Rev::<std::slice::Iter<'_, T>> { iter: move _13 }; + StorageDead(_13); + StorageLive(_15); + _15 = move _14; + goto -> bb4; + } + + bb4: { + StorageLive(_18); + _16 = &mut _15; + StorageLive(_17); + _17 = &mut ((*_16).0: std::slice::Iter<'_, T>); + _18 = <std::slice::Iter<'_, T> as DoubleEndedIterator>::next_back(move _17) -> [return: bb5, unwind: bb11]; + } + + bb5: { + StorageDead(_17); + _19 = discriminant(_18); + switchInt(move _19) -> [0: bb6, 1: bb8, otherwise: bb10]; + } + + bb6: { + StorageDead(_18); + StorageDead(_15); + drop(_2) -> [return: bb7, unwind continue]; + } + + bb7: { + return; + } + + bb8: { + _20 = ((_18 as Some).0: &T); + StorageLive(_21); + _21 = &_2; + StorageLive(_22); + _22 = (_20,); + _23 = <impl Fn(&T) as Fn<(&T,)>>::call(move _21, move _22) -> [return: bb9, unwind: bb11]; + } + + bb9: { + StorageDead(_22); + StorageDead(_21); + StorageDead(_18); + goto -> bb4; + } + + bb10: { + unreachable; + } + + bb11 (cleanup): { + drop(_2) -> [return: bb12, unwind terminate]; + } + + bb12 (cleanup): { + resume; + } +} |