diff --git a/compiler/rustc_mir_transform/src/gvn.rs b/compiler/rustc_mir_transform/src/gvn.rs index 5324c39e9f222..49d04022711d6 100644 --- a/compiler/rustc_mir_transform/src/gvn.rs +++ b/compiler/rustc_mir_transform/src/gvn.rs @@ -1527,6 +1527,7 @@ impl<'body, 'a, 'tcx> VnState<'body, 'a, 'tcx> { } } + #[instrument(level = "trace", skip(self), ret)] fn simplify_cast( &mut self, initial_kind: &mut CastKind, @@ -1582,6 +1583,42 @@ impl<'body, 'a, 'tcx> VnState<'body, 'a, 'tcx> { } } + // Field-Access-then-Transmute can just transmute the original value, + // so long as the bytes of a value from only from a single field. + if let Transmute = kind + && let Value::Projection(field_value, ProjectionElem::Field(field_idx, ())) = + self.get(value) + { + if let Value::Projection( + downcast_value, + ProjectionElem::Downcast(_, _variant_idx), + ) = self.get(field_value) + { + let downcast_ty = self.ty(downcast_value); + if let Ok(downcast_layout) = self.ecx.layout_of(downcast_ty) + && let Ok(projected_layout) = self.ecx.layout_of(from) + && downcast_layout.size == projected_layout.size + { + from = downcast_ty; + value = downcast_value; + was_updated_this_iteration = true; + if projected_layout.ty == to { + return Some(value); + } + } + } else if let Some((f_idx, field_ty)) = + self.value_is_all_in_one_field(self.ty(field_value), FIRST_VARIANT) + { + assert_eq!(field_idx, f_idx, "{from} -> {field_ty}"); + from = self.ty(field_value); + value = field_value; + was_updated_this_iteration = true; + if field_ty == to { + return Some(value); + } + } + } + // Aggregate-then-Transmute can just transmute the original field value, // so long as the bytes of a value from only from a single field. if let Transmute = kind diff --git a/tests/mir-opt/const_prop/transmute.option_field.GVN.32bit.diff b/tests/mir-opt/const_prop/transmute.option_field.GVN.32bit.diff new file mode 100644 index 0000000000000..99208f5d80273 --- /dev/null +++ b/tests/mir-opt/const_prop/transmute.option_field.GVN.32bit.diff @@ -0,0 +1,40 @@ +- // MIR for `option_field` before GVN ++ // MIR for `option_field` after GVN + + fn option_field(_1: Option>) -> *const () { + debug x => _1; + let mut _0: *const (); + let mut _2: isize; + let mut _4: std::ptr::NonNull<()>; + scope 1 { + debug x => _3; + let _3: std::ptr::NonNull<()>; + } + + bb0: { + _2 = discriminant(_1); + switchInt(move _2) -> [1: bb1, otherwise: bb2]; + } + + bb1: { + StorageLive(_3); + _3 = copy ((_1 as Some).0: std::ptr::NonNull<()>); + StorageLive(_4); + _4 = copy _3; +- _0 = move _4 as *const () (Transmute); ++ _0 = copy _1 as *const () (Transmute); + StorageDead(_4); + StorageDead(_3); + goto -> bb3; + } + + bb2: { + _0 = const 0_usize as *const () (PointerWithExposedProvenance); + goto -> bb3; + } + + bb3: { + return; + } + } + diff --git a/tests/mir-opt/const_prop/transmute.option_field.GVN.64bit.diff b/tests/mir-opt/const_prop/transmute.option_field.GVN.64bit.diff new file mode 100644 index 0000000000000..99208f5d80273 --- /dev/null +++ b/tests/mir-opt/const_prop/transmute.option_field.GVN.64bit.diff @@ -0,0 +1,40 @@ +- // MIR for `option_field` before GVN ++ // MIR for `option_field` after GVN + + fn option_field(_1: Option>) -> *const () { + debug x => _1; + let mut _0: *const (); + let mut _2: isize; + let mut _4: std::ptr::NonNull<()>; + scope 1 { + debug x => _3; + let _3: std::ptr::NonNull<()>; + } + + bb0: { + _2 = discriminant(_1); + switchInt(move _2) -> [1: bb1, otherwise: bb2]; + } + + bb1: { + StorageLive(_3); + _3 = copy ((_1 as Some).0: std::ptr::NonNull<()>); + StorageLive(_4); + _4 = copy _3; +- _0 = move _4 as *const () (Transmute); ++ _0 = copy _1 as *const () (Transmute); + StorageDead(_4); + StorageDead(_3); + goto -> bb3; + } + + bb2: { + _0 = const 0_usize as *const () (PointerWithExposedProvenance); + goto -> bb3; + } + + bb3: { + return; + } + } + diff --git a/tests/mir-opt/const_prop/transmute.rs b/tests/mir-opt/const_prop/transmute.rs index ad971a64370e9..cf4244860832f 100644 --- a/tests/mir-opt/const_prop/transmute.rs +++ b/tests/mir-opt/const_prop/transmute.rs @@ -84,4 +84,12 @@ pub unsafe fn unreachable_box() -> ! { match *x {} } +// EMIT_MIR transmute.option_field.GVN.diff +pub unsafe fn option_field(x: Option>) -> *const () { + // CHECK-LABEL: fn option_field( + // CHECK: _3 = copy ((_1 as Some).0: std::ptr::NonNull<()>) + // CHECK: _0 = copy _1 as *const () (Transmute) + if let Some(x) = x { unsafe { transmute(x) } } else { 0 as *const () } +} + enum Never {} diff --git a/tests/mir-opt/const_prop/transmute.unreachable_box.GVN.32bit.diff b/tests/mir-opt/const_prop/transmute.unreachable_box.GVN.32bit.diff index 6ebce526c9833..a16d4df3e379d 100644 --- a/tests/mir-opt/const_prop/transmute.unreachable_box.GVN.32bit.diff +++ b/tests/mir-opt/const_prop/transmute.unreachable_box.GVN.32bit.diff @@ -14,7 +14,7 @@ - _1 = const 1_usize as std::boxed::Box (Transmute); - _2 = copy ((_1.0: std::ptr::Unique).0: std::ptr::NonNull) as *const Never (Transmute); + _1 = const Box::(std::ptr::Unique:: {{ pointer: NonNull:: {{ pointer: {0x1 as *const Never} is !null }}, _marker: PhantomData:: }}, std::alloc::Global); -+ _2 = const std::ptr::NonNull:: {{ pointer: {0x1 as *const Never} is !null }} as *const Never (Transmute); ++ _2 = const std::boxed::Box::(std::ptr::Unique:: {{ pointer: std::ptr::NonNull:: {{ pointer: {0x1 as *const Never} is !null }}, _marker: std::marker::PhantomData:: }}, std::alloc::Global) as *const Never (Transmute); unreachable; } } diff --git a/tests/mir-opt/const_prop/transmute.unreachable_box.GVN.64bit.diff b/tests/mir-opt/const_prop/transmute.unreachable_box.GVN.64bit.diff index 6ebce526c9833..a16d4df3e379d 100644 --- a/tests/mir-opt/const_prop/transmute.unreachable_box.GVN.64bit.diff +++ b/tests/mir-opt/const_prop/transmute.unreachable_box.GVN.64bit.diff @@ -14,7 +14,7 @@ - _1 = const 1_usize as std::boxed::Box (Transmute); - _2 = copy ((_1.0: std::ptr::Unique).0: std::ptr::NonNull) as *const Never (Transmute); + _1 = const Box::(std::ptr::Unique:: {{ pointer: NonNull:: {{ pointer: {0x1 as *const Never} is !null }}, _marker: PhantomData:: }}, std::alloc::Global); -+ _2 = const std::ptr::NonNull:: {{ pointer: {0x1 as *const Never} is !null }} as *const Never (Transmute); ++ _2 = const std::boxed::Box::(std::ptr::Unique:: {{ pointer: std::ptr::NonNull:: {{ pointer: {0x1 as *const Never} is !null }}, _marker: std::marker::PhantomData:: }}, std::alloc::Global) as *const Never (Transmute); unreachable; } } diff --git a/tests/mir-opt/dont_reset_cast_kind_without_updating_operand.test.GVN.32bit.panic-abort.diff b/tests/mir-opt/dont_reset_cast_kind_without_updating_operand.test.GVN.32bit.panic-abort.diff index ca53e87ec2c13..998863a6487d7 100644 --- a/tests/mir-opt/dont_reset_cast_kind_without_updating_operand.test.GVN.32bit.panic-abort.diff +++ b/tests/mir-opt/dont_reset_cast_kind_without_updating_operand.test.GVN.32bit.panic-abort.diff @@ -73,7 +73,8 @@ StorageDead(_2); StorageLive(_5); _10 = copy (*_1); - _11 = copy ((_10.0: std::ptr::Unique<()>).0: std::ptr::NonNull<()>) as *const () (Transmute); +- _11 = copy ((_10.0: std::ptr::Unique<()>).0: std::ptr::NonNull<()>) as *const () (Transmute); ++ _11 = copy _10 as *const () (Transmute); _5 = &raw const (*_11); StorageLive(_6); StorageLive(_7); diff --git a/tests/mir-opt/dont_reset_cast_kind_without_updating_operand.test.GVN.32bit.panic-unwind.diff b/tests/mir-opt/dont_reset_cast_kind_without_updating_operand.test.GVN.32bit.panic-unwind.diff index 2d7c387d6b73d..44aa29814e836 100644 --- a/tests/mir-opt/dont_reset_cast_kind_without_updating_operand.test.GVN.32bit.panic-unwind.diff +++ b/tests/mir-opt/dont_reset_cast_kind_without_updating_operand.test.GVN.32bit.panic-unwind.diff @@ -53,7 +53,8 @@ StorageDead(_2); StorageLive(_5); _10 = copy (*_1); - _11 = copy ((_10.0: std::ptr::Unique<()>).0: std::ptr::NonNull<()>) as *const () (Transmute); +- _11 = copy ((_10.0: std::ptr::Unique<()>).0: std::ptr::NonNull<()>) as *const () (Transmute); ++ _11 = copy _10 as *const () (Transmute); _5 = &raw const (*_11); StorageLive(_6); StorageLive(_7); diff --git a/tests/mir-opt/dont_reset_cast_kind_without_updating_operand.test.GVN.64bit.panic-abort.diff b/tests/mir-opt/dont_reset_cast_kind_without_updating_operand.test.GVN.64bit.panic-abort.diff index 005f60e8a26f1..18f916f274c33 100644 --- a/tests/mir-opt/dont_reset_cast_kind_without_updating_operand.test.GVN.64bit.panic-abort.diff +++ b/tests/mir-opt/dont_reset_cast_kind_without_updating_operand.test.GVN.64bit.panic-abort.diff @@ -73,7 +73,8 @@ StorageDead(_2); StorageLive(_5); _10 = copy (*_1); - _11 = copy ((_10.0: std::ptr::Unique<()>).0: std::ptr::NonNull<()>) as *const () (Transmute); +- _11 = copy ((_10.0: std::ptr::Unique<()>).0: std::ptr::NonNull<()>) as *const () (Transmute); ++ _11 = copy _10 as *const () (Transmute); _5 = &raw const (*_11); StorageLive(_6); StorageLive(_7); diff --git a/tests/mir-opt/dont_reset_cast_kind_without_updating_operand.test.GVN.64bit.panic-unwind.diff b/tests/mir-opt/dont_reset_cast_kind_without_updating_operand.test.GVN.64bit.panic-unwind.diff index 2d7c387d6b73d..44aa29814e836 100644 --- a/tests/mir-opt/dont_reset_cast_kind_without_updating_operand.test.GVN.64bit.panic-unwind.diff +++ b/tests/mir-opt/dont_reset_cast_kind_without_updating_operand.test.GVN.64bit.panic-unwind.diff @@ -53,7 +53,8 @@ StorageDead(_2); StorageLive(_5); _10 = copy (*_1); - _11 = copy ((_10.0: std::ptr::Unique<()>).0: std::ptr::NonNull<()>) as *const () (Transmute); +- _11 = copy ((_10.0: std::ptr::Unique<()>).0: std::ptr::NonNull<()>) as *const () (Transmute); ++ _11 = copy _10 as *const () (Transmute); _5 = &raw const (*_11); StorageLive(_6); StorageLive(_7); diff --git a/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.32bit.panic-abort.diff b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.32bit.panic-abort.diff index a0526d279a863..6098a1d8f82a5 100644 --- a/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.32bit.panic-abort.diff +++ b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.32bit.panic-abort.diff @@ -68,7 +68,8 @@ StorageLive(_3); StorageLive(_4); StorageLive(_5); - StorageLive(_6); +- StorageLive(_6); ++ nop; StorageLive(_7); - _7 = copy _1; - _6 = std::alloc::Global::alloc_impl_runtime(move _7, const false) -> [return: bb4, unwind unreachable]; @@ -92,10 +93,13 @@ } bb6: { - _5 = move ((_6 as Ok).0: std::ptr::NonNull<[u8]>); +- _5 = move ((_6 as Ok).0: std::ptr::NonNull<[u8]>); ++ _5 = copy ((_6 as Ok).0: std::ptr::NonNull<[u8]>); StorageDead(_10); - StorageDead(_6); - _4 = copy _5 as *mut [u8] (Transmute); +- StorageDead(_6); +- _4 = copy _5 as *mut [u8] (Transmute); ++ nop; ++ _4 = copy _6 as *mut [u8] (Transmute); StorageDead(_5); _3 = copy _4 as *mut u8 (PtrToPtr); StorageDead(_4); diff --git a/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-abort.diff b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-abort.diff index 3a6b52b0f2496..2a5acb36f29f7 100644 --- a/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-abort.diff +++ b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-abort.diff @@ -68,7 +68,8 @@ StorageLive(_3); StorageLive(_4); StorageLive(_5); - StorageLive(_6); +- StorageLive(_6); ++ nop; StorageLive(_7); - _7 = copy _1; - _6 = std::alloc::Global::alloc_impl_runtime(move _7, const false) -> [return: bb4, unwind unreachable]; @@ -92,10 +93,13 @@ } bb6: { - _5 = move ((_6 as Ok).0: std::ptr::NonNull<[u8]>); +- _5 = move ((_6 as Ok).0: std::ptr::NonNull<[u8]>); ++ _5 = copy ((_6 as Ok).0: std::ptr::NonNull<[u8]>); StorageDead(_10); - StorageDead(_6); - _4 = copy _5 as *mut [u8] (Transmute); +- StorageDead(_6); +- _4 = copy _5 as *mut [u8] (Transmute); ++ nop; ++ _4 = copy _6 as *mut [u8] (Transmute); StorageDead(_5); _3 = copy _4 as *mut u8 (PtrToPtr); StorageDead(_4); diff --git a/tests/mir-opt/pre-codegen/slice_iter.enumerated_loop.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/slice_iter.enumerated_loop.PreCodegen.after.panic-abort.mir index 6d3519846023a..575659e6d0ded 100644 --- a/tests/mir-opt/pre-codegen/slice_iter.enumerated_loop.PreCodegen.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/slice_iter.enumerated_loop.PreCodegen.after.panic-abort.mir @@ -180,23 +180,20 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () { bb4: { StorageLive(_32); - StorageLive(_29); StorageLive(_30); StorageLive(_27); - StorageLive(_13); - StorageLive(_14); - StorageLive(_20); StorageLive(_24); - StorageLive(_15); - StorageLive(_26); StorageLive(_16); + StorageLive(_13); _13 = copy _8; + StorageLive(_14); _14 = copy _11; switchInt(const ::IS_ZST) -> [0: bb5, otherwise: bb8]; } bb5: { StorageLive(_18); + StorageLive(_15); _15 = copy _14 as std::ptr::NonNull (Transmute); _16 = copy _13 as *mut T (Transmute); StorageLive(_17); @@ -207,6 +204,7 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () { } bb6: { + StorageDead(_15); StorageDead(_18); StorageLive(_19); _19 = Offset(copy _16, const 1_usize); @@ -216,27 +214,27 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () { } bb7: { + StorageDead(_15); StorageDead(_18); goto -> bb10; } bb8: { + StorageLive(_20); _20 = copy _14 as usize (Transmute); switchInt(copy _20) -> [0: bb9, otherwise: bb12]; } bb9: { + StorageDead(_20); goto -> bb10; } bb10: { - StorageDead(_16); - StorageDead(_26); - StorageDead(_15); - StorageDead(_24); - StorageDead(_20); StorageDead(_14); StorageDead(_13); + StorageDead(_16); + StorageDead(_24); StorageDead(_27); StorageLive(_21); StorageLive(_23); @@ -246,7 +244,6 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () { StorageDead(_23); StorageDead(_21); StorageDead(_30); - StorageDead(_29); StorageDead(_32); StorageDead(_12); drop(_2) -> [return: bb11, unwind unreachable]; @@ -259,24 +256,25 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () { bb12: { _24 = SubUnchecked(copy _20, const 1_usize); _11 = copy _24 as *const T (Transmute); + StorageDead(_20); goto -> bb13; } bb13: { + StorageLive(_26); StorageLive(_25); _25 = copy _13 as *const T (Transmute); _26 = &(*_25); StorageDead(_25); _27 = Option::<&T>::Some(copy _26); - StorageDead(_16); StorageDead(_26); - StorageDead(_15); - StorageDead(_24); - StorageDead(_20); StorageDead(_14); StorageDead(_13); + StorageDead(_16); + StorageDead(_24); _28 = copy ((_27 as Some).0: &T); StorageDead(_27); + StorageLive(_29); _29 = copy _12; _30 = AddWithOverflow(copy _12, const 1_usize); assert(!move (_30.1: bool), "attempt to compute `{} + {}`, which would overflow", copy _12, const 1_usize) -> [success: bb14, unwind unreachable]; @@ -288,9 +286,11 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () { _31 = (copy _29, copy _28); _32 = Option::<(usize, &T)>::Some(move _31); StorageDead(_31); - StorageDead(_30); StorageDead(_29); + StorageDead(_30); + StorageLive(_33); _33 = copy (((_32 as Some).0: (usize, &T)).0: usize); + StorageLive(_34); _34 = copy (((_32 as Some).0: (usize, &T)).1: &T); StorageLive(_35); _35 = &_2; @@ -302,6 +302,8 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () { bb15: { StorageDead(_36); StorageDead(_35); + StorageDead(_34); + StorageDead(_33); StorageDead(_32); goto -> bb4; } diff --git a/tests/mir-opt/pre-codegen/slice_iter.forward_loop.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/slice_iter.forward_loop.PreCodegen.after.panic-abort.mir index 6e27d02641687..f41dbd567003e 100644 --- a/tests/mir-opt/pre-codegen/slice_iter.forward_loop.PreCodegen.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/slice_iter.forward_loop.PreCodegen.after.panic-abort.mir @@ -142,20 +142,18 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () { bb4: { StorageLive(_23); - StorageLive(_12); - StorageLive(_13); - StorageLive(_19); StorageLive(_20); - StorageLive(_14); - StorageLive(_22); StorageLive(_15); + StorageLive(_12); _12 = copy _8; + StorageLive(_13); _13 = copy _11; switchInt(const ::IS_ZST) -> [0: bb5, otherwise: bb8]; } bb5: { StorageLive(_17); + StorageLive(_14); _14 = copy _13 as std::ptr::NonNull (Transmute); _15 = copy _12 as *mut T (Transmute); StorageLive(_16); @@ -166,6 +164,7 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () { } bb6: { + StorageDead(_14); StorageDead(_17); StorageLive(_18); _18 = Offset(copy _15, const 1_usize); @@ -175,27 +174,27 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () { } bb7: { + StorageDead(_14); StorageDead(_17); goto -> bb10; } bb8: { + StorageLive(_19); _19 = copy _13 as usize (Transmute); switchInt(copy _19) -> [0: bb9, otherwise: bb12]; } bb9: { + StorageDead(_19); goto -> bb10; } bb10: { - StorageDead(_15); - StorageDead(_22); - StorageDead(_14); - StorageDead(_20); - StorageDead(_19); StorageDead(_13); StorageDead(_12); + StorageDead(_15); + StorageDead(_20); StorageDead(_23); drop(_2) -> [return: bb11, unwind unreachable]; } @@ -207,22 +206,23 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () { bb12: { _20 = SubUnchecked(copy _19, const 1_usize); _11 = copy _20 as *const T (Transmute); + StorageDead(_19); goto -> bb13; } bb13: { + StorageLive(_22); StorageLive(_21); _21 = copy _12 as *const T (Transmute); _22 = &(*_21); StorageDead(_21); _23 = Option::<&T>::Some(copy _22); - StorageDead(_15); StorageDead(_22); - StorageDead(_14); - StorageDead(_20); - StorageDead(_19); StorageDead(_13); StorageDead(_12); + StorageDead(_15); + StorageDead(_20); + StorageLive(_24); _24 = copy ((_23 as Some).0: &T); StorageLive(_25); _25 = &_2; @@ -234,6 +234,7 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () { bb14: { StorageDead(_26); StorageDead(_25); + StorageDead(_24); StorageDead(_23); goto -> bb4; } diff --git a/tests/mir-opt/pre-codegen/slice_iter.range_loop.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/slice_iter.range_loop.PreCodegen.after.panic-abort.mir index 145375990710b..43e2d24674d96 100644 --- a/tests/mir-opt/pre-codegen/slice_iter.range_loop.PreCodegen.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/slice_iter.range_loop.PreCodegen.after.panic-abort.mir @@ -72,11 +72,15 @@ fn range_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () { } bb4: { + StorageLive(_7); _7 = copy _4; _4 = AddUnchecked(copy _7, const 1_usize); _8 = Option::::Some(copy _7); + StorageDead(_7); StorageDead(_6); + StorageLive(_9); _9 = copy ((_8 as Some).0: usize); + StorageLive(_11); _10 = Lt(copy _9, copy _3); assert(move _10, "index out of bounds: the length is {} but the index is {}", copy _3, copy _9) -> [success: bb5, unwind unreachable]; } @@ -93,6 +97,8 @@ fn range_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () { bb6: { StorageDead(_13); StorageDead(_12); + StorageDead(_11); + StorageDead(_9); StorageDead(_8); goto -> bb1; } diff --git a/tests/mir-opt/pre-codegen/slice_iter.reverse_loop.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/slice_iter.reverse_loop.PreCodegen.after.panic-abort.mir index ac2b0f23b9f90..1f96a8e14a5b2 100644 --- a/tests/mir-opt/pre-codegen/slice_iter.reverse_loop.PreCodegen.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/slice_iter.reverse_loop.PreCodegen.after.panic-abort.mir @@ -132,10 +132,10 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () { bb0: { StorageLive(_12); - StorageLive(_3); - StorageLive(_8); StorageLive(_11); + StorageLive(_3); _3 = PtrMetadata(copy _1); + StorageLive(_8); StorageLive(_5); StorageLive(_4); _4 = &raw const (*_1); @@ -170,9 +170,9 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () { bb3: { _12 = std::slice::Iter::<'_, T> { ptr: copy _8, end_or_len: copy _11, _marker: const ZeroSized: PhantomData<&T> }; - StorageDead(_11); StorageDead(_8); StorageDead(_3); + StorageDead(_11); _13 = Rev::> { iter: copy _12 }; StorageDead(_12); StorageLive(_14); @@ -182,15 +182,12 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () { bb4: { StorageLive(_35); - StorageLive(_22); - StorageLive(_21); - StorageLive(_16); - StorageLive(_34); StorageLive(_20); switchInt(const ::IS_ZST) -> [0: bb5, otherwise: bb6]; } bb5: { + StorageLive(_16); StorageLive(_15); _15 = copy ((_14.0: std::slice::Iter<'_, T>).1: *const T); _16 = copy _15 as std::ptr::NonNull (Transmute); @@ -205,13 +202,18 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () { _20 = Eq(copy _18, copy _19); StorageDead(_19); StorageDead(_18); + StorageDead(_16); goto -> bb7; } bb6: { + StorageLive(_22); + StorageLive(_21); _21 = copy ((_14.0: std::slice::Iter<'_, T>).1: *const T); _22 = copy _21 as usize (Transmute); + StorageDead(_21); _20 = Eq(copy _22, const 0_usize); + StorageDead(_22); goto -> bb7; } @@ -220,6 +222,7 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () { } bb8: { + StorageLive(_34); StorageLive(_28); StorageLive(_30); StorageLive(_24); @@ -279,11 +282,9 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () { StorageDead(_33); StorageDead(_28); _35 = Option::<&T>::Some(copy _34); - StorageDead(_20); StorageDead(_34); - StorageDead(_16); - StorageDead(_21); - StorageDead(_22); + StorageDead(_20); + StorageLive(_36); _36 = copy ((_35 as Some).0: &T); StorageLive(_37); _37 = &_2; @@ -295,16 +296,13 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () { bb14: { StorageDead(_38); StorageDead(_37); + StorageDead(_36); StorageDead(_35); goto -> bb4; } bb15: { StorageDead(_20); - StorageDead(_34); - StorageDead(_16); - StorageDead(_21); - StorageDead(_22); StorageDead(_35); StorageDead(_14); drop(_2) -> [return: bb16, unwind unreachable]; diff --git a/tests/mir-opt/pre-codegen/slice_iter.slice_iter_generic_is_empty.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/slice_iter.slice_iter_generic_is_empty.PreCodegen.after.panic-abort.mir index 9b510380b10b2..04f78fa3e7e3b 100644 --- a/tests/mir-opt/pre-codegen/slice_iter.slice_iter_generic_is_empty.PreCodegen.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/slice_iter.slice_iter_generic_is_empty.PreCodegen.after.panic-abort.mir @@ -30,13 +30,11 @@ fn slice_iter_generic_is_empty(_1: &std::slice::Iter<'_, T>) -> bool { } bb0: { - StorageLive(_8); - StorageLive(_7); - StorageLive(_3); switchInt(const ::IS_ZST) -> [0: bb1, otherwise: bb2]; } bb1: { + StorageLive(_3); StorageLive(_2); _2 = copy ((*_1).1: *const T); _3 = copy _2 as std::ptr::NonNull (Transmute); @@ -51,20 +49,22 @@ fn slice_iter_generic_is_empty(_1: &std::slice::Iter<'_, T>) -> bool { _0 = Eq(copy _5, copy _6); StorageDead(_6); StorageDead(_5); + StorageDead(_3); goto -> bb3; } bb2: { + StorageLive(_8); + StorageLive(_7); _7 = copy ((*_1).1: *const T); _8 = copy _7 as usize (Transmute); + StorageDead(_7); _0 = Eq(copy _8, const 0_usize); + StorageDead(_8); goto -> bb3; } bb3: { - StorageDead(_3); - StorageDead(_7); - StorageDead(_8); return; } } diff --git a/tests/mir-opt/pre-codegen/slice_iter.slice_iter_mut_next_back.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/slice_iter.slice_iter_mut_next_back.PreCodegen.after.panic-abort.mir index 99f793ea67249..94471cbb157c5 100644 --- a/tests/mir-opt/pre-codegen/slice_iter.slice_iter_mut_next_back.PreCodegen.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/slice_iter.slice_iter_mut_next_back.PreCodegen.after.panic-abort.mir @@ -73,16 +73,13 @@ fn slice_iter_mut_next_back(_1: &mut std::slice::IterMut<'_, T>) -> Option<&mut } bb0: { - StorageLive(_9); - StorageLive(_8); - StorageLive(_3); StorageLive(_2); - StorageLive(_21); StorageLive(_7); switchInt(const ::IS_ZST) -> [0: bb1, otherwise: bb2]; } bb1: { + StorageLive(_3); _2 = copy ((*_1).1: *mut T); _3 = copy _2 as std::ptr::NonNull (Transmute); StorageLive(_5); @@ -95,13 +92,18 @@ fn slice_iter_mut_next_back(_1: &mut std::slice::IterMut<'_, T>) -> Option<&mut _7 = Eq(copy _5, copy _6); StorageDead(_6); StorageDead(_5); + StorageDead(_3); goto -> bb3; } bb2: { + StorageLive(_9); + StorageLive(_8); _8 = copy ((*_1).1: *mut T); _9 = copy _8 as usize (Transmute); + StorageDead(_8); _7 = Eq(copy _9, const 0_usize); + StorageDead(_9); goto -> bb3; } @@ -110,6 +112,7 @@ fn slice_iter_mut_next_back(_1: &mut std::slice::IterMut<'_, T>) -> Option<&mut } bb4: { + StorageLive(_21); StorageLive(_15); StorageLive(_17); StorageLive(_11); @@ -169,6 +172,7 @@ fn slice_iter_mut_next_back(_1: &mut std::slice::IterMut<'_, T>) -> Option<&mut StorageDead(_20); StorageDead(_15); _0 = Option::<&mut T>::Some(copy _21); + StorageDead(_21); goto -> bb11; } @@ -179,11 +183,7 @@ fn slice_iter_mut_next_back(_1: &mut std::slice::IterMut<'_, T>) -> Option<&mut bb11: { StorageDead(_7); - StorageDead(_21); StorageDead(_2); - StorageDead(_3); - StorageDead(_8); - StorageDead(_9); return; } } diff --git a/tests/mir-opt/pre-codegen/slice_iter.slice_iter_next.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/slice_iter.slice_iter_next.PreCodegen.after.panic-abort.mir index 5711b556203ac..70e21435cc18f 100644 --- a/tests/mir-opt/pre-codegen/slice_iter.slice_iter_next.PreCodegen.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/slice_iter.slice_iter_next.PreCodegen.after.panic-abort.mir @@ -53,20 +53,18 @@ fn slice_iter_next(_1: &mut std::slice::Iter<'_, T>) -> Option<&T> { } bb0: { - StorageLive(_2); - StorageLive(_3); - StorageLive(_10); StorageLive(_11); - StorageLive(_4); - StorageLive(_13); StorageLive(_5); + StorageLive(_2); _2 = copy ((*_1).0: std::ptr::NonNull); + StorageLive(_3); _3 = copy ((*_1).1: *const T); switchInt(const ::IS_ZST) -> [0: bb1, otherwise: bb4]; } bb1: { StorageLive(_7); + StorageLive(_4); _4 = copy _3 as std::ptr::NonNull (Transmute); _5 = copy _2 as *mut T (Transmute); StorageLive(_6); @@ -77,6 +75,7 @@ fn slice_iter_next(_1: &mut std::slice::Iter<'_, T>) -> Option<&T> { } bb2: { + StorageDead(_4); StorageDead(_7); StorageLive(_9); StorageLive(_8); @@ -85,48 +84,57 @@ fn slice_iter_next(_1: &mut std::slice::Iter<'_, T>) -> Option<&T> { StorageDead(_8); ((*_1).0: std::ptr::NonNull) = move _9; StorageDead(_9); - goto -> bb7; + goto -> bb8; } bb3: { + StorageDead(_4); _0 = const {transmute(0x0000000000000000): Option<&T>}; StorageDead(_7); - goto -> bb8; + goto -> bb6; } bb4: { + StorageLive(_10); _10 = copy _3 as usize (Transmute); - switchInt(copy _10) -> [0: bb5, otherwise: bb6]; + switchInt(copy _10) -> [0: bb5, otherwise: bb7]; } bb5: { _0 = const {transmute(0x0000000000000000): Option<&T>}; - goto -> bb8; + StorageDead(_10); + goto -> bb6; } bb6: { + StorageDead(_3); + StorageDead(_2); + goto -> bb9; + } + + bb7: { _11 = SubUnchecked(copy _10, const 1_usize); ((*_1).1: *const T) = copy _11 as *const T (Transmute); - goto -> bb7; + StorageDead(_10); + goto -> bb8; } - bb7: { + bb8: { + StorageLive(_13); StorageLive(_12); _12 = copy _2 as *const T (Transmute); _13 = &(*_12); StorageDead(_12); _0 = Option::<&T>::Some(copy _13); - goto -> bb8; + StorageDead(_13); + StorageDead(_3); + StorageDead(_2); + goto -> bb9; } - bb8: { + bb9: { StorageDead(_5); - StorageDead(_13); - StorageDead(_4); StorageDead(_11); - StorageDead(_10); - StorageDead(_3); - StorageDead(_2); return; } }