| // MIR for `array_casts` after SimplifyCfg-pre-optimizations |
| |
| fn array_casts() -> () { |
| let mut _0: (); |
| let mut _1: [usize; 2]; |
| let mut _3: *mut [usize; 2]; |
| let mut _4: &mut [usize; 2]; |
| let _5: (); |
| let mut _6: *mut usize; |
| let mut _7: *mut usize; |
| let mut _10: *const [usize; 2]; |
| let _11: &[usize; 2]; |
| let _12: (); |
| let mut _13: (&usize, &usize); |
| let mut _14: &usize; |
| let _15: usize; |
| let mut _16: *const usize; |
| let mut _17: *const usize; |
| let mut _18: &usize; |
| let _19: usize; |
| let mut _22: bool; |
| let mut _23: usize; |
| let mut _24: usize; |
| let mut _25: !; |
| let _27: !; |
| let mut _28: core::panicking::AssertKind; |
| let mut _29: &usize; |
| let _30: &usize; |
| let mut _31: &usize; |
| let _32: &usize; |
| let mut _33: std::option::Option<std::fmt::Arguments<'_>>; |
| scope 1 { |
| debug x => _1; |
| let _2: *mut usize; |
| scope 2 { |
| debug p => _2; |
| let _8: [usize; 2]; |
| scope 3 { |
| debug x => _8; |
| let _9: *const usize; |
| scope 4 { |
| debug p => _9; |
| let _20: &usize; |
| let _21: &usize; |
| let mut _34: &usize; |
| scope 5 { |
| debug left_val => _20; |
| debug right_val => _21; |
| let _26: core::panicking::AssertKind; |
| scope 6 { |
| debug kind => _26; |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| bb0: { |
| StorageLive(_1); |
| _1 = [const 0_usize, const 0_usize]; |
| StorageLive(_2); |
| StorageLive(_3); |
| StorageLive(_4); |
| _4 = &mut _1; |
| _3 = &raw mut (*_4); |
| _2 = move _3 as *mut usize (PointerCoercion(ArrayToPointer)); |
| StorageDead(_3); |
| StorageDead(_4); |
| StorageLive(_5); |
| StorageLive(_6); |
| StorageLive(_7); |
| _7 = _2; |
| _6 = std::ptr::mut_ptr::<impl *mut usize>::add(move _7, const 1_usize) -> [return: bb1, unwind continue]; |
| } |
| |
| bb1: { |
| StorageDead(_7); |
| (*_6) = const 1_usize; |
| StorageDead(_6); |
| _5 = const (); |
| StorageDead(_5); |
| StorageLive(_8); |
| _8 = [const 0_usize, const 1_usize]; |
| StorageLive(_9); |
| StorageLive(_10); |
| StorageLive(_11); |
| _11 = &_8; |
| _10 = &raw const (*_11); |
| _9 = move _10 as *const usize (PointerCoercion(ArrayToPointer)); |
| StorageDead(_10); |
| StorageDead(_11); |
| StorageLive(_12); |
| StorageLive(_13); |
| StorageLive(_14); |
| StorageLive(_15); |
| StorageLive(_16); |
| StorageLive(_17); |
| _17 = _9; |
| _16 = std::ptr::const_ptr::<impl *const usize>::add(move _17, const 1_usize) -> [return: bb2, unwind continue]; |
| } |
| |
| bb2: { |
| StorageDead(_17); |
| _15 = (*_16); |
| _14 = &_15; |
| StorageLive(_18); |
| _34 = const array_casts::promoted[0]; |
| Retag(_34); |
| _18 = &(*_34); |
| _13 = (move _14, move _18); |
| Retag(_13); |
| StorageDead(_18); |
| StorageDead(_14); |
| StorageLive(_20); |
| _20 = (_13.0: &usize); |
| Retag(_20); |
| StorageLive(_21); |
| _21 = (_13.1: &usize); |
| Retag(_21); |
| StorageLive(_22); |
| StorageLive(_23); |
| _23 = (*_20); |
| StorageLive(_24); |
| _24 = (*_21); |
| _22 = Eq(move _23, move _24); |
| switchInt(move _22) -> [0: bb4, otherwise: bb3]; |
| } |
| |
| bb3: { |
| StorageDead(_24); |
| StorageDead(_23); |
| _12 = const (); |
| StorageDead(_22); |
| StorageDead(_21); |
| StorageDead(_20); |
| StorageDead(_16); |
| StorageDead(_15); |
| StorageDead(_13); |
| StorageDead(_12); |
| _0 = const (); |
| StorageDead(_9); |
| StorageDead(_8); |
| StorageDead(_2); |
| StorageDead(_1); |
| return; |
| } |
| |
| bb4: { |
| StorageDead(_24); |
| StorageDead(_23); |
| StorageLive(_26); |
| _26 = core::panicking::AssertKind::Eq; |
| StorageLive(_27); |
| StorageLive(_28); |
| _28 = move _26; |
| StorageLive(_29); |
| StorageLive(_30); |
| _30 = &(*_20); |
| _29 = &(*_30); |
| StorageLive(_31); |
| StorageLive(_32); |
| _32 = &(*_21); |
| _31 = &(*_32); |
| StorageLive(_33); |
| _33 = Option::<Arguments<'_>>::None; |
| Retag(_33); |
| _27 = core::panicking::assert_failed::<usize, usize>(move _28, move _29, move _31, move _33) -> unwind continue; |
| } |
| } |