| // 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_or_len => _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 std::ptr::mut_ptr::<impl *mut T>::is_null) { |
| debug self => _24; |
| let mut _25: *mut u8; |
| scope 17 { |
| scope 18 (inlined std::ptr::mut_ptr::<impl *mut T>::is_null::runtime_impl) { |
| debug ptr => _25; |
| scope 19 (inlined std::ptr::mut_ptr::<impl *mut u8>::addr) { |
| debug self => _25; |
| scope 20 { |
| scope 21 (inlined std::ptr::mut_ptr::<impl *mut u8>::cast::<()>) { |
| debug self => _25; |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| scope 9 (inlined invalid::<T>) { |
| debug addr => _8; |
| scope 10 { |
| } |
| } |
| scope 11 (inlined std::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_or_len: move _12, _marker: const ZeroSized: PhantomData<&T> }; |
| StorageDead(_12); |
| StorageDead(_11); |
| StorageDead(_7); |
| StorageDead(_4); |
| _14 = Rev::<std::slice::Iter<'_, T>> { iter: _13 }; |
| StorageDead(_13); |
| StorageLive(_15); |
| _15 = _14; |
| goto -> bb4; |
| } |
| |
| bb4: { |
| StorageLive(_18); |
| _16 = &mut _15; |
| StorageLive(_17); |
| _17 = &mut (_15.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(cleanup)]; |
| } |
| |
| bb12 (cleanup): { |
| resume; |
| } |
| } |