| - // MIR for `wide_ptr_ops` before GVN |
| + // MIR for `wide_ptr_ops` after GVN |
| |
| fn wide_ptr_ops() -> () { |
| let mut _0: (); |
| let _1: *const dyn std::marker::Send; |
| let mut _2: *const dyn std::marker::Send; |
| let _3: &dyn std::marker::Send; |
| let mut _4: &i32; |
| let _5: &i32; |
| let _6: i32; |
| let mut _8: *const dyn std::marker::Send; |
| let _9: &dyn std::marker::Send; |
| let mut _10: &i32; |
| let _11: &i32; |
| let _12: i32; |
| let mut _14: *const dyn std::marker::Send; |
| let mut _15: *const dyn std::marker::Send; |
| let mut _16: *const dyn std::marker::Send; |
| let mut _18: *const dyn std::marker::Send; |
| let mut _19: *const dyn std::marker::Send; |
| let mut _20: *const dyn std::marker::Send; |
| let mut _22: *const dyn std::marker::Send; |
| let mut _23: *const dyn std::marker::Send; |
| let mut _24: *const dyn std::marker::Send; |
| let mut _26: *const dyn std::marker::Send; |
| let mut _27: *const dyn std::marker::Send; |
| let mut _28: *const dyn std::marker::Send; |
| let mut _30: *const dyn std::marker::Send; |
| let mut _31: *const dyn std::marker::Send; |
| let mut _32: *const dyn std::marker::Send; |
| let mut _34: *const dyn std::marker::Send; |
| let mut _35: *const dyn std::marker::Send; |
| let mut _36: *const dyn std::marker::Send; |
| let mut _38: (usize, usize); |
| let mut _40: (usize, usize); |
| let _41: (); |
| let mut _42: bool; |
| let mut _43: bool; |
| let mut _44: *const [u8]; |
| let mut _45: *const [u8]; |
| let _46: (); |
| let mut _47: bool; |
| let mut _48: *const [u8]; |
| let mut _49: *const [u8]; |
| let _50: (); |
| let mut _51: bool; |
| let mut _52: *const [u8]; |
| let mut _53: *const [u8]; |
| let _54: (); |
| let mut _55: bool; |
| let mut _56: *const [u8]; |
| let mut _57: *const [u8]; |
| let _58: (); |
| let mut _59: bool; |
| let mut _60: bool; |
| let mut _61: *const [u8]; |
| let mut _62: *const [u8]; |
| let _63: (); |
| let mut _64: bool; |
| let mut _65: bool; |
| let mut _66: *const [u8]; |
| let mut _67: *const [u8]; |
| let mut _69: &i32; |
| scope 1 { |
| debug a => _1; |
| let _7: *const dyn std::marker::Send; |
| let mut _68: &i32; |
| scope 2 { |
| debug b => _7; |
| let _13: bool; |
| scope 3 { |
| debug _val => _13; |
| let _17: bool; |
| scope 4 { |
| debug _val => _17; |
| let _21: bool; |
| scope 5 { |
| debug _val => _21; |
| let _25: bool; |
| scope 6 { |
| debug _val => _25; |
| let _29: bool; |
| scope 7 { |
| debug _val => _29; |
| let _33: bool; |
| scope 8 { |
| debug _val => _33; |
| let _37: *const [u8]; |
| scope 9 { |
| debug a => _37; |
| let _39: *const [u8]; |
| scope 11 { |
| debug b => _39; |
| } |
| scope 12 { |
| } |
| } |
| scope 10 { |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| bb0: { |
| - StorageLive(_1); |
| + nop; |
| StorageLive(_2); |
| StorageLive(_3); |
| StorageLive(_4); |
| StorageLive(_5); |
| _69 = const _; |
| _5 = &(*_69); |
| _4 = &(*_5); |
| _3 = move _4 as &dyn std::marker::Send (PointerCoercion(Unsize)); |
| StorageDead(_4); |
| _2 = &raw const (*_3); |
| _1 = move _2 as *const dyn std::marker::Send (PointerCoercion(Unsize)); |
| StorageDead(_2); |
| StorageDead(_5); |
| StorageDead(_3); |
| - StorageLive(_7); |
| + nop; |
| StorageLive(_8); |
| StorageLive(_9); |
| StorageLive(_10); |
| StorageLive(_11); |
| _68 = const _; |
| _11 = &(*_68); |
| _10 = &(*_11); |
| _9 = move _10 as &dyn std::marker::Send (PointerCoercion(Unsize)); |
| StorageDead(_10); |
| _8 = &raw const (*_9); |
| _7 = move _8 as *const dyn std::marker::Send (PointerCoercion(Unsize)); |
| StorageDead(_8); |
| StorageDead(_11); |
| StorageDead(_9); |
| StorageLive(_13); |
| StorageLive(_14); |
| _14 = _1; |
| - StorageLive(_15); |
| + nop; |
| StorageLive(_16); |
| _16 = _7; |
| - _15 = move _16 as *const dyn std::marker::Send (PointerCoercion(Unsize)); |
| + _15 = _7 as *const dyn std::marker::Send (PointerCoercion(Unsize)); |
| StorageDead(_16); |
| - _13 = Eq(move _14, move _15); |
| - StorageDead(_15); |
| + _13 = Eq(_1, _15); |
| + nop; |
| StorageDead(_14); |
| StorageLive(_17); |
| StorageLive(_18); |
| _18 = _1; |
| StorageLive(_19); |
| StorageLive(_20); |
| _20 = _7; |
| - _19 = move _20 as *const dyn std::marker::Send (PointerCoercion(Unsize)); |
| + _19 = _15; |
| StorageDead(_20); |
| - _17 = Ne(move _18, move _19); |
| + _17 = Ne(_1, _15); |
| StorageDead(_19); |
| StorageDead(_18); |
| StorageLive(_21); |
| StorageLive(_22); |
| _22 = _1; |
| StorageLive(_23); |
| StorageLive(_24); |
| _24 = _7; |
| - _23 = move _24 as *const dyn std::marker::Send (PointerCoercion(Unsize)); |
| + _23 = _15; |
| StorageDead(_24); |
| - _21 = Lt(move _22, move _23); |
| + _21 = Lt(_1, _15); |
| StorageDead(_23); |
| StorageDead(_22); |
| StorageLive(_25); |
| StorageLive(_26); |
| _26 = _1; |
| StorageLive(_27); |
| StorageLive(_28); |
| _28 = _7; |
| - _27 = move _28 as *const dyn std::marker::Send (PointerCoercion(Unsize)); |
| + _27 = _15; |
| StorageDead(_28); |
| - _25 = Le(move _26, move _27); |
| + _25 = Le(_1, _15); |
| StorageDead(_27); |
| StorageDead(_26); |
| StorageLive(_29); |
| StorageLive(_30); |
| _30 = _1; |
| StorageLive(_31); |
| StorageLive(_32); |
| _32 = _7; |
| - _31 = move _32 as *const dyn std::marker::Send (PointerCoercion(Unsize)); |
| + _31 = _15; |
| StorageDead(_32); |
| - _29 = Gt(move _30, move _31); |
| + _29 = Gt(_1, _15); |
| StorageDead(_31); |
| StorageDead(_30); |
| StorageLive(_33); |
| StorageLive(_34); |
| _34 = _1; |
| StorageLive(_35); |
| StorageLive(_36); |
| _36 = _7; |
| - _35 = move _36 as *const dyn std::marker::Send (PointerCoercion(Unsize)); |
| + _35 = _15; |
| StorageDead(_36); |
| - _33 = Ge(move _34, move _35); |
| + _33 = Ge(_1, _15); |
| StorageDead(_35); |
| StorageDead(_34); |
| - StorageLive(_37); |
| + nop; |
| StorageLive(_38); |
| - _38 = (const 1_usize, const 1_usize); |
| - _37 = move _38 as *const [u8] (Transmute); |
| + _38 = const (1_usize, 1_usize); |
| + _37 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8]; |
| StorageDead(_38); |
| - StorageLive(_39); |
| + nop; |
| StorageLive(_40); |
| - _40 = (const 1_usize, const 2_usize); |
| - _39 = move _40 as *const [u8] (Transmute); |
| + _40 = const (1_usize, 2_usize); |
| + _39 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8]; |
| StorageDead(_40); |
| StorageLive(_41); |
| - StorageLive(_42); |
| + nop; |
| StorageLive(_43); |
| StorageLive(_44); |
| - _44 = _37; |
| + _44 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8]; |
| StorageLive(_45); |
| - _45 = _39; |
| - _43 = Eq(move _44, move _45); |
| + _45 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8]; |
| + _43 = Eq(const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8], const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8]); |
| StorageDead(_45); |
| StorageDead(_44); |
| _42 = Not(move _43); |
| StorageDead(_43); |
| - _41 = opaque::<bool>(move _42) -> [return: bb1, unwind unreachable]; |
| + _41 = opaque::<bool>(_42) -> [return: bb1, unwind unreachable]; |
| } |
| |
| bb1: { |
| - StorageDead(_42); |
| + nop; |
| StorageDead(_41); |
| StorageLive(_46); |
| StorageLive(_47); |
| StorageLive(_48); |
| - _48 = _37; |
| + _48 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8]; |
| StorageLive(_49); |
| - _49 = _39; |
| - _47 = Ne(move _48, move _49); |
| + _49 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8]; |
| + _47 = _42; |
| StorageDead(_49); |
| StorageDead(_48); |
| - _46 = opaque::<bool>(move _47) -> [return: bb2, unwind unreachable]; |
| + _46 = opaque::<bool>(_42) -> [return: bb2, unwind unreachable]; |
| } |
| |
| bb2: { |
| StorageDead(_47); |
| StorageDead(_46); |
| StorageLive(_50); |
| StorageLive(_51); |
| StorageLive(_52); |
| - _52 = _37; |
| + _52 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8]; |
| StorageLive(_53); |
| - _53 = _39; |
| - _51 = Le(move _52, move _53); |
| + _53 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8]; |
| + _51 = Le(const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8], const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8]); |
| StorageDead(_53); |
| StorageDead(_52); |
| _50 = opaque::<bool>(move _51) -> [return: bb3, unwind unreachable]; |
| } |
| |
| bb3: { |
| StorageDead(_51); |
| StorageDead(_50); |
| StorageLive(_54); |
| StorageLive(_55); |
| StorageLive(_56); |
| - _56 = _37; |
| + _56 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8]; |
| StorageLive(_57); |
| - _57 = _39; |
| - _55 = Lt(move _56, move _57); |
| + _57 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8]; |
| + _55 = Lt(const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8], const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8]); |
| StorageDead(_57); |
| StorageDead(_56); |
| _54 = opaque::<bool>(move _55) -> [return: bb4, unwind unreachable]; |
| } |
| |
| bb4: { |
| StorageDead(_55); |
| StorageDead(_54); |
| StorageLive(_58); |
| StorageLive(_59); |
| StorageLive(_60); |
| StorageLive(_61); |
| - _61 = _37; |
| + _61 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8]; |
| StorageLive(_62); |
| - _62 = _39; |
| - _60 = Ge(move _61, move _62); |
| + _62 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8]; |
| + _60 = Ge(const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8], const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8]); |
| StorageDead(_62); |
| StorageDead(_61); |
| _59 = Not(move _60); |
| StorageDead(_60); |
| _58 = opaque::<bool>(move _59) -> [return: bb5, unwind unreachable]; |
| } |
| |
| bb5: { |
| StorageDead(_59); |
| StorageDead(_58); |
| StorageLive(_63); |
| StorageLive(_64); |
| StorageLive(_65); |
| StorageLive(_66); |
| - _66 = _37; |
| + _66 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8]; |
| StorageLive(_67); |
| - _67 = _39; |
| - _65 = Gt(move _66, move _67); |
| + _67 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8]; |
| + _65 = Gt(const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8], const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8]); |
| StorageDead(_67); |
| StorageDead(_66); |
| _64 = Not(move _65); |
| StorageDead(_65); |
| _63 = opaque::<bool>(move _64) -> [return: bb6, unwind unreachable]; |
| } |
| |
| bb6: { |
| StorageDead(_64); |
| StorageDead(_63); |
| _0 = const (); |
| - StorageDead(_39); |
| - StorageDead(_37); |
| + nop; |
| + nop; |
| StorageDead(_33); |
| StorageDead(_29); |
| StorageDead(_25); |
| StorageDead(_21); |
| StorageDead(_17); |
| StorageDead(_13); |
| - StorageDead(_7); |
| - StorageDead(_1); |
| + nop; |
| + nop; |
| return; |
| } |
| + } |
| + |
| + ALLOC1 (size: 16, align: 8) { |
| + 01 00 00 00 00 00 00 00 02 00 00 00 00 00 00 00 │ ................ |
| + } |
| + |
| + ALLOC0 (size: 16, align: 8) { |
| + 01 00 00 00 00 00 00 00 01 00 00 00 00 00 00 00 │ ................ |
| } |
| |