From 3f7dc376edffb9e025bfbfca5cc0360eedac7510 Mon Sep 17 00:00:00 2001 From: Ohad Ravid Date: Tue, 3 Jun 2025 07:36:50 +0300 Subject: [PATCH 01/25] Added a mir-opt test for generating storage statements for scoped locals --- ...sue_141649.main.CopyProp.panic-unwind.diff | 100 ++++++++++++++++++ tests/mir-opt/copy-prop/issue_141649.rs | 27 +++++ 2 files changed, 127 insertions(+) create mode 100644 tests/mir-opt/copy-prop/issue_141649.main.CopyProp.panic-unwind.diff create mode 100644 tests/mir-opt/copy-prop/issue_141649.rs diff --git a/tests/mir-opt/copy-prop/issue_141649.main.CopyProp.panic-unwind.diff b/tests/mir-opt/copy-prop/issue_141649.main.CopyProp.panic-unwind.diff new file mode 100644 index 0000000000000..e02fe72a47a7b --- /dev/null +++ b/tests/mir-opt/copy-prop/issue_141649.main.CopyProp.panic-unwind.diff @@ -0,0 +1,100 @@ +- // MIR for `main` before CopyProp ++ // MIR for `main` after CopyProp + + fn main() -> () { + let mut _0: (); + let _1: (); + let _2: main::S; + let _3: (); + let mut _4: main::S; + let _5: (); + let _6: main::S; + let _7: (); + let mut _8: main::S; + let _9: (); + let _10: main::C; + let _11: (); + let mut _12: main::C; + let _13: main::C; + let _14: (); + let mut _15: main::C; + scope 1 { + debug s1 => _2; + } + scope 2 { + debug s2 => _6; + } + scope 3 { + debug c1 => _10; + } + scope 4 { + debug c2 => _13; + } + + bb0: { +- StorageLive(_1); +- StorageLive(_2); + _2 = S(const 1_usize, const 2_usize); + StorageLive(_3); +- StorageLive(_4); +- _4 = move _2; +- _3 = std::mem::drop::(move _4) -> [return: bb1, unwind continue]; ++ _3 = std::mem::drop::(move _2) -> [return: bb1, unwind continue]; + } + + bb1: { +- StorageDead(_4); + StorageDead(_3); +- _1 = const (); +- StorageDead(_2); +- StorageDead(_1); +- StorageLive(_5); +- StorageLive(_6); + _6 = S(const 3_usize, const 4_usize); + StorageLive(_7); +- StorageLive(_8); +- _8 = move _6; +- _7 = std::mem::drop::(move _8) -> [return: bb2, unwind continue]; ++ _7 = std::mem::drop::(move _6) -> [return: bb2, unwind continue]; + } + + bb2: { +- StorageDead(_8); + StorageDead(_7); +- _5 = const (); +- StorageDead(_6); +- StorageDead(_5); +- StorageLive(_9); +- StorageLive(_10); + _10 = C(const 1_usize, const 2_usize); + StorageLive(_11); +- StorageLive(_12); +- _12 = copy _10; +- _11 = std::mem::drop::(move _12) -> [return: bb3, unwind continue]; ++ _11 = std::mem::drop::(copy _10) -> [return: bb3, unwind continue]; + } + + bb3: { +- StorageDead(_12); + StorageDead(_11); +- _9 = const (); +- StorageDead(_10); +- StorageDead(_9); +- StorageLive(_13); + _13 = C(const 3_usize, const 4_usize); + StorageLive(_14); +- StorageLive(_15); +- _15 = copy _13; +- _14 = std::mem::drop::(move _15) -> [return: bb4, unwind continue]; ++ _14 = std::mem::drop::(copy _13) -> [return: bb4, unwind continue]; + } + + bb4: { +- StorageDead(_15); + StorageDead(_14); + _0 = const (); +- StorageDead(_13); + return; + } + } + diff --git a/tests/mir-opt/copy-prop/issue_141649.rs b/tests/mir-opt/copy-prop/issue_141649.rs new file mode 100644 index 0000000000000..3227c47bcc72c --- /dev/null +++ b/tests/mir-opt/copy-prop/issue_141649.rs @@ -0,0 +1,27 @@ +// skip-filecheck +// EMIT_MIR_FOR_EACH_PANIC_STRATEGY +//@ test-mir-pass: CopyProp + +// EMIT_MIR issue_141649.main.CopyProp.diff +fn main() { + struct S(usize, usize); + { + let s1 = S(1, 2); + drop(s1); + } + { + let s2 = S(3, 4); + drop(s2); + } + + #[derive(Clone, Copy)] + struct C(usize, usize); + { + let c1 = C(1, 2); + drop(c1); + } + { + let c2 = C(3, 4); + drop(c2); + } +} From ab6ad05da34ed1ce80082ec6448465433b3ae33e Mon Sep 17 00:00:00 2001 From: Ohad Ravid Date: Tue, 3 Jun 2025 07:49:56 +0300 Subject: [PATCH 02/25] Implement `MaybeUninitializedLocals` analysis for `copy_prop` mir-opt to remove fewer storage statements # Conflicts: # tests/mir-opt/copy-prop/dead_stores_better.f.CopyProp.after.panic-abort.mir # tests/mir-opt/copy-prop/dead_stores_better.f.CopyProp.after.panic-unwind.mir --- .../src/impls/initialized.rs | 74 +++++++++ compiler/rustc_mir_dataflow/src/impls/mod.rs | 2 +- compiler/rustc_mir_transform/src/copy_prop.rs | 96 +++++++++++- ...rrowed_storage_not_removed.f.CopyProp.diff | 21 +++ .../copy_prop_borrowed_storage_not_removed.rs | 30 ++++ ...rop_storage_twice.dead_twice.CopyProp.diff | 28 ++++ ...rop_storage_twice.live_twice.CopyProp.diff | 27 ++++ .../copy-prop/copy_prop_storage_twice.rs | 61 ++++++++ .../cycle.main.CopyProp.panic-abort.diff | 4 +- .../cycle.main.CopyProp.panic-unwind.diff | 4 +- ...res_79191.f.CopyProp.after.panic-abort.mir | 2 + ...es_79191.f.CopyProp.after.panic-unwind.mir | 2 + ...es_better.f.CopyProp.after.panic-abort.mir | 28 ++++ ...s_better.f.CopyProp.after.panic-unwind.mir | 28 ++++ ...ssue_107511.main.CopyProp.panic-abort.diff | 4 +- ...sue_107511.main.CopyProp.panic-unwind.diff | 4 +- ...ssue_141649.main.CopyProp.panic-abort.diff | 142 ++++++++++++++++++ ...sue_141649.main.CopyProp.panic-unwind.diff | 100 ++++++++---- tests/mir-opt/copy-prop/issue_141649.rs | 11 ++ ...41649_debug.main.CopyProp.panic-abort.diff | 100 ++++++++++++ ...1649_debug.main.CopyProp.panic-unwind.diff | 100 ++++++++++++ tests/mir-opt/copy-prop/issue_141649_debug.rs | 29 ++++ ...reborrow.demiraw.CopyProp.panic-abort.diff | 4 +- ...eborrow.demiraw.CopyProp.panic-unwind.diff | 4 +- .../reborrow.miraw.CopyProp.panic-abort.diff | 4 +- .../reborrow.miraw.CopyProp.panic-unwind.diff | 4 +- .../reborrow.remut.CopyProp.panic-abort.diff | 4 +- .../reborrow.remut.CopyProp.panic-unwind.diff | 4 +- .../reborrow.reraw.CopyProp.panic-abort.diff | 4 +- .../reborrow.reraw.CopyProp.panic-unwind.diff | 4 +- ....foo.SimplifyLocals-final.panic-abort.diff | 2 + ...foo.SimplifyLocals-final.panic-unwind.diff | 2 + 32 files changed, 875 insertions(+), 58 deletions(-) create mode 100644 tests/mir-opt/copy-prop/copy_prop_borrowed_storage_not_removed.f.CopyProp.diff create mode 100644 tests/mir-opt/copy-prop/copy_prop_borrowed_storage_not_removed.rs create mode 100644 tests/mir-opt/copy-prop/copy_prop_storage_twice.dead_twice.CopyProp.diff create mode 100644 tests/mir-opt/copy-prop/copy_prop_storage_twice.live_twice.CopyProp.diff create mode 100644 tests/mir-opt/copy-prop/copy_prop_storage_twice.rs create mode 100644 tests/mir-opt/copy-prop/dead_stores_better.f.CopyProp.after.panic-abort.mir create mode 100644 tests/mir-opt/copy-prop/dead_stores_better.f.CopyProp.after.panic-unwind.mir create mode 100644 tests/mir-opt/copy-prop/issue_141649.main.CopyProp.panic-abort.diff create mode 100644 tests/mir-opt/copy-prop/issue_141649_debug.main.CopyProp.panic-abort.diff create mode 100644 tests/mir-opt/copy-prop/issue_141649_debug.main.CopyProp.panic-unwind.diff create mode 100644 tests/mir-opt/copy-prop/issue_141649_debug.rs diff --git a/compiler/rustc_mir_dataflow/src/impls/initialized.rs b/compiler/rustc_mir_dataflow/src/impls/initialized.rs index 9216106b6eddc..81c0abae262cb 100644 --- a/compiler/rustc_mir_dataflow/src/impls/initialized.rs +++ b/compiler/rustc_mir_dataflow/src/impls/initialized.rs @@ -605,6 +605,80 @@ impl<'tcx> Analysis<'tcx> for MaybeUninitializedPlaces<'_, 'tcx> { } } +/// A dataflow analysis that tracks locals that are maybe uninitialized. +/// +/// This is a simpler analysis than `MaybeUninitializedPlaces`, because it does not track +/// individual fields. +pub struct MaybeUninitializedLocals; + +impl MaybeUninitializedLocals { + pub fn new() -> Self { + Self {} + } +} + +impl<'tcx> Analysis<'tcx> for MaybeUninitializedLocals { + type Domain = DenseBitSet; + + const NAME: &'static str = "maybe_uninit_locals"; + + fn bottom_value(&self, body: &Body<'tcx>) -> Self::Domain { + // bottom = all locals are initialized. + DenseBitSet::new_empty(body.local_decls.len()) + } + + fn initialize_start_block(&self, body: &Body<'tcx>, state: &mut Self::Domain) { + // All locals start as uninitialized... + state.insert_all(); + // ...except for arguments, which are definitely initialized. + for arg in body.args_iter() { + state.remove(arg); + } + } + + fn apply_primary_statement_effect( + &mut self, + state: &mut Self::Domain, + statement: &mir::Statement<'tcx>, + _location: Location, + ) { + match statement.kind { + // An assignment makes a local initialized. + mir::StatementKind::Assign(box (place, _)) => { + if let Some(local) = place.as_local() { + state.remove(local); + } + } + // Deinit makes the local uninitialized. + mir::StatementKind::Deinit(box place) => { + // A deinit makes a local uninitialized. + if let Some(local) = place.as_local() { + state.insert(local); + } + } + // Storage{Live,Dead} makes a local uninitialized. + mir::StatementKind::StorageLive(local) | mir::StatementKind::StorageDead(local) => { + state.insert(local); + } + _ => {} + } + } + + fn apply_call_return_effect( + &mut self, + state: &mut Self::Domain, + _block: mir::BasicBlock, + return_places: CallReturnPlaces<'_, 'tcx>, + ) { + // The return place of a call is initialized. + return_places.for_each(|place| { + if let Some(local) = place.as_local() { + state.remove(local); + } + }); + } +} + /// There can be many more `InitIndex` than there are locals in a MIR body. /// We use a mixed bitset to avoid paying too high a memory footprint. pub type EverInitializedPlacesDomain = MixedBitSet; diff --git a/compiler/rustc_mir_dataflow/src/impls/mod.rs b/compiler/rustc_mir_dataflow/src/impls/mod.rs index 6d573e1c00e1c..0f93e5ef15a82 100644 --- a/compiler/rustc_mir_dataflow/src/impls/mod.rs +++ b/compiler/rustc_mir_dataflow/src/impls/mod.rs @@ -6,7 +6,7 @@ mod storage_liveness; pub use self::borrowed_locals::{MaybeBorrowedLocals, borrowed_locals}; pub use self::initialized::{ EverInitializedPlaces, EverInitializedPlacesDomain, MaybeInitializedPlaces, - MaybeUninitializedPlaces, MaybeUninitializedPlacesDomain, + MaybeUninitializedLocals, MaybeUninitializedPlaces, MaybeUninitializedPlacesDomain, }; pub use self::liveness::{ DefUse, MaybeLiveLocals, MaybeTransitiveLiveLocals, diff --git a/compiler/rustc_mir_transform/src/copy_prop.rs b/compiler/rustc_mir_transform/src/copy_prop.rs index 2e9c3a5bf3eeb..bff7d7746bd01 100644 --- a/compiler/rustc_mir_transform/src/copy_prop.rs +++ b/compiler/rustc_mir_transform/src/copy_prop.rs @@ -3,6 +3,8 @@ use rustc_index::bit_set::DenseBitSet; use rustc_middle::mir::visit::*; use rustc_middle::mir::*; use rustc_middle::ty::TyCtxt; +use rustc_mir_dataflow::impls::MaybeUninitializedLocals; +use rustc_mir_dataflow::{Analysis, ResultsCursor}; use tracing::{debug, instrument}; use crate::ssa::SsaLocals; @@ -16,7 +18,7 @@ use crate::ssa::SsaLocals; /// _d = move? _c /// where each of the locals is only assigned once. /// -/// We want to replace all those locals by `_a`, either copied or moved. +/// We want to replace all those locals by `_a` (the "head"), either copied or moved. pub(super) struct CopyProp; impl<'tcx> crate::MirPass<'tcx> for CopyProp { @@ -30,15 +32,30 @@ impl<'tcx> crate::MirPass<'tcx> for CopyProp { let typing_env = body.typing_env(tcx); let ssa = SsaLocals::new(tcx, body, typing_env); - debug!(borrowed_locals = ?ssa.borrowed_locals()); + let borrowed_locals = ssa.borrowed_locals().clone(); + + debug!(?borrowed_locals); debug!(copy_classes = ?ssa.copy_classes()); let mut any_replacement = false; - let mut storage_to_remove = DenseBitSet::new_empty(body.local_decls.len()); + let fully_moved = fully_moved_locals(&ssa, body); + debug!(?fully_moved); + + let mut head_storage_to_check = DenseBitSet::new_empty(fully_moved.domain_size()); + let mut storage_to_remove = DenseBitSet::new_empty(fully_moved.domain_size()); + for (local, &head) in ssa.copy_classes().iter_enumerated() { if local != head { any_replacement = true; - storage_to_remove.insert(head); + // We need to determine if we can keep the head's storage statements (which enables better optimizations). + // For every local's usage location, if the head is maybe-uninitialized, we'll need to remove it's storage statements. + head_storage_to_check.insert(head); + + if borrowed_locals.contains(local) { + // To keep the storage of a head, we require that none of the locals in it's copy class are borrowed, + // since otherwise we cannot easily identify when it is used. + storage_to_remove.insert(head); + } } } @@ -49,6 +66,29 @@ impl<'tcx> crate::MirPass<'tcx> for CopyProp { let fully_moved = fully_moved_locals(&ssa, body); debug!(?fully_moved); + // Debug builds have no use for the storage statements, so avoid extra work. + let storage_to_remove = if any_replacement && tcx.sess.emit_lifetime_markers() { + let maybe_uninit = MaybeUninitializedLocals::new() + .iterate_to_fixpoint(tcx, body, Some("mir_opt::copy_prop")) + .into_results_cursor(body); + + let mut storage_checker = StorageChecker { + maybe_uninit, + copy_classes: ssa.copy_classes(), + head_storage_to_check, + storage_to_remove, + }; + + storage_checker.visit_body(body); + + storage_checker.storage_to_remove + } else { + // Conservatively remove all storage statements for the head locals. + head_storage_to_check + }; + + debug!(?storage_to_remove); + Replacer { tcx, copy_classes: ssa.copy_classes(), fully_moved, storage_to_remove } .visit_body_preserves_cfg(body); @@ -151,3 +191,51 @@ impl<'tcx> MutVisitor<'tcx> for Replacer<'_, 'tcx> { } } } + +// Marks heads of copy classes that are maybe uninitialized at the location of a local +// as needing storage statement removal. +struct StorageChecker<'a, 'tcx> { + maybe_uninit: ResultsCursor<'a, 'tcx, MaybeUninitializedLocals>, + copy_classes: &'a IndexSlice, + head_storage_to_check: DenseBitSet, + storage_to_remove: DenseBitSet, +} + +impl<'a, 'tcx> Visitor<'tcx> for StorageChecker<'a, 'tcx> { + fn visit_local(&mut self, local: Local, context: PlaceContext, loc: Location) { + // We don't need to check storage statements and statements for which the local doesn't need to be initialized. + match context { + PlaceContext::MutatingUse( + MutatingUseContext::Store + | MutatingUseContext::Call + | MutatingUseContext::Yield + | MutatingUseContext::AsmOutput, + ) + | PlaceContext::NonUse(_) => { + return; + } + _ => {} + }; + + let head = self.copy_classes[local]; + + // The head must be initialized at the location of the local, otherwise we must remove it's storage statements. + if self.head_storage_to_check.contains(head) { + self.maybe_uninit.seek_before_primary_effect(loc); + + if self.maybe_uninit.get().contains(head) { + debug!( + ?loc, + ?context, + ?local, + ?head, + "found a head at a location in which it is maybe uninit, marking head for storage statement removal" + ); + self.storage_to_remove.insert(head); + + // Once we found a use of the head that is maybe uninit, we do not need to check it again. + self.head_storage_to_check.remove(head); + } + } + } +} diff --git a/tests/mir-opt/copy-prop/copy_prop_borrowed_storage_not_removed.f.CopyProp.diff b/tests/mir-opt/copy-prop/copy_prop_borrowed_storage_not_removed.f.CopyProp.diff new file mode 100644 index 0000000000000..782b053cf2240 --- /dev/null +++ b/tests/mir-opt/copy-prop/copy_prop_borrowed_storage_not_removed.f.CopyProp.diff @@ -0,0 +1,21 @@ +- // MIR for `f` before CopyProp ++ // MIR for `f` after CopyProp + + fn f(_1: (T, T)) -> T { + let mut _0: T; + let mut _2: T; + let mut _3: T; + let mut _4: &T; + + bb0: { +- StorageLive(_2); + _2 = copy (_1.0: T); +- _3 = copy _2; +- _4 = &_3; +- StorageDead(_2); ++ _4 = &_2; + _0 = copy (*_4); + return; + } + } + diff --git a/tests/mir-opt/copy-prop/copy_prop_borrowed_storage_not_removed.rs b/tests/mir-opt/copy-prop/copy_prop_borrowed_storage_not_removed.rs new file mode 100644 index 0000000000000..39a3fda47a8e5 --- /dev/null +++ b/tests/mir-opt/copy-prop/copy_prop_borrowed_storage_not_removed.rs @@ -0,0 +1,30 @@ +// skip-filecheck +//@ test-mir-pass: CopyProp + +#![feature(custom_mir, core_intrinsics, freeze)] + +// Check that we remove the storage statements if one of the locals is borrowed, +// and the head isn't borrowed. + +use std::intrinsics::mir::*; +use std::marker::Freeze; + +// EMIT_MIR copy_prop_borrowed_storage_not_removed.f.CopyProp.diff + +#[custom_mir(dialect = "runtime")] +pub fn f(_1: (T, T)) -> T { + mir! { + let _2: T; + let _3: T; + let _4: &T; + { + StorageLive(_2); + _2 = _1.0; + _3 = _2; + _4 = &_3; + StorageDead(_2); + RET = *_4; + Return() + } + } +} diff --git a/tests/mir-opt/copy-prop/copy_prop_storage_twice.dead_twice.CopyProp.diff b/tests/mir-opt/copy-prop/copy_prop_storage_twice.dead_twice.CopyProp.diff new file mode 100644 index 0000000000000..0eb86de527219 --- /dev/null +++ b/tests/mir-opt/copy-prop/copy_prop_storage_twice.dead_twice.CopyProp.diff @@ -0,0 +1,28 @@ +- // MIR for `dead_twice` before CopyProp ++ // MIR for `dead_twice` after CopyProp + + fn dead_twice(_1: T) -> T { + let mut _0: T; + let mut _2: T; + let mut _3: T; + let mut _4: T; + + bb0: { +- StorageLive(_2); + _2 = opaque::(move _1) -> [return: bb1, unwind unreachable]; + } + + bb1: { +- _4 = move _2; +- StorageDead(_2); +- StorageLive(_2); +- _0 = opaque::(move _4) -> [return: bb2, unwind unreachable]; ++ _0 = opaque::(move _2) -> [return: bb2, unwind unreachable]; + } + + bb2: { +- StorageDead(_2); + return; + } + } + diff --git a/tests/mir-opt/copy-prop/copy_prop_storage_twice.live_twice.CopyProp.diff b/tests/mir-opt/copy-prop/copy_prop_storage_twice.live_twice.CopyProp.diff new file mode 100644 index 0000000000000..01b59b547eaa8 --- /dev/null +++ b/tests/mir-opt/copy-prop/copy_prop_storage_twice.live_twice.CopyProp.diff @@ -0,0 +1,27 @@ +- // MIR for `live_twice` before CopyProp ++ // MIR for `live_twice` after CopyProp + + fn live_twice(_1: T) -> T { + let mut _0: T; + let mut _2: T; + let mut _3: T; + let mut _4: T; + + bb0: { +- StorageLive(_2); + _2 = opaque::(move _1) -> [return: bb1, unwind unreachable]; + } + + bb1: { +- _4 = move _2; +- StorageLive(_2); +- _0 = opaque::(copy _4) -> [return: bb2, unwind unreachable]; ++ _0 = opaque::(copy _2) -> [return: bb2, unwind unreachable]; + } + + bb2: { +- StorageDead(_2); + return; + } + } + diff --git a/tests/mir-opt/copy-prop/copy_prop_storage_twice.rs b/tests/mir-opt/copy-prop/copy_prop_storage_twice.rs new file mode 100644 index 0000000000000..421bb55d62ecc --- /dev/null +++ b/tests/mir-opt/copy-prop/copy_prop_storage_twice.rs @@ -0,0 +1,61 @@ +// skip-filecheck +//@ test-mir-pass: CopyProp +//@ compile-flags: -Zlint-mir=false + +#![feature(custom_mir, core_intrinsics)] + +// Check that we remove the storage statements if the head +// becomes uninitialized before it is used again. + +use std::intrinsics::mir::*; + +// EMIT_MIR copy_prop_storage_twice.dead_twice.CopyProp.diff +// EMIT_MIR copy_prop_storage_twice.live_twice.CopyProp.diff + +#[custom_mir(dialect = "runtime")] +pub fn dead_twice(_1: T) -> T { + mir! { + let _2: T; + let _3: T; + { + StorageLive(_2); + Call(_2 = opaque(Move(_1)), ReturnTo(bb1), UnwindUnreachable()) + } + bb1 = { + let _3 = Move(_2); + StorageDead(_2); + StorageLive(_2); + Call(RET = opaque(Move(_3)), ReturnTo(bb2), UnwindUnreachable()) + } + bb2 = { + StorageDead(_2); + Return() + } + } +} + +#[custom_mir(dialect = "runtime")] +pub fn live_twice(_1: T) -> T { + mir! { + let _2: T; + let _3: T; + { + StorageLive(_2); + Call(_2 = opaque(Move(_1)), ReturnTo(bb1), UnwindUnreachable()) + } + bb1 = { + let _3 = Move(_2); + StorageLive(_2); + Call(RET = opaque(_3), ReturnTo(bb2), UnwindUnreachable()) + } + bb2 = { + StorageDead(_2); + Return() + } + } +} + +#[inline(never)] +fn opaque(a: T) -> T { + a +} diff --git a/tests/mir-opt/copy-prop/cycle.main.CopyProp.panic-abort.diff b/tests/mir-opt/copy-prop/cycle.main.CopyProp.panic-abort.diff index d133091e6a438..f11685467fd7d 100644 --- a/tests/mir-opt/copy-prop/cycle.main.CopyProp.panic-abort.diff +++ b/tests/mir-opt/copy-prop/cycle.main.CopyProp.panic-abort.diff @@ -26,7 +26,7 @@ } bb1: { -- StorageLive(_2); + StorageLive(_2); _2 = copy _1; - StorageLive(_3); - _3 = copy _2; @@ -46,7 +46,7 @@ StorageDead(_5); _0 = const (); - StorageDead(_3); -- StorageDead(_2); + StorageDead(_2); StorageDead(_1); return; } diff --git a/tests/mir-opt/copy-prop/cycle.main.CopyProp.panic-unwind.diff b/tests/mir-opt/copy-prop/cycle.main.CopyProp.panic-unwind.diff index bd4ad737cec13..bf5d8d20b7a10 100644 --- a/tests/mir-opt/copy-prop/cycle.main.CopyProp.panic-unwind.diff +++ b/tests/mir-opt/copy-prop/cycle.main.CopyProp.panic-unwind.diff @@ -26,7 +26,7 @@ } bb1: { -- StorageLive(_2); + StorageLive(_2); _2 = copy _1; - StorageLive(_3); - _3 = copy _2; @@ -46,7 +46,7 @@ StorageDead(_5); _0 = const (); - StorageDead(_3); -- StorageDead(_2); + StorageDead(_2); StorageDead(_1); return; } diff --git a/tests/mir-opt/copy-prop/dead_stores_79191.f.CopyProp.after.panic-abort.mir b/tests/mir-opt/copy-prop/dead_stores_79191.f.CopyProp.after.panic-abort.mir index 4781fdfd902a4..90bd2b8e07a8f 100644 --- a/tests/mir-opt/copy-prop/dead_stores_79191.f.CopyProp.after.panic-abort.mir +++ b/tests/mir-opt/copy-prop/dead_stores_79191.f.CopyProp.after.panic-abort.mir @@ -11,6 +11,7 @@ fn f(_1: usize) -> usize { } bb0: { + StorageLive(_2); _2 = copy _1; _1 = const 5_usize; _1 = copy _2; @@ -21,6 +22,7 @@ fn f(_1: usize) -> usize { bb1: { StorageDead(_4); + StorageDead(_2); return; } } diff --git a/tests/mir-opt/copy-prop/dead_stores_79191.f.CopyProp.after.panic-unwind.mir b/tests/mir-opt/copy-prop/dead_stores_79191.f.CopyProp.after.panic-unwind.mir index f5fded45c13b4..72b51f0b60a7b 100644 --- a/tests/mir-opt/copy-prop/dead_stores_79191.f.CopyProp.after.panic-unwind.mir +++ b/tests/mir-opt/copy-prop/dead_stores_79191.f.CopyProp.after.panic-unwind.mir @@ -11,6 +11,7 @@ fn f(_1: usize) -> usize { } bb0: { + StorageLive(_2); _2 = copy _1; _1 = const 5_usize; _1 = copy _2; @@ -21,6 +22,7 @@ fn f(_1: usize) -> usize { bb1: { StorageDead(_4); + StorageDead(_2); return; } } diff --git a/tests/mir-opt/copy-prop/dead_stores_better.f.CopyProp.after.panic-abort.mir b/tests/mir-opt/copy-prop/dead_stores_better.f.CopyProp.after.panic-abort.mir new file mode 100644 index 0000000000000..90bd2b8e07a8f --- /dev/null +++ b/tests/mir-opt/copy-prop/dead_stores_better.f.CopyProp.after.panic-abort.mir @@ -0,0 +1,28 @@ +// MIR for `f` after CopyProp + +fn f(_1: usize) -> usize { + debug a => _1; + let mut _0: usize; + let _2: usize; + let mut _3: usize; + let mut _4: usize; + scope 1 { + debug b => _2; + } + + bb0: { + StorageLive(_2); + _2 = copy _1; + _1 = const 5_usize; + _1 = copy _2; + StorageLive(_4); + _4 = copy _1; + _0 = id::(move _4) -> [return: bb1, unwind unreachable]; + } + + bb1: { + StorageDead(_4); + StorageDead(_2); + return; + } +} diff --git a/tests/mir-opt/copy-prop/dead_stores_better.f.CopyProp.after.panic-unwind.mir b/tests/mir-opt/copy-prop/dead_stores_better.f.CopyProp.after.panic-unwind.mir new file mode 100644 index 0000000000000..72b51f0b60a7b --- /dev/null +++ b/tests/mir-opt/copy-prop/dead_stores_better.f.CopyProp.after.panic-unwind.mir @@ -0,0 +1,28 @@ +// MIR for `f` after CopyProp + +fn f(_1: usize) -> usize { + debug a => _1; + let mut _0: usize; + let _2: usize; + let mut _3: usize; + let mut _4: usize; + scope 1 { + debug b => _2; + } + + bb0: { + StorageLive(_2); + _2 = copy _1; + _1 = const 5_usize; + _1 = copy _2; + StorageLive(_4); + _4 = copy _1; + _0 = id::(move _4) -> [return: bb1, unwind continue]; + } + + bb1: { + StorageDead(_4); + StorageDead(_2); + return; + } +} diff --git a/tests/mir-opt/copy-prop/issue_107511.main.CopyProp.panic-abort.diff b/tests/mir-opt/copy-prop/issue_107511.main.CopyProp.panic-abort.diff index 689083dfc1d3a..fb2aa9c055a64 100644 --- a/tests/mir-opt/copy-prop/issue_107511.main.CopyProp.panic-abort.diff +++ b/tests/mir-opt/copy-prop/issue_107511.main.CopyProp.panic-abort.diff @@ -86,7 +86,7 @@ } bb6: { -- StorageLive(_16); + StorageLive(_16); _16 = copy ((_11 as Some).0: usize); StorageLive(_17); - StorageLive(_18); @@ -116,7 +116,7 @@ StorageDead(_17); - StorageDead(_18); - _10 = const (); -- StorageDead(_16); + StorageDead(_16); StorageDead(_13); StorageDead(_11); - StorageDead(_10); diff --git a/tests/mir-opt/copy-prop/issue_107511.main.CopyProp.panic-unwind.diff b/tests/mir-opt/copy-prop/issue_107511.main.CopyProp.panic-unwind.diff index 7f768a9f834d9..df3a7793bfdd3 100644 --- a/tests/mir-opt/copy-prop/issue_107511.main.CopyProp.panic-unwind.diff +++ b/tests/mir-opt/copy-prop/issue_107511.main.CopyProp.panic-unwind.diff @@ -86,7 +86,7 @@ } bb6: { -- StorageLive(_16); + StorageLive(_16); _16 = copy ((_11 as Some).0: usize); StorageLive(_17); - StorageLive(_18); @@ -116,7 +116,7 @@ StorageDead(_17); - StorageDead(_18); - _10 = const (); -- StorageDead(_16); + StorageDead(_16); StorageDead(_13); StorageDead(_11); - StorageDead(_10); diff --git a/tests/mir-opt/copy-prop/issue_141649.main.CopyProp.panic-abort.diff b/tests/mir-opt/copy-prop/issue_141649.main.CopyProp.panic-abort.diff new file mode 100644 index 0000000000000..c68bfb1b8e94a --- /dev/null +++ b/tests/mir-opt/copy-prop/issue_141649.main.CopyProp.panic-abort.diff @@ -0,0 +1,142 @@ +- // MIR for `main` before CopyProp ++ // MIR for `main` after CopyProp + + fn main() -> () { + let mut _0: (); + let _1: (); + let _2: main::S; + let _3: (); + let mut _4: main::S; + let _5: (); + let _6: main::S; + let _7: (); + let mut _8: main::S; + let _9: (); + let _10: main::S; + let _12: &main::S; + let mut _13: &main::S; + let _14: (); + let mut _15: main::S; + let _16: (); + let _17: main::C; + let _18: (); + let mut _19: main::C; + let _20: main::C; + let _21: (); + let mut _22: main::C; + scope 1 { + debug s1 => _2; + } + scope 2 { + debug s2 => _6; + } + scope 3 { + debug s3 => _10; + let _11: &main::S; + scope 4 { + debug borrowed_s3 => _11; + } + } + scope 5 { + debug c1 => _17; + } + scope 6 { + debug c2 => _20; + } + + bb0: { +- StorageLive(_1); + StorageLive(_2); + _2 = S(const 1_usize, const 2_usize); + StorageLive(_3); +- StorageLive(_4); +- _4 = move _2; +- _3 = std::mem::drop::(move _4) -> [return: bb1, unwind unreachable]; ++ _3 = std::mem::drop::(move _2) -> [return: bb1, unwind unreachable]; + } + + bb1: { +- StorageDead(_4); + StorageDead(_3); +- _1 = const (); + StorageDead(_2); +- StorageDead(_1); +- StorageLive(_5); + StorageLive(_6); + _6 = S(const 3_usize, const 4_usize); + StorageLive(_7); +- StorageLive(_8); +- _8 = move _6; +- _7 = std::mem::drop::(move _8) -> [return: bb2, unwind unreachable]; ++ _7 = std::mem::drop::(move _6) -> [return: bb2, unwind unreachable]; + } + + bb2: { +- StorageDead(_8); + StorageDead(_7); +- _5 = const (); + StorageDead(_6); +- StorageDead(_5); +- StorageLive(_9); + StorageLive(_10); + _10 = S(const 5_usize, const 6_usize); + StorageLive(_11); + _11 = &_10; + StorageLive(_12); +- StorageLive(_13); +- _13 = copy _11; +- _12 = opaque::<&S>(move _13) -> [return: bb3, unwind unreachable]; ++ _12 = opaque::<&S>(copy _11) -> [return: bb3, unwind unreachable]; + } + + bb3: { +- StorageDead(_13); + StorageDead(_12); + StorageLive(_14); +- StorageLive(_15); +- _15 = move _10; +- _14 = std::mem::drop::(move _15) -> [return: bb4, unwind unreachable]; ++ _14 = std::mem::drop::(move _10) -> [return: bb4, unwind unreachable]; + } + + bb4: { +- StorageDead(_15); + StorageDead(_14); +- _9 = const (); + StorageDead(_11); + StorageDead(_10); +- StorageDead(_9); +- StorageLive(_16); + StorageLive(_17); + _17 = C(const 1_usize, const 2_usize); + StorageLive(_18); +- StorageLive(_19); +- _19 = copy _17; +- _18 = std::mem::drop::(move _19) -> [return: bb5, unwind unreachable]; ++ _18 = std::mem::drop::(copy _17) -> [return: bb5, unwind unreachable]; + } + + bb5: { +- StorageDead(_19); + StorageDead(_18); +- _16 = const (); + StorageDead(_17); +- StorageDead(_16); + StorageLive(_20); + _20 = C(const 3_usize, const 4_usize); + StorageLive(_21); +- StorageLive(_22); +- _22 = copy _20; +- _21 = std::mem::drop::(move _22) -> [return: bb6, unwind unreachable]; ++ _21 = std::mem::drop::(copy _20) -> [return: bb6, unwind unreachable]; + } + + bb6: { +- StorageDead(_22); + StorageDead(_21); + _0 = const (); + StorageDead(_20); + return; + } + } + diff --git a/tests/mir-opt/copy-prop/issue_141649.main.CopyProp.panic-unwind.diff b/tests/mir-opt/copy-prop/issue_141649.main.CopyProp.panic-unwind.diff index e02fe72a47a7b..3535a9840f685 100644 --- a/tests/mir-opt/copy-prop/issue_141649.main.CopyProp.panic-unwind.diff +++ b/tests/mir-opt/copy-prop/issue_141649.main.CopyProp.panic-unwind.diff @@ -12,12 +12,18 @@ let _7: (); let mut _8: main::S; let _9: (); - let _10: main::C; - let _11: (); - let mut _12: main::C; - let _13: main::C; + let _10: main::S; + let _12: &main::S; + let mut _13: &main::S; let _14: (); - let mut _15: main::C; + let mut _15: main::S; + let _16: (); + let _17: main::C; + let _18: (); + let mut _19: main::C; + let _20: main::C; + let _21: (); + let mut _22: main::C; scope 1 { debug s1 => _2; } @@ -25,15 +31,22 @@ debug s2 => _6; } scope 3 { - debug c1 => _10; + debug s3 => _10; + let _11: &main::S; + scope 4 { + debug borrowed_s3 => _11; + } } - scope 4 { - debug c2 => _13; + scope 5 { + debug c1 => _17; + } + scope 6 { + debug c2 => _20; } bb0: { - StorageLive(_1); -- StorageLive(_2); + StorageLive(_2); _2 = S(const 1_usize, const 2_usize); StorageLive(_3); - StorageLive(_4); @@ -46,10 +59,10 @@ - StorageDead(_4); StorageDead(_3); - _1 = const (); -- StorageDead(_2); + StorageDead(_2); - StorageDead(_1); - StorageLive(_5); -- StorageLive(_6); + StorageLive(_6); _6 = S(const 3_usize, const 4_usize); StorageLive(_7); - StorageLive(_8); @@ -62,38 +75,67 @@ - StorageDead(_8); StorageDead(_7); - _5 = const (); -- StorageDead(_6); + StorageDead(_6); - StorageDead(_5); - StorageLive(_9); -- StorageLive(_10); - _10 = C(const 1_usize, const 2_usize); + StorageLive(_10); + _10 = S(const 5_usize, const 6_usize); StorageLive(_11); -- StorageLive(_12); -- _12 = copy _10; -- _11 = std::mem::drop::(move _12) -> [return: bb3, unwind continue]; -+ _11 = std::mem::drop::(copy _10) -> [return: bb3, unwind continue]; + _11 = &_10; + StorageLive(_12); +- StorageLive(_13); +- _13 = copy _11; +- _12 = opaque::<&S>(move _13) -> [return: bb3, unwind continue]; ++ _12 = opaque::<&S>(copy _11) -> [return: bb3, unwind continue]; } bb3: { -- StorageDead(_12); - StorageDead(_11); -- _9 = const (); -- StorageDead(_10); -- StorageDead(_9); -- StorageLive(_13); - _13 = C(const 3_usize, const 4_usize); +- StorageDead(_13); + StorageDead(_12); StorageLive(_14); - StorageLive(_15); -- _15 = copy _13; -- _14 = std::mem::drop::(move _15) -> [return: bb4, unwind continue]; -+ _14 = std::mem::drop::(copy _13) -> [return: bb4, unwind continue]; +- _15 = move _10; +- _14 = std::mem::drop::(move _15) -> [return: bb4, unwind continue]; ++ _14 = std::mem::drop::(move _10) -> [return: bb4, unwind continue]; } bb4: { - StorageDead(_15); StorageDead(_14); +- _9 = const (); + StorageDead(_11); + StorageDead(_10); +- StorageDead(_9); +- StorageLive(_16); + StorageLive(_17); + _17 = C(const 1_usize, const 2_usize); + StorageLive(_18); +- StorageLive(_19); +- _19 = copy _17; +- _18 = std::mem::drop::(move _19) -> [return: bb5, unwind continue]; ++ _18 = std::mem::drop::(copy _17) -> [return: bb5, unwind continue]; + } + + bb5: { +- StorageDead(_19); + StorageDead(_18); +- _16 = const (); + StorageDead(_17); +- StorageDead(_16); + StorageLive(_20); + _20 = C(const 3_usize, const 4_usize); + StorageLive(_21); +- StorageLive(_22); +- _22 = copy _20; +- _21 = std::mem::drop::(move _22) -> [return: bb6, unwind continue]; ++ _21 = std::mem::drop::(copy _20) -> [return: bb6, unwind continue]; + } + + bb6: { +- StorageDead(_22); + StorageDead(_21); _0 = const (); -- StorageDead(_13); + StorageDead(_20); return; } } diff --git a/tests/mir-opt/copy-prop/issue_141649.rs b/tests/mir-opt/copy-prop/issue_141649.rs index 3227c47bcc72c..e3b9062d65101 100644 --- a/tests/mir-opt/copy-prop/issue_141649.rs +++ b/tests/mir-opt/copy-prop/issue_141649.rs @@ -13,6 +13,12 @@ fn main() { let s2 = S(3, 4); drop(s2); } + { + let s3 = S(5, 6); + let borrowed_s3 = &s3; + opaque(borrowed_s3); + drop(s3); + } #[derive(Clone, Copy)] struct C(usize, usize); @@ -25,3 +31,8 @@ fn main() { drop(c2); } } + +#[inline(never)] +fn opaque(a: T) -> T { + a +} diff --git a/tests/mir-opt/copy-prop/issue_141649_debug.main.CopyProp.panic-abort.diff b/tests/mir-opt/copy-prop/issue_141649_debug.main.CopyProp.panic-abort.diff new file mode 100644 index 0000000000000..93629b0f9f3f9 --- /dev/null +++ b/tests/mir-opt/copy-prop/issue_141649_debug.main.CopyProp.panic-abort.diff @@ -0,0 +1,100 @@ +- // MIR for `main` before CopyProp ++ // MIR for `main` after CopyProp + + fn main() -> () { + let mut _0: (); + let _1: (); + let _2: main::S; + let _3: (); + let mut _4: main::S; + let _5: (); + let _6: main::S; + let _7: (); + let mut _8: main::S; + let _9: (); + let _10: main::C; + let _11: (); + let mut _12: main::C; + let _13: main::C; + let _14: (); + let mut _15: main::C; + scope 1 { + debug s1 => _2; + } + scope 2 { + debug s2 => _6; + } + scope 3 { + debug c1 => _10; + } + scope 4 { + debug c2 => _13; + } + + bb0: { +- StorageLive(_1); +- StorageLive(_2); + _2 = S(const 1_usize, const 2_usize); + StorageLive(_3); +- StorageLive(_4); +- _4 = move _2; +- _3 = std::mem::drop::(move _4) -> [return: bb1, unwind unreachable]; ++ _3 = std::mem::drop::(move _2) -> [return: bb1, unwind unreachable]; + } + + bb1: { +- StorageDead(_4); + StorageDead(_3); +- _1 = const (); +- StorageDead(_2); +- StorageDead(_1); +- StorageLive(_5); +- StorageLive(_6); + _6 = S(const 3_usize, const 4_usize); + StorageLive(_7); +- StorageLive(_8); +- _8 = move _6; +- _7 = std::mem::drop::(move _8) -> [return: bb2, unwind unreachable]; ++ _7 = std::mem::drop::(move _6) -> [return: bb2, unwind unreachable]; + } + + bb2: { +- StorageDead(_8); + StorageDead(_7); +- _5 = const (); +- StorageDead(_6); +- StorageDead(_5); +- StorageLive(_9); +- StorageLive(_10); + _10 = C(const 1_usize, const 2_usize); + StorageLive(_11); +- StorageLive(_12); +- _12 = copy _10; +- _11 = std::mem::drop::(move _12) -> [return: bb3, unwind unreachable]; ++ _11 = std::mem::drop::(copy _10) -> [return: bb3, unwind unreachable]; + } + + bb3: { +- StorageDead(_12); + StorageDead(_11); +- _9 = const (); +- StorageDead(_10); +- StorageDead(_9); +- StorageLive(_13); + _13 = C(const 3_usize, const 4_usize); + StorageLive(_14); +- StorageLive(_15); +- _15 = copy _13; +- _14 = std::mem::drop::(move _15) -> [return: bb4, unwind unreachable]; ++ _14 = std::mem::drop::(copy _13) -> [return: bb4, unwind unreachable]; + } + + bb4: { +- StorageDead(_15); + StorageDead(_14); + _0 = const (); +- StorageDead(_13); + return; + } + } + diff --git a/tests/mir-opt/copy-prop/issue_141649_debug.main.CopyProp.panic-unwind.diff b/tests/mir-opt/copy-prop/issue_141649_debug.main.CopyProp.panic-unwind.diff new file mode 100644 index 0000000000000..e02fe72a47a7b --- /dev/null +++ b/tests/mir-opt/copy-prop/issue_141649_debug.main.CopyProp.panic-unwind.diff @@ -0,0 +1,100 @@ +- // MIR for `main` before CopyProp ++ // MIR for `main` after CopyProp + + fn main() -> () { + let mut _0: (); + let _1: (); + let _2: main::S; + let _3: (); + let mut _4: main::S; + let _5: (); + let _6: main::S; + let _7: (); + let mut _8: main::S; + let _9: (); + let _10: main::C; + let _11: (); + let mut _12: main::C; + let _13: main::C; + let _14: (); + let mut _15: main::C; + scope 1 { + debug s1 => _2; + } + scope 2 { + debug s2 => _6; + } + scope 3 { + debug c1 => _10; + } + scope 4 { + debug c2 => _13; + } + + bb0: { +- StorageLive(_1); +- StorageLive(_2); + _2 = S(const 1_usize, const 2_usize); + StorageLive(_3); +- StorageLive(_4); +- _4 = move _2; +- _3 = std::mem::drop::(move _4) -> [return: bb1, unwind continue]; ++ _3 = std::mem::drop::(move _2) -> [return: bb1, unwind continue]; + } + + bb1: { +- StorageDead(_4); + StorageDead(_3); +- _1 = const (); +- StorageDead(_2); +- StorageDead(_1); +- StorageLive(_5); +- StorageLive(_6); + _6 = S(const 3_usize, const 4_usize); + StorageLive(_7); +- StorageLive(_8); +- _8 = move _6; +- _7 = std::mem::drop::(move _8) -> [return: bb2, unwind continue]; ++ _7 = std::mem::drop::(move _6) -> [return: bb2, unwind continue]; + } + + bb2: { +- StorageDead(_8); + StorageDead(_7); +- _5 = const (); +- StorageDead(_6); +- StorageDead(_5); +- StorageLive(_9); +- StorageLive(_10); + _10 = C(const 1_usize, const 2_usize); + StorageLive(_11); +- StorageLive(_12); +- _12 = copy _10; +- _11 = std::mem::drop::(move _12) -> [return: bb3, unwind continue]; ++ _11 = std::mem::drop::(copy _10) -> [return: bb3, unwind continue]; + } + + bb3: { +- StorageDead(_12); + StorageDead(_11); +- _9 = const (); +- StorageDead(_10); +- StorageDead(_9); +- StorageLive(_13); + _13 = C(const 3_usize, const 4_usize); + StorageLive(_14); +- StorageLive(_15); +- _15 = copy _13; +- _14 = std::mem::drop::(move _15) -> [return: bb4, unwind continue]; ++ _14 = std::mem::drop::(copy _13) -> [return: bb4, unwind continue]; + } + + bb4: { +- StorageDead(_15); + StorageDead(_14); + _0 = const (); +- StorageDead(_13); + return; + } + } + diff --git a/tests/mir-opt/copy-prop/issue_141649_debug.rs b/tests/mir-opt/copy-prop/issue_141649_debug.rs new file mode 100644 index 0000000000000..5769118700ca1 --- /dev/null +++ b/tests/mir-opt/copy-prop/issue_141649_debug.rs @@ -0,0 +1,29 @@ +// skip-filecheck +// EMIT_MIR_FOR_EACH_PANIC_STRATEGY +//! Tests that in lower opt levels we remove (more) storage statements using a simpler strategy. +//@ test-mir-pass: CopyProp +//@ compile-flags: -Copt-level=0 + +// EMIT_MIR issue_141649_debug.main.CopyProp.diff +fn main() { + struct S(usize, usize); + { + let s1 = S(1, 2); + drop(s1); + } + { + let s2 = S(3, 4); + drop(s2); + } + + #[derive(Clone, Copy)] + struct C(usize, usize); + { + let c1 = C(1, 2); + drop(c1); + } + { + let c2 = C(3, 4); + drop(c2); + } +} diff --git a/tests/mir-opt/copy-prop/reborrow.demiraw.CopyProp.panic-abort.diff b/tests/mir-opt/copy-prop/reborrow.demiraw.CopyProp.panic-abort.diff index 676c5cee34387..ccd1e1caf003a 100644 --- a/tests/mir-opt/copy-prop/reborrow.demiraw.CopyProp.panic-abort.diff +++ b/tests/mir-opt/copy-prop/reborrow.demiraw.CopyProp.panic-abort.diff @@ -22,7 +22,7 @@ } bb0: { -- StorageLive(_2); + StorageLive(_2); _2 = &raw mut _1; StorageLive(_3); StorageLive(_4); @@ -44,7 +44,7 @@ _0 = const (); - StorageDead(_5); StorageDead(_3); -- StorageDead(_2); + StorageDead(_2); return; } } diff --git a/tests/mir-opt/copy-prop/reborrow.demiraw.CopyProp.panic-unwind.diff b/tests/mir-opt/copy-prop/reborrow.demiraw.CopyProp.panic-unwind.diff index ca2232ce54a1f..6cfb4af1fcf2e 100644 --- a/tests/mir-opt/copy-prop/reborrow.demiraw.CopyProp.panic-unwind.diff +++ b/tests/mir-opt/copy-prop/reborrow.demiraw.CopyProp.panic-unwind.diff @@ -22,7 +22,7 @@ } bb0: { -- StorageLive(_2); + StorageLive(_2); _2 = &raw mut _1; StorageLive(_3); StorageLive(_4); @@ -44,7 +44,7 @@ _0 = const (); - StorageDead(_5); StorageDead(_3); -- StorageDead(_2); + StorageDead(_2); return; } } diff --git a/tests/mir-opt/copy-prop/reborrow.miraw.CopyProp.panic-abort.diff b/tests/mir-opt/copy-prop/reborrow.miraw.CopyProp.panic-abort.diff index 1968696905fc7..b5f6a6e22f29f 100644 --- a/tests/mir-opt/copy-prop/reborrow.miraw.CopyProp.panic-abort.diff +++ b/tests/mir-opt/copy-prop/reborrow.miraw.CopyProp.panic-abort.diff @@ -21,7 +21,7 @@ } bb0: { -- StorageLive(_2); + StorageLive(_2); _2 = &raw mut _1; StorageLive(_3); _3 = &raw mut (*_2); @@ -40,7 +40,7 @@ _0 = const (); - StorageDead(_4); StorageDead(_3); -- StorageDead(_2); + StorageDead(_2); return; } } diff --git a/tests/mir-opt/copy-prop/reborrow.miraw.CopyProp.panic-unwind.diff b/tests/mir-opt/copy-prop/reborrow.miraw.CopyProp.panic-unwind.diff index 9a3c9665bc8f3..c28f7d037fd1d 100644 --- a/tests/mir-opt/copy-prop/reborrow.miraw.CopyProp.panic-unwind.diff +++ b/tests/mir-opt/copy-prop/reborrow.miraw.CopyProp.panic-unwind.diff @@ -21,7 +21,7 @@ } bb0: { -- StorageLive(_2); + StorageLive(_2); _2 = &raw mut _1; StorageLive(_3); _3 = &raw mut (*_2); @@ -40,7 +40,7 @@ _0 = const (); - StorageDead(_4); StorageDead(_3); -- StorageDead(_2); + StorageDead(_2); return; } } diff --git a/tests/mir-opt/copy-prop/reborrow.remut.CopyProp.panic-abort.diff b/tests/mir-opt/copy-prop/reborrow.remut.CopyProp.panic-abort.diff index 2026c1982f299..aebd98d85b54c 100644 --- a/tests/mir-opt/copy-prop/reborrow.remut.CopyProp.panic-abort.diff +++ b/tests/mir-opt/copy-prop/reborrow.remut.CopyProp.panic-abort.diff @@ -21,7 +21,7 @@ } bb0: { -- StorageLive(_2); + StorageLive(_2); _2 = &mut _1; StorageLive(_3); _3 = &mut (*_2); @@ -40,7 +40,7 @@ _0 = const (); - StorageDead(_4); StorageDead(_3); -- StorageDead(_2); + StorageDead(_2); return; } } diff --git a/tests/mir-opt/copy-prop/reborrow.remut.CopyProp.panic-unwind.diff b/tests/mir-opt/copy-prop/reborrow.remut.CopyProp.panic-unwind.diff index 67763fdce6676..a836d439c3eac 100644 --- a/tests/mir-opt/copy-prop/reborrow.remut.CopyProp.panic-unwind.diff +++ b/tests/mir-opt/copy-prop/reborrow.remut.CopyProp.panic-unwind.diff @@ -21,7 +21,7 @@ } bb0: { -- StorageLive(_2); + StorageLive(_2); _2 = &mut _1; StorageLive(_3); _3 = &mut (*_2); @@ -40,7 +40,7 @@ _0 = const (); - StorageDead(_4); StorageDead(_3); -- StorageDead(_2); + StorageDead(_2); return; } } diff --git a/tests/mir-opt/copy-prop/reborrow.reraw.CopyProp.panic-abort.diff b/tests/mir-opt/copy-prop/reborrow.reraw.CopyProp.panic-abort.diff index dfc8dd0975638..38801bc7811a8 100644 --- a/tests/mir-opt/copy-prop/reborrow.reraw.CopyProp.panic-abort.diff +++ b/tests/mir-opt/copy-prop/reborrow.reraw.CopyProp.panic-abort.diff @@ -21,7 +21,7 @@ } bb0: { -- StorageLive(_2); + StorageLive(_2); _2 = &mut _1; StorageLive(_3); _3 = &raw mut (*_2); @@ -40,7 +40,7 @@ _0 = const (); - StorageDead(_4); StorageDead(_3); -- StorageDead(_2); + StorageDead(_2); return; } } diff --git a/tests/mir-opt/copy-prop/reborrow.reraw.CopyProp.panic-unwind.diff b/tests/mir-opt/copy-prop/reborrow.reraw.CopyProp.panic-unwind.diff index becc425632104..f7af4681014b3 100644 --- a/tests/mir-opt/copy-prop/reborrow.reraw.CopyProp.panic-unwind.diff +++ b/tests/mir-opt/copy-prop/reborrow.reraw.CopyProp.panic-unwind.diff @@ -21,7 +21,7 @@ } bb0: { -- StorageLive(_2); + StorageLive(_2); _2 = &mut _1; StorageLive(_3); _3 = &raw mut (*_2); @@ -40,7 +40,7 @@ _0 = const (); - StorageDead(_4); StorageDead(_3); -- StorageDead(_2); + StorageDead(_2); return; } } diff --git a/tests/mir-opt/simplify_locals_fixedpoint.foo.SimplifyLocals-final.panic-abort.diff b/tests/mir-opt/simplify_locals_fixedpoint.foo.SimplifyLocals-final.panic-abort.diff index ff1bc58524bc2..c590c1aad4477 100644 --- a/tests/mir-opt/simplify_locals_fixedpoint.foo.SimplifyLocals-final.panic-abort.diff +++ b/tests/mir-opt/simplify_locals_fixedpoint.foo.SimplifyLocals-final.panic-abort.diff @@ -35,7 +35,9 @@ } bb2: { + StorageLive(_6); _6 = copy (((_1.0: std::option::Option) as Some).0: u8); + StorageDead(_6); goto -> bb3; } diff --git a/tests/mir-opt/simplify_locals_fixedpoint.foo.SimplifyLocals-final.panic-unwind.diff b/tests/mir-opt/simplify_locals_fixedpoint.foo.SimplifyLocals-final.panic-unwind.diff index 2c289c664754a..9dd0195c86c97 100644 --- a/tests/mir-opt/simplify_locals_fixedpoint.foo.SimplifyLocals-final.panic-unwind.diff +++ b/tests/mir-opt/simplify_locals_fixedpoint.foo.SimplifyLocals-final.panic-unwind.diff @@ -35,7 +35,9 @@ } bb2: { + StorageLive(_6); _6 = copy (((_1.0: std::option::Option) as Some).0: u8); + StorageDead(_6); goto -> bb3; } From da07f362267a6254b0ef58a1f3ee805a26fc4f37 Mon Sep 17 00:00:00 2001 From: Ohad Ravid Date: Tue, 3 Jun 2025 08:28:17 +0300 Subject: [PATCH 03/25] Added gvn test for removed local storage annotations --- ...n_storage_remove.main.GVN.panic-abort.diff | 132 ++++++++++++++++++ ..._storage_remove.main.GVN.panic-unwind.diff | 132 ++++++++++++++++++ .../issue_141649_gvn_storage_remove.rs | 27 ++++ 3 files changed, 291 insertions(+) create mode 100644 tests/mir-opt/issue_141649_gvn_storage_remove.main.GVN.panic-abort.diff create mode 100644 tests/mir-opt/issue_141649_gvn_storage_remove.main.GVN.panic-unwind.diff create mode 100644 tests/mir-opt/issue_141649_gvn_storage_remove.rs diff --git a/tests/mir-opt/issue_141649_gvn_storage_remove.main.GVN.panic-abort.diff b/tests/mir-opt/issue_141649_gvn_storage_remove.main.GVN.panic-abort.diff new file mode 100644 index 0000000000000..5e19645ed5b7d --- /dev/null +++ b/tests/mir-opt/issue_141649_gvn_storage_remove.main.GVN.panic-abort.diff @@ -0,0 +1,132 @@ +- // MIR for `main` before GVN ++ // MIR for `main` after GVN + + fn main() -> () { + let mut _0: (); + let _1: (); + let _2: main::S; + let _3: (); + let mut _4: main::S; + let _5: (); + let _6: main::S; + let _7: (); + let mut _8: main::S; + let _9: (); + let _10: main::C; + let _11: (); + let mut _12: main::C; + let _13: main::C; + let _14: (); + let mut _15: main::C; + scope 1 { + debug s1 => _2; + } + scope 2 { + debug s2 => _6; + } + scope 3 { + debug c1 => _10; + } + scope 4 { + debug c2 => _13; + } + + bb0: { + StorageLive(_1); +- StorageLive(_2); +- _2 = S(const 1_u32, const 2_u32); ++ nop; ++ _2 = const S(1_u32, 2_u32); + StorageLive(_3); + StorageLive(_4); +- _4 = move _2; +- _3 = std::mem::drop::(move _4) -> [return: bb1, unwind unreachable]; ++ _4 = const S(1_u32, 2_u32); ++ _3 = std::mem::drop::(const S(1_u32, 2_u32)) -> [return: bb1, unwind unreachable]; + } + + bb1: { + StorageDead(_4); + StorageDead(_3); + _1 = const (); +- StorageDead(_2); ++ nop; + StorageDead(_1); + StorageLive(_5); +- StorageLive(_6); +- _6 = S(const 3_u32, const 4_u32); ++ nop; ++ _6 = const S(3_u32, 4_u32); + StorageLive(_7); + StorageLive(_8); +- _8 = move _6; +- _7 = std::mem::drop::(move _8) -> [return: bb2, unwind unreachable]; ++ _8 = const S(3_u32, 4_u32); ++ _7 = std::mem::drop::(const S(3_u32, 4_u32)) -> [return: bb2, unwind unreachable]; + } + + bb2: { + StorageDead(_8); + StorageDead(_7); + _5 = const (); +- StorageDead(_6); ++ nop; + StorageDead(_5); + StorageLive(_9); +- StorageLive(_10); +- _10 = C(const 1_u32, const 2_u32); ++ nop; ++ _10 = const C(1_u32, 2_u32); + StorageLive(_11); + StorageLive(_12); +- _12 = copy _10; +- _11 = std::mem::drop::(move _12) -> [return: bb3, unwind unreachable]; ++ _12 = const C(1_u32, 2_u32); ++ _11 = std::mem::drop::(const C(1_u32, 2_u32)) -> [return: bb3, unwind unreachable]; + } + + bb3: { + StorageDead(_12); + StorageDead(_11); + _9 = const (); +- StorageDead(_10); ++ nop; + StorageDead(_9); +- StorageLive(_13); +- _13 = C(const 3_u32, const 4_u32); ++ nop; ++ _13 = const C(3_u32, 4_u32); + StorageLive(_14); + StorageLive(_15); +- _15 = copy _13; +- _14 = std::mem::drop::(move _15) -> [return: bb4, unwind unreachable]; ++ _15 = const C(3_u32, 4_u32); ++ _14 = std::mem::drop::(const C(3_u32, 4_u32)) -> [return: bb4, unwind unreachable]; + } + + bb4: { + StorageDead(_15); + StorageDead(_14); + _0 = const (); +- StorageDead(_13); ++ nop; + return; + } ++ } ++ ++ ALLOC0 (size: 8, align: 4) { ++ 03 00 00 00 04 00 00 00 │ ........ ++ } ++ ++ ALLOC1 (size: 8, align: 4) { ++ 01 00 00 00 02 00 00 00 │ ........ ++ } ++ ++ ALLOC2 (size: 8, align: 4) { ++ 03 00 00 00 04 00 00 00 │ ........ ++ } ++ ++ ALLOC3 (size: 8, align: 4) { ++ 01 00 00 00 02 00 00 00 │ ........ + } + diff --git a/tests/mir-opt/issue_141649_gvn_storage_remove.main.GVN.panic-unwind.diff b/tests/mir-opt/issue_141649_gvn_storage_remove.main.GVN.panic-unwind.diff new file mode 100644 index 0000000000000..8f60f2f63e0f6 --- /dev/null +++ b/tests/mir-opt/issue_141649_gvn_storage_remove.main.GVN.panic-unwind.diff @@ -0,0 +1,132 @@ +- // MIR for `main` before GVN ++ // MIR for `main` after GVN + + fn main() -> () { + let mut _0: (); + let _1: (); + let _2: main::S; + let _3: (); + let mut _4: main::S; + let _5: (); + let _6: main::S; + let _7: (); + let mut _8: main::S; + let _9: (); + let _10: main::C; + let _11: (); + let mut _12: main::C; + let _13: main::C; + let _14: (); + let mut _15: main::C; + scope 1 { + debug s1 => _2; + } + scope 2 { + debug s2 => _6; + } + scope 3 { + debug c1 => _10; + } + scope 4 { + debug c2 => _13; + } + + bb0: { + StorageLive(_1); +- StorageLive(_2); +- _2 = S(const 1_u32, const 2_u32); ++ nop; ++ _2 = const S(1_u32, 2_u32); + StorageLive(_3); + StorageLive(_4); +- _4 = move _2; +- _3 = std::mem::drop::(move _4) -> [return: bb1, unwind continue]; ++ _4 = const S(1_u32, 2_u32); ++ _3 = std::mem::drop::(const S(1_u32, 2_u32)) -> [return: bb1, unwind continue]; + } + + bb1: { + StorageDead(_4); + StorageDead(_3); + _1 = const (); +- StorageDead(_2); ++ nop; + StorageDead(_1); + StorageLive(_5); +- StorageLive(_6); +- _6 = S(const 3_u32, const 4_u32); ++ nop; ++ _6 = const S(3_u32, 4_u32); + StorageLive(_7); + StorageLive(_8); +- _8 = move _6; +- _7 = std::mem::drop::(move _8) -> [return: bb2, unwind continue]; ++ _8 = const S(3_u32, 4_u32); ++ _7 = std::mem::drop::(const S(3_u32, 4_u32)) -> [return: bb2, unwind continue]; + } + + bb2: { + StorageDead(_8); + StorageDead(_7); + _5 = const (); +- StorageDead(_6); ++ nop; + StorageDead(_5); + StorageLive(_9); +- StorageLive(_10); +- _10 = C(const 1_u32, const 2_u32); ++ nop; ++ _10 = const C(1_u32, 2_u32); + StorageLive(_11); + StorageLive(_12); +- _12 = copy _10; +- _11 = std::mem::drop::(move _12) -> [return: bb3, unwind continue]; ++ _12 = const C(1_u32, 2_u32); ++ _11 = std::mem::drop::(const C(1_u32, 2_u32)) -> [return: bb3, unwind continue]; + } + + bb3: { + StorageDead(_12); + StorageDead(_11); + _9 = const (); +- StorageDead(_10); ++ nop; + StorageDead(_9); +- StorageLive(_13); +- _13 = C(const 3_u32, const 4_u32); ++ nop; ++ _13 = const C(3_u32, 4_u32); + StorageLive(_14); + StorageLive(_15); +- _15 = copy _13; +- _14 = std::mem::drop::(move _15) -> [return: bb4, unwind continue]; ++ _15 = const C(3_u32, 4_u32); ++ _14 = std::mem::drop::(const C(3_u32, 4_u32)) -> [return: bb4, unwind continue]; + } + + bb4: { + StorageDead(_15); + StorageDead(_14); + _0 = const (); +- StorageDead(_13); ++ nop; + return; + } ++ } ++ ++ ALLOC0 (size: 8, align: 4) { ++ 03 00 00 00 04 00 00 00 │ ........ ++ } ++ ++ ALLOC1 (size: 8, align: 4) { ++ 01 00 00 00 02 00 00 00 │ ........ ++ } ++ ++ ALLOC2 (size: 8, align: 4) { ++ 03 00 00 00 04 00 00 00 │ ........ ++ } ++ ++ ALLOC3 (size: 8, align: 4) { ++ 01 00 00 00 02 00 00 00 │ ........ + } + diff --git a/tests/mir-opt/issue_141649_gvn_storage_remove.rs b/tests/mir-opt/issue_141649_gvn_storage_remove.rs new file mode 100644 index 0000000000000..eb2b5337d0c41 --- /dev/null +++ b/tests/mir-opt/issue_141649_gvn_storage_remove.rs @@ -0,0 +1,27 @@ +// skip-filecheck +// EMIT_MIR_FOR_EACH_PANIC_STRATEGY +//@ test-mir-pass: GVN + +// EMIT_MIR issue_141649_gvn_storage_remove.main.GVN.diff +fn main() { + struct S(u32, u32); + { + let s1 = S(1, 2); + drop(s1); + } + { + let s2 = S(3, 4); + drop(s2); + } + + #[derive(Clone, Copy)] + struct C(u32, u32); + { + let c1 = C(1, 2); + drop(c1); + } + { + let c2 = C(3, 4); + drop(c2); + } +} From 1317dcc26811b6bcb0f91d6923261935958c87b3 Mon Sep 17 00:00:00 2001 From: Ohad Ravid Date: Sat, 14 Jun 2025 22:38:21 +0300 Subject: [PATCH 04/25] Use `MaybeUninitializedLocals` analysis in GVN mir-opt to remove fewer storage statements --- compiler/rustc_mir_transform/src/gvn.rs | 71 +++- .../const_debuginfo.main.SingleUseConsts.diff | 20 +- .../aggregate.main.GVN.panic-abort.diff | 6 +- .../aggregate.main.GVN.panic-unwind.diff | 6 +- ...d_op_div_by_zero.main.GVN.panic-abort.diff | 6 +- ..._op_div_by_zero.main.GVN.panic-unwind.diff | 6 +- ...d_op_mod_by_zero.main.GVN.panic-abort.diff | 6 +- ..._op_mod_by_zero.main.GVN.panic-unwind.diff | 6 +- .../boolean_identities.test.GVN.diff | 12 +- .../boxes.main.GVN.panic-abort.diff | 6 +- .../boxes.main.GVN.panic-unwind.diff | 6 +- ...le_unprop_assign.main.GVN.panic-abort.diff | 6 +- ...e_unprop_assign.main.GVN.panic-unwind.diff | 6 +- ...xpose_provenance.main.GVN.panic-abort.diff | 6 +- ...pose_provenance.main.GVN.panic-unwind.diff | 6 +- .../read_immutable_static.main.GVN.diff | 12 +- ...eral_propagation.main.GVN.panic-abort.diff | 6 +- ...ral_propagation.main.GVN.panic-unwind.diff | 6 +- ...eral_propagation.main.GVN.panic-abort.diff | 6 +- ...ral_propagation.main.GVN.panic-unwind.diff | 6 +- ...ng_operand.test.GVN.32bit.panic-abort.diff | 194 +++++------ ...g_operand.test.GVN.32bit.panic-unwind.diff | 89 +++-- ...ng_operand.test.GVN.64bit.panic-abort.diff | 194 +++++------ ...g_operand.test.GVN.64bit.panic-unwind.diff | 89 +++-- ...onential_common.GVN.32bit.panic-abort.diff | 6 +- ...nential_common.GVN.32bit.panic-unwind.diff | 6 +- ...onential_common.GVN.64bit.panic-abort.diff | 6 +- ...nential_common.GVN.64bit.panic-unwind.diff | 6 +- ...struct_then_transmute.GVN.panic-abort.diff | 48 +-- ...truct_then_transmute.GVN.panic-unwind.diff | 48 +-- .../gvn.arithmetic.GVN.panic-abort.diff | 6 +- .../gvn.arithmetic.GVN.panic-unwind.diff | 6 +- ...vn.arithmetic_checked.GVN.panic-abort.diff | 6 +- ...n.arithmetic_checked.GVN.panic-unwind.diff | 6 +- tests/mir-opt/gvn.cast.GVN.panic-abort.diff | 18 +- tests/mir-opt/gvn.cast.GVN.panic-unwind.diff | 18 +- .../gvn.cast_pointer_eq.GVN.panic-abort.diff | 12 +- .../gvn.cast_pointer_eq.GVN.panic-unwind.diff | 12 +- ...ore_aggregate_raw_ptr.GVN.panic-abort.diff | 18 +- ...re_aggregate_raw_ptr.GVN.panic-unwind.diff | 18 +- ...nstant_index_overflow.GVN.panic-abort.diff | 6 +- ...stant_index_overflow.GVN.panic-unwind.diff | 6 +- .../gvn.fn_pointers.GVN.panic-abort.diff | 48 ++- .../gvn.fn_pointers.GVN.panic-unwind.diff | 48 ++- ....manual_slice_mut_len.GVN.panic-abort.diff | 12 +- ...manual_slice_mut_len.GVN.panic-unwind.diff | 12 +- ....meta_of_ref_to_slice.GVN.panic-abort.diff | 6 +- ...meta_of_ref_to_slice.GVN.panic-unwind.diff | 6 +- .../gvn.references.GVN.panic-abort.diff | 6 +- .../gvn.references.GVN.panic-unwind.diff | 6 +- tests/mir-opt/gvn.repeat.GVN.panic-abort.diff | 6 +- .../mir-opt/gvn.repeat.GVN.panic-unwind.diff | 6 +- ...vn.slice_const_length.GVN.panic-abort.diff | 12 +- ...n.slice_const_length.GVN.panic-unwind.diff | 12 +- ...from_raw_parts_as_ptr.GVN.panic-abort.diff | 6 +- ...rom_raw_parts_as_ptr.GVN.panic-unwind.diff | 6 +- tests/mir-opt/gvn.slices.GVN.panic-abort.diff | 42 +-- .../mir-opt/gvn.slices.GVN.panic-unwind.diff | 42 +-- ...ute_then_cast_pointer.GVN.panic-abort.diff | 18 +- ...te_then_cast_pointer.GVN.panic-unwind.diff | 18 +- ..._then_transmute_again.GVN.panic-abort.diff | 12 +- ...then_transmute_again.GVN.panic-unwind.diff | 12 +- tests/mir-opt/gvn.unary.GVN.panic-abort.diff | 6 +- tests/mir-opt/gvn.unary.GVN.panic-unwind.diff | 6 +- .../gvn.wide_ptr_integer.GVN.panic-abort.diff | 12 +- ...gvn.wide_ptr_integer.GVN.panic-unwind.diff | 12 +- .../mir-opt/gvn_clone.{impl#0}-clone.GVN.diff | 18 +- .../gvn_copy_aggregate.all_copy.GVN.diff | 18 +- .../gvn_copy_aggregate.all_copy_2.GVN.diff | 27 +- ...aggregate.all_copy_different_type.GVN.diff | 18 +- ...py_aggregate.all_copy_has_changed.GVN.diff | 18 +- .../gvn_copy_aggregate.all_copy_move.GVN.diff | 18 +- ...gvn_copy_aggregate.all_copy_ret_2.GVN.diff | 24 +- ...py_aggregate.all_copy_use_changed.GVN.diff | 12 +- ..._aggregate.all_copy_use_changed_2.GVN.diff | 12 +- ..._aggregate.enum_different_variant.GVN.diff | 56 ++-- ..._aggregate.enum_identical_variant.GVN.diff | 56 ++-- .../gvn_copy_aggregate.nest_copy.GVN.diff | 30 +- ...gregate.same_type_different_index.GVN.diff | 12 +- ...ompare_constant_index.GVN.panic-abort.diff | 6 +- ...mpare_constant_index.GVN.panic-unwind.diff | 6 +- .../gvn_on_unsafe_binder.propagate.GVN.diff | 6 +- .../gvn_storage_twice.repeat_local.GVN.diff | 17 + ...n_storage_twice.repeat_local_dead.GVN.diff | 19 ++ ...rage_twice.repeat_local_dead_live.GVN.diff | 21 ++ tests/mir-opt/gvn_storage_twice.rs | 65 ++++ ...inline_diverging.h.Inline.panic-abort.diff | 1 - ...nline_diverging.h.Inline.panic-unwind.diff | 1 - ...n_storage_remove.main.GVN.panic-abort.diff | 24 +- ..._storage_remove.main.GVN.panic-unwind.diff | 24 +- ...implifyComparisonIntegral.panic-abort.diff | 38 ++- ...mplifyComparisonIntegral.panic-unwind.diff | 38 ++- ...e_75439.foo.MatchBranchSimplification.diff | 2 + ...array_len.array_bound.GVN.panic-abort.diff | 6 +- ...rray_len.array_bound.GVN.panic-unwind.diff | 6 +- ...y_len.array_bound_mut.GVN.panic-abort.diff | 6 +- ..._len.array_bound_mut.GVN.panic-unwind.diff | 6 +- ...ecked_sub.PreCodegen.after.panic-abort.mir | 14 +- ...cked_sub.PreCodegen.after.panic-unwind.mir | 14 +- ...ef_nested_borrows.src.GVN.panic-abort.diff | 12 +- ...f_nested_borrows.src.GVN.panic-unwind.diff | 12 +- ...rrows.src.PreCodegen.after.panic-abort.mir | 2 + ...rows.src.PreCodegen.after.panic-unwind.mir | 2 + .../derived_ord.demo_le.PreCodegen.after.mir | 35 +- ....{impl#0}-partial_cmp.PreCodegen.after.mir | 2 + ...d_constant.main.GVN.32bit.panic-abort.diff | 6 +- ..._constant.main.GVN.32bit.panic-unwind.diff | 6 +- ...d_constant.main.GVN.64bit.panic-abort.diff | 6 +- ..._constant.main.GVN.64bit.panic-unwind.diff | 6 +- .../loops.filter_mapped.PreCodegen.after.mir | 46 +-- .../loops.int_range.PreCodegen.after.mir | 99 +++--- .../loops.mapped.PreCodegen.after.mir | 86 ++--- .../loops.vec_move.PreCodegen.after.mir | 305 ++---------------- ...ward_loop.PreCodegen.after.panic-abort.mir | 68 ++-- ...ard_loop.PreCodegen.after.panic-unwind.mir | 68 ++-- ...sive_loop.PreCodegen.after.panic-abort.mir | 5 + ...ive_loop.PreCodegen.after.panic-unwind.mir | 5 + ...iter_next.PreCodegen.after.panic-abort.mir | 2 + ...ter_next.PreCodegen.after.panic-unwind.mir | 2 + ...mple_option_map.ezmap.PreCodegen.after.mir | 2 + ...variant_b-{closure#0}.PreCodegen.after.mir | 8 + ...mut_range.PreCodegen.after.panic-abort.mir | 4 + ...ut_range.PreCodegen.after.panic-unwind.mir | 4 + ...ked_range.PreCodegen.after.panic-abort.mir | 4 + ...ed_range.PreCodegen.after.panic-unwind.mir | 4 + .../try_identity.new.PreCodegen.after.mir | 6 + .../try_identity.old.PreCodegen.after.mir | 4 + ...e_const_switch.identity.JumpThreading.diff | 4 + ...onst_switch.too_complex.JumpThreading.diff | 6 + ..._aggregate_to_copy_miscompile.foo.GVN.diff | 6 +- .../simplify_match.main.GVN.panic-abort.diff | 8 +- .../simplify_match.main.GVN.panic-unwind.diff | 8 +- 132 files changed, 1232 insertions(+), 1651 deletions(-) create mode 100644 tests/mir-opt/gvn_storage_twice.repeat_local.GVN.diff create mode 100644 tests/mir-opt/gvn_storage_twice.repeat_local_dead.GVN.diff create mode 100644 tests/mir-opt/gvn_storage_twice.repeat_local_dead_live.GVN.diff create mode 100644 tests/mir-opt/gvn_storage_twice.rs diff --git a/compiler/rustc_mir_transform/src/gvn.rs b/compiler/rustc_mir_transform/src/gvn.rs index a20e04371b987..5cb35610477dd 100644 --- a/compiler/rustc_mir_transform/src/gvn.rs +++ b/compiler/rustc_mir_transform/src/gvn.rs @@ -108,6 +108,8 @@ use rustc_middle::mir::visit::*; use rustc_middle::mir::*; use rustc_middle::ty::layout::HasTypingEnv; use rustc_middle::ty::{self, Ty, TyCtxt}; +use rustc_mir_dataflow::impls::MaybeUninitializedLocals; +use rustc_mir_dataflow::{Analysis, ResultsCursor}; use rustc_span::DUMMY_SP; use smallvec::SmallVec; use tracing::{debug, instrument, trace}; @@ -151,10 +153,31 @@ impl<'tcx> crate::MirPass<'tcx> for GVN { state.visit_basic_block_data(bb, data); } - // For each local that is reused (`y` above), we remove its storage statements do avoid any - // difficulty. Those locals are SSA, so should be easy to optimize by LLVM without storage - // statements. - StorageRemover { tcx, reused_locals: state.reused_locals }.visit_body_preserves_cfg(body); + // If we emit storage annotations, use `MaybeStorageDead` to check which reused locals + // require storage removal (making them alive for the duration of the function). + let storage_to_remove = if tcx.sess.emit_lifetime_markers() { + let maybe_uninit = MaybeUninitializedLocals::new() + .iterate_to_fixpoint(tcx, body, Some("mir_opt::gvn")) + .into_results_cursor(body); + + let mut storage_checker = StorageChecker { + storage_to_check: state.reused_locals.clone(), + storage_to_remove: DenseBitSet::new_empty(body.local_decls.len()), + maybe_uninit, + }; + + storage_checker.visit_body(body); + + storage_checker.storage_to_remove + } else { + // Conservatively remove all storage statements for reused locals. + state.reused_locals.clone() + }; + + debug!(?storage_to_remove); + + StorageRemover { tcx, reused_locals: state.reused_locals, storage_to_remove } + .visit_body_preserves_cfg(body); } fn is_required(&self) -> bool { @@ -1931,6 +1954,7 @@ impl<'tcx> MutVisitor<'tcx> for VnState<'_, '_, 'tcx> { struct StorageRemover<'tcx> { tcx: TyCtxt<'tcx>, reused_locals: DenseBitSet, + storage_to_remove: DenseBitSet, } impl<'tcx> MutVisitor<'tcx> for StorageRemover<'tcx> { @@ -1951,7 +1975,7 @@ impl<'tcx> MutVisitor<'tcx> for StorageRemover<'tcx> { match stmt.kind { // When removing storage statements, we need to remove both (#107511). StatementKind::StorageLive(l) | StatementKind::StorageDead(l) - if self.reused_locals.contains(l) => + if self.storage_to_remove.contains(l) => { stmt.make_nop(true) } @@ -1959,3 +1983,40 @@ impl<'tcx> MutVisitor<'tcx> for StorageRemover<'tcx> { } } } + +struct StorageChecker<'a, 'tcx> { + storage_to_check: DenseBitSet, + storage_to_remove: DenseBitSet, + maybe_uninit: ResultsCursor<'a, 'tcx, MaybeUninitializedLocals>, +} + +impl<'a, 'tcx> Visitor<'tcx> for StorageChecker<'a, 'tcx> { + fn visit_local(&mut self, local: Local, context: PlaceContext, location: Location) { + match context { + // These mutating uses do not require the local to be initialized. + PlaceContext::MutatingUse(MutatingUseContext::AsmOutput) + | PlaceContext::MutatingUse(MutatingUseContext::Call) + | PlaceContext::MutatingUse(MutatingUseContext::Store) + | PlaceContext::MutatingUse(MutatingUseContext::Yield) + | PlaceContext::NonUse(_) => { + return; + } + // Must check validity for other mutating usages and all non-mutating uses. + PlaceContext::MutatingUse(_) | PlaceContext::NonMutatingUse(_) => {} + } + + if self.storage_to_check.contains(local) { + self.maybe_uninit.seek_before_primary_effect(location); + + if self.maybe_uninit.get().contains(local) { + debug!( + ?location, + ?local, + "local is maybe uninit in this location, removing storage" + ); + self.storage_to_remove.insert(local); + self.storage_to_check.remove(local); + } + } + } +} diff --git a/tests/mir-opt/const_debuginfo.main.SingleUseConsts.diff b/tests/mir-opt/const_debuginfo.main.SingleUseConsts.diff index 9baf8439e59f5..03e077b1528c7 100644 --- a/tests/mir-opt/const_debuginfo.main.SingleUseConsts.diff +++ b/tests/mir-opt/const_debuginfo.main.SingleUseConsts.diff @@ -55,14 +55,14 @@ } bb0: { - nop; + StorageLive(_1); - _1 = const 1_u8; - nop; -- _2 = const 2_u8; - nop; -- _3 = const 3_u8; + nop; + StorageLive(_2); +- _2 = const 2_u8; + nop; + StorageLive(_3); +- _3 = const 3_u8; + nop; StorageLive(_4); StorageLive(_5); @@ -95,7 +95,7 @@ - _12 = const Point {{ x: 32_u32, y: 32_u32 }}; + nop; StorageLive(_13); - nop; + StorageLive(_14); - _14 = const 32_u32; + nop; StorageLive(_15); @@ -104,7 +104,7 @@ + nop; + nop; StorageDead(_15); - nop; + StorageDead(_14); _0 = const (); StorageDead(_13); StorageDead(_12); @@ -112,9 +112,9 @@ StorageDead(_10); StorageDead(_9); StorageDead(_4); - nop; - nop; - nop; + StorageDead(_3); + StorageDead(_2); + StorageDead(_1); return; } } diff --git a/tests/mir-opt/const_prop/aggregate.main.GVN.panic-abort.diff b/tests/mir-opt/const_prop/aggregate.main.GVN.panic-abort.diff index 0a59c59c2ed2c..3371c19360f92 100644 --- a/tests/mir-opt/const_prop/aggregate.main.GVN.panic-abort.diff +++ b/tests/mir-opt/const_prop/aggregate.main.GVN.panic-abort.diff @@ -13,8 +13,7 @@ } bb0: { -- StorageLive(_1); -+ nop; + StorageLive(_1); StorageLive(_2); StorageLive(_3); _3 = (const 0_i32, const 1_u8, const 2_i32); @@ -36,8 +35,7 @@ StorageDead(_5); StorageDead(_4); _0 = const (); -- StorageDead(_1); -+ nop; + StorageDead(_1); return; } } diff --git a/tests/mir-opt/const_prop/aggregate.main.GVN.panic-unwind.diff b/tests/mir-opt/const_prop/aggregate.main.GVN.panic-unwind.diff index 100369a2eee31..a0f9e7a117996 100644 --- a/tests/mir-opt/const_prop/aggregate.main.GVN.panic-unwind.diff +++ b/tests/mir-opt/const_prop/aggregate.main.GVN.panic-unwind.diff @@ -13,8 +13,7 @@ } bb0: { -- StorageLive(_1); -+ nop; + StorageLive(_1); StorageLive(_2); StorageLive(_3); _3 = (const 0_i32, const 1_u8, const 2_i32); @@ -36,8 +35,7 @@ StorageDead(_5); StorageDead(_4); _0 = const (); -- StorageDead(_1); -+ nop; + StorageDead(_1); return; } } diff --git a/tests/mir-opt/const_prop/bad_op_div_by_zero.main.GVN.panic-abort.diff b/tests/mir-opt/const_prop/bad_op_div_by_zero.main.GVN.panic-abort.diff index 8c535b567c328..d6551b8e3e741 100644 --- a/tests/mir-opt/const_prop/bad_op_div_by_zero.main.GVN.panic-abort.diff +++ b/tests/mir-opt/const_prop/bad_op_div_by_zero.main.GVN.panic-abort.diff @@ -18,8 +18,7 @@ } bb0: { -- StorageLive(_1); -+ nop; + StorageLive(_1); _1 = const 0_i32; StorageLive(_2); StorageLive(_3); @@ -48,8 +47,7 @@ StorageDead(_3); _0 = const (); StorageDead(_2); -- StorageDead(_1); -+ nop; + StorageDead(_1); return; } } diff --git a/tests/mir-opt/const_prop/bad_op_div_by_zero.main.GVN.panic-unwind.diff b/tests/mir-opt/const_prop/bad_op_div_by_zero.main.GVN.panic-unwind.diff index 045f4d81db62e..3dbd6ca6769cb 100644 --- a/tests/mir-opt/const_prop/bad_op_div_by_zero.main.GVN.panic-unwind.diff +++ b/tests/mir-opt/const_prop/bad_op_div_by_zero.main.GVN.panic-unwind.diff @@ -18,8 +18,7 @@ } bb0: { -- StorageLive(_1); -+ nop; + StorageLive(_1); _1 = const 0_i32; StorageLive(_2); StorageLive(_3); @@ -48,8 +47,7 @@ StorageDead(_3); _0 = const (); StorageDead(_2); -- StorageDead(_1); -+ nop; + StorageDead(_1); return; } } diff --git a/tests/mir-opt/const_prop/bad_op_mod_by_zero.main.GVN.panic-abort.diff b/tests/mir-opt/const_prop/bad_op_mod_by_zero.main.GVN.panic-abort.diff index e5a8726b855c4..eac751a231bd3 100644 --- a/tests/mir-opt/const_prop/bad_op_mod_by_zero.main.GVN.panic-abort.diff +++ b/tests/mir-opt/const_prop/bad_op_mod_by_zero.main.GVN.panic-abort.diff @@ -18,8 +18,7 @@ } bb0: { -- StorageLive(_1); -+ nop; + StorageLive(_1); _1 = const 0_i32; StorageLive(_2); StorageLive(_3); @@ -48,8 +47,7 @@ StorageDead(_3); _0 = const (); StorageDead(_2); -- StorageDead(_1); -+ nop; + StorageDead(_1); return; } } diff --git a/tests/mir-opt/const_prop/bad_op_mod_by_zero.main.GVN.panic-unwind.diff b/tests/mir-opt/const_prop/bad_op_mod_by_zero.main.GVN.panic-unwind.diff index 1110ff186dc6e..72b13008f5c50 100644 --- a/tests/mir-opt/const_prop/bad_op_mod_by_zero.main.GVN.panic-unwind.diff +++ b/tests/mir-opt/const_prop/bad_op_mod_by_zero.main.GVN.panic-unwind.diff @@ -18,8 +18,7 @@ } bb0: { -- StorageLive(_1); -+ nop; + StorageLive(_1); _1 = const 0_i32; StorageLive(_2); StorageLive(_3); @@ -48,8 +47,7 @@ StorageDead(_3); _0 = const (); StorageDead(_2); -- StorageDead(_1); -+ nop; + StorageDead(_1); return; } } diff --git a/tests/mir-opt/const_prop/boolean_identities.test.GVN.diff b/tests/mir-opt/const_prop/boolean_identities.test.GVN.diff index 3fe70302b21cf..2b389e815ce4e 100644 --- a/tests/mir-opt/const_prop/boolean_identities.test.GVN.diff +++ b/tests/mir-opt/const_prop/boolean_identities.test.GVN.diff @@ -19,15 +19,13 @@ } bb0: { -- StorageLive(_3); -+ nop; + StorageLive(_3); StorageLive(_4); _4 = copy _2; - _3 = BitOr(move _4, const true); + _3 = const true; StorageDead(_4); -- StorageLive(_5); -+ nop; + StorageLive(_5); StorageLive(_6); _6 = copy _1; - _5 = BitAnd(move _6, const false); @@ -43,10 +41,8 @@ + _0 = const false; StorageDead(_8); StorageDead(_7); -- StorageDead(_5); -- StorageDead(_3); -+ nop; -+ nop; + StorageDead(_5); + StorageDead(_3); return; } } diff --git a/tests/mir-opt/const_prop/boxes.main.GVN.panic-abort.diff b/tests/mir-opt/const_prop/boxes.main.GVN.panic-abort.diff index 95eaf18b4703b..110536e20fddd 100644 --- a/tests/mir-opt/const_prop/boxes.main.GVN.panic-abort.diff +++ b/tests/mir-opt/const_prop/boxes.main.GVN.panic-abort.diff @@ -19,8 +19,7 @@ bb0: { StorageLive(_1); -- StorageLive(_2); -+ nop; + StorageLive(_2); StorageLive(_3); _4 = alloc::alloc::exchange_malloc(const ::SIZE, const ::ALIGN) -> [return: bb1, unwind unreachable]; } @@ -43,9 +42,8 @@ _10 = copy ((_3.0: std::ptr::Unique).0: std::ptr::NonNull) as *const i32 (Transmute); _2 = copy (*_10); - _1 = Add(move _2, const 0_i32); -- StorageDead(_2); + _1 = copy _2; -+ nop; + StorageDead(_2); drop(_3) -> [return: bb2, unwind unreachable]; } diff --git a/tests/mir-opt/const_prop/boxes.main.GVN.panic-unwind.diff b/tests/mir-opt/const_prop/boxes.main.GVN.panic-unwind.diff index 6d8d3a0dcfe29..16d33824344d6 100644 --- a/tests/mir-opt/const_prop/boxes.main.GVN.panic-unwind.diff +++ b/tests/mir-opt/const_prop/boxes.main.GVN.panic-unwind.diff @@ -19,8 +19,7 @@ bb0: { StorageLive(_1); -- StorageLive(_2); -+ nop; + StorageLive(_2); StorageLive(_3); _4 = alloc::alloc::exchange_malloc(const ::SIZE, const ::ALIGN) -> [return: bb1, unwind continue]; } @@ -43,9 +42,8 @@ _10 = copy ((_3.0: std::ptr::Unique).0: std::ptr::NonNull) as *const i32 (Transmute); _2 = copy (*_10); - _1 = Add(move _2, const 0_i32); -- StorageDead(_2); + _1 = copy _2; -+ nop; + StorageDead(_2); drop(_3) -> [return: bb2, unwind: bb3]; } diff --git a/tests/mir-opt/const_prop/mutable_variable_unprop_assign.main.GVN.panic-abort.diff b/tests/mir-opt/const_prop/mutable_variable_unprop_assign.main.GVN.panic-abort.diff index 7ca1b39d77110..405ef7f54d654 100644 --- a/tests/mir-opt/const_prop/mutable_variable_unprop_assign.main.GVN.panic-abort.diff +++ b/tests/mir-opt/const_prop/mutable_variable_unprop_assign.main.GVN.panic-abort.diff @@ -22,8 +22,7 @@ } bb0: { -- StorageLive(_1); -+ nop; + StorageLive(_1); _1 = foo() -> [return: bb1, unwind unreachable]; } @@ -44,8 +43,7 @@ StorageDead(_5); StorageDead(_4); StorageDead(_2); -- StorageDead(_1); -+ nop; + StorageDead(_1); return; } } diff --git a/tests/mir-opt/const_prop/mutable_variable_unprop_assign.main.GVN.panic-unwind.diff b/tests/mir-opt/const_prop/mutable_variable_unprop_assign.main.GVN.panic-unwind.diff index f637951380664..49782bb44c2a0 100644 --- a/tests/mir-opt/const_prop/mutable_variable_unprop_assign.main.GVN.panic-unwind.diff +++ b/tests/mir-opt/const_prop/mutable_variable_unprop_assign.main.GVN.panic-unwind.diff @@ -22,8 +22,7 @@ } bb0: { -- StorageLive(_1); -+ nop; + StorageLive(_1); _1 = foo() -> [return: bb1, unwind continue]; } @@ -44,8 +43,7 @@ StorageDead(_5); StorageDead(_4); StorageDead(_2); -- StorageDead(_1); -+ nop; + StorageDead(_1); return; } } diff --git a/tests/mir-opt/const_prop/pointer_expose_provenance.main.GVN.panic-abort.diff b/tests/mir-opt/const_prop/pointer_expose_provenance.main.GVN.panic-abort.diff index 657fa7a5fea19..c6991c0a3bb4d 100644 --- a/tests/mir-opt/const_prop/pointer_expose_provenance.main.GVN.panic-abort.diff +++ b/tests/mir-opt/const_prop/pointer_expose_provenance.main.GVN.panic-abort.diff @@ -13,8 +13,7 @@ } bb0: { -- StorageLive(_1); -+ nop; + StorageLive(_1); StorageLive(_2); StorageLive(_3); _3 = const main::FOO; @@ -33,8 +32,7 @@ StorageDead(_5); StorageDead(_4); _0 = const (); -- StorageDead(_1); -+ nop; + StorageDead(_1); return; } } diff --git a/tests/mir-opt/const_prop/pointer_expose_provenance.main.GVN.panic-unwind.diff b/tests/mir-opt/const_prop/pointer_expose_provenance.main.GVN.panic-unwind.diff index 8fef6591d41d9..04a43e5973a88 100644 --- a/tests/mir-opt/const_prop/pointer_expose_provenance.main.GVN.panic-unwind.diff +++ b/tests/mir-opt/const_prop/pointer_expose_provenance.main.GVN.panic-unwind.diff @@ -13,8 +13,7 @@ } bb0: { -- StorageLive(_1); -+ nop; + StorageLive(_1); StorageLive(_2); StorageLive(_3); _3 = const main::FOO; @@ -33,8 +32,7 @@ StorageDead(_5); StorageDead(_4); _0 = const (); -- StorageDead(_1); -+ nop; + StorageDead(_1); return; } } diff --git a/tests/mir-opt/const_prop/read_immutable_static.main.GVN.diff b/tests/mir-opt/const_prop/read_immutable_static.main.GVN.diff index 8df262b351f12..1d8c05a4d6a9c 100644 --- a/tests/mir-opt/const_prop/read_immutable_static.main.GVN.diff +++ b/tests/mir-opt/const_prop/read_immutable_static.main.GVN.diff @@ -14,10 +14,8 @@ bb0: { StorageLive(_1); -- StorageLive(_2); -- StorageLive(_3); -+ nop; -+ nop; + StorageLive(_2); + StorageLive(_3); _3 = const {ALLOC0: &u8}; - _2 = copy (*_3); + _2 = const 2_u8; @@ -29,11 +27,9 @@ + _4 = const 2_u8; + _1 = const 4_u8; StorageDead(_4); -- StorageDead(_2); -+ nop; + StorageDead(_2); StorageDead(_5); -- StorageDead(_3); -+ nop; + StorageDead(_3); _0 = const (); StorageDead(_1); return; diff --git a/tests/mir-opt/const_prop/scalar_literal_propagation.main.GVN.panic-abort.diff b/tests/mir-opt/const_prop/scalar_literal_propagation.main.GVN.panic-abort.diff index 3c73d34474c13..83093cc337cb3 100644 --- a/tests/mir-opt/const_prop/scalar_literal_propagation.main.GVN.panic-abort.diff +++ b/tests/mir-opt/const_prop/scalar_literal_propagation.main.GVN.panic-abort.diff @@ -11,8 +11,7 @@ } bb0: { -- StorageLive(_1); -+ nop; + StorageLive(_1); _1 = const 1_u32; StorageLive(_2); StorageLive(_3); @@ -26,8 +25,7 @@ StorageDead(_3); StorageDead(_2); _0 = const (); -- StorageDead(_1); -+ nop; + StorageDead(_1); return; } } diff --git a/tests/mir-opt/const_prop/scalar_literal_propagation.main.GVN.panic-unwind.diff b/tests/mir-opt/const_prop/scalar_literal_propagation.main.GVN.panic-unwind.diff index 0a7fddee39b62..804763b4f399b 100644 --- a/tests/mir-opt/const_prop/scalar_literal_propagation.main.GVN.panic-unwind.diff +++ b/tests/mir-opt/const_prop/scalar_literal_propagation.main.GVN.panic-unwind.diff @@ -11,8 +11,7 @@ } bb0: { -- StorageLive(_1); -+ nop; + StorageLive(_1); _1 = const 1_u32; StorageLive(_2); StorageLive(_3); @@ -26,8 +25,7 @@ StorageDead(_3); StorageDead(_2); _0 = const (); -- StorageDead(_1); -+ nop; + StorageDead(_1); return; } } diff --git a/tests/mir-opt/const_prop/tuple_literal_propagation.main.GVN.panic-abort.diff b/tests/mir-opt/const_prop/tuple_literal_propagation.main.GVN.panic-abort.diff index 01d86ce8717d1..402482eb4e006 100644 --- a/tests/mir-opt/const_prop/tuple_literal_propagation.main.GVN.panic-abort.diff +++ b/tests/mir-opt/const_prop/tuple_literal_propagation.main.GVN.panic-abort.diff @@ -11,9 +11,8 @@ } bb0: { -- StorageLive(_1); + StorageLive(_1); - _1 = (const 1_u32, const 2_u32); -+ nop; + _1 = const (1_u32, 2_u32); StorageLive(_2); StorageLive(_3); @@ -27,8 +26,7 @@ StorageDead(_3); StorageDead(_2); _0 = const (); -- StorageDead(_1); -+ nop; + StorageDead(_1); return; } } diff --git a/tests/mir-opt/const_prop/tuple_literal_propagation.main.GVN.panic-unwind.diff b/tests/mir-opt/const_prop/tuple_literal_propagation.main.GVN.panic-unwind.diff index bd7d494212ce6..2f1c5f1c0b0de 100644 --- a/tests/mir-opt/const_prop/tuple_literal_propagation.main.GVN.panic-unwind.diff +++ b/tests/mir-opt/const_prop/tuple_literal_propagation.main.GVN.panic-unwind.diff @@ -11,9 +11,8 @@ } bb0: { -- StorageLive(_1); + StorageLive(_1); - _1 = (const 1_u32, const 2_u32); -+ nop; + _1 = const (1_u32, 2_u32); StorageLive(_2); StorageLive(_3); @@ -27,8 +26,7 @@ StorageDead(_3); StorageDead(_2); _0 = const (); -- StorageDead(_1); -+ nop; + StorageDead(_1); return; } } 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 38beb81e1ead2..89c57901d7f5a 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 @@ -6,28 +6,24 @@ let _1: &std::boxed::Box<()>; let _2: &std::boxed::Box<()>; let _3: std::boxed::Box<()>; - let mut _4: (); - let mut _7: *const (); - let mut _9: *const [()]; - let mut _10: std::boxed::Box<()>; - let mut _11: *const (); - let mut _16: usize; - let mut _17: usize; - let mut _27: usize; + let mut _6: *const (); + let mut _8: *const [()]; + let mut _9: std::boxed::Box<()>; + let mut _10: *const (); + let mut _23: usize; scope 1 { debug vp_ctx => _1; - let _5: *const (); + let _4: *const (); scope 2 { - debug slf => _5; - let _6: *const [()]; + debug slf => _10; + let _5: *const [()]; scope 3 { - debug bytes => _6; - let _8: *mut (); + debug bytes => _5; + let _7: *mut (); scope 4 { - debug _x => _8; + debug _x => _7; } scope 18 (inlined foo) { - let mut _28: *const [()]; } } scope 16 (inlined slice_from_raw_parts::<()>) { @@ -37,22 +33,21 @@ } } scope 5 (inlined Box::<()>::new) { - let mut _12: *mut u8; - let mut _13: *const (); - let mut _14: std::ptr::NonNull<()>; - let mut _15: std::ptr::Unique<()>; + let mut _11: usize; + let mut _12: usize; + let mut _13: *mut u8; scope 6 (inlined alloc::alloc::exchange_malloc) { - let _18: std::alloc::Layout; - let mut _19: std::result::Result, std::alloc::AllocError>; - let mut _20: isize; - let mut _22: !; + let _14: std::alloc::Layout; + let mut _15: std::result::Result, std::alloc::AllocError>; + let mut _16: isize; + let mut _18: !; scope 7 { - let _21: std::ptr::NonNull<[u8]>; + let _17: std::ptr::NonNull<[u8]>; scope 8 { scope 11 (inlined NonNull::<[u8]>::as_mut_ptr) { scope 12 (inlined NonNull::<[u8]>::as_non_null_ptr) { scope 13 (inlined NonNull::<[u8]>::cast::) { - let mut _26: *mut [u8]; + let mut _22: *mut [u8]; scope 14 (inlined NonNull::<[u8]>::as_ptr) { } } @@ -65,39 +60,31 @@ } } scope 9 (inlined #[track_caller] Layout::from_size_align_unchecked) { - let mut _23: bool; - let _24: (); - let mut _25: std::ptr::Alignment; + let mut _19: bool; + let _20: (); + let mut _21: std::ptr::Alignment; } } } bb0: { StorageLive(_1); -- StorageLive(_2); -+ nop; + StorageLive(_2); StorageLive(_3); - StorageLive(_4); -- _4 = (); -+ _4 = const (); + StorageLive(_11); StorageLive(_12); StorageLive(_13); +- _11 = SizeOf(()); +- _12 = AlignOf(()); ++ _11 = const 0_usize; ++ _12 = const 1_usize; StorageLive(_14); - StorageLive(_15); StorageLive(_16); -- _16 = const <() as std::mem::SizedTypeProperties>::SIZE; -+ _16 = const 0_usize; StorageLive(_17); -- _17 = const <() as std::mem::SizedTypeProperties>::ALIGN; -+ _17 = const 1_usize; - StorageLive(_18); - StorageLive(_20); - StorageLive(_21); - StorageLive(_22); - StorageLive(_24); - StorageLive(_23); - _23 = UbChecks(); - switchInt(move _23) -> [0: bb6, otherwise: bb5]; + StorageLive(_19); + _19 = const false; +- switchInt(move _19) -> [0: bb6, otherwise: bb5]; ++ switchInt(const false) -> [0: bb6, otherwise: bb5]; } bb1: { @@ -111,98 +98,75 @@ } bb3: { -- _22 = handle_alloc_error(move _18) -> unwind unreachable; -+ _22 = handle_alloc_error(const Layout {{ size: 0_usize, align: std::ptr::Alignment(std::ptr::alignment::AlignmentEnum::_Align1Shl0) }}) -> unwind unreachable; +- _18 = handle_alloc_error(move _14) -> unwind unreachable; ++ _18 = handle_alloc_error(const Layout {{ size: 0_usize, align: std::ptr::Alignment(std::ptr::alignment::AlignmentEnum::_Align1Shl0) }}) -> unwind unreachable; } bb4: { - _21 = copy ((_19 as Ok).0: std::ptr::NonNull<[u8]>); -- StorageLive(_26); -+ nop; - _26 = copy _21 as *mut [u8] (Transmute); - _12 = copy _26 as *mut u8 (PtrToPtr); -- StorageDead(_26); -+ nop; - StorageDead(_19); - StorageDead(_24); + _17 = copy ((_15 as Ok).0: std::ptr::NonNull<[u8]>); + StorageLive(_22); + _22 = copy _17 as *mut [u8] (Transmute); + _13 = copy _22 as *mut u8 (PtrToPtr); StorageDead(_22); - StorageDead(_21); - StorageDead(_20); - StorageDead(_18); + StorageDead(_15); StorageDead(_17); StorageDead(_16); -- _13 = copy _12 as *const () (PtrToPtr); -+ _13 = copy _26 as *const () (PtrToPtr); - _14 = NonNull::<()> { pointer: copy _13 }; - _15 = Unique::<()> { pointer: copy _14, _marker: const PhantomData::<()> }; - _3 = Box::<()>(move _15, const std::alloc::Global); -- (*_13) = move _4; -+ (*_13) = const (); - StorageDead(_15); StorageDead(_14); + _3 = ShallowInitBox(copy _13, ()); StorageDead(_13); StorageDead(_12); - StorageDead(_4); + StorageDead(_11); _2 = &_3; - _1 = &(*_2); -- StorageDead(_2); -- StorageLive(_5); -- _10 = copy (*_1); -+ nop; -+ nop; -+ _10 = copy (*_2); - _11 = copy ((_10.0: std::ptr::Unique<()>).0: std::ptr::NonNull<()>) as *const () (Transmute); - _5 = &raw const (*_11); -- StorageLive(_6); -+ nop; + _1 = copy _2; + StorageDead(_2); + StorageLive(_4); +- _9 = deref_copy _3; ++ _9 = copy _3; + _10 = copy ((_9.0: std::ptr::Unique<()>).0: std::ptr::NonNull<()>) as *const () (Transmute); + _4 = copy _10; + StorageLive(_5); + StorageLive(_6); +- _6 = copy _4; ++ _6 = copy _10; + StorageLive(_23); + _23 = const 1_usize; +- _5 = *const [()] from (copy _6, copy _23); ++ _5 = *const [()] from (copy _10, const 1_usize); + StorageDead(_23); + StorageDead(_6); StorageLive(_7); - _7 = copy _5; - StorageLive(_27); - _27 = const 1_usize; -- _6 = *const [()] from (copy _7, copy _27); -+ _6 = *const [()] from (copy _5, const 1_usize); - StorageDead(_27); - StorageDead(_7); StorageLive(_8); - StorageLive(_9); - _9 = copy _6; - StorageLive(_28); -- _28 = copy _9; -- _8 = copy _9 as *mut () (PtrToPtr); -+ _28 = copy _6; -+ _8 = copy _5 as *mut () (PtrToPtr); - StorageDead(_28); - StorageDead(_9); - _0 = const (); + _8 = copy _5; +- _7 = copy _8 as *mut () (PtrToPtr); ++ _7 = copy ((_9.0: std::ptr::Unique<()>).0: std::ptr::NonNull<()>) as *mut () (Transmute); StorageDead(_8); -- StorageDead(_6); -- StorageDead(_5); -+ nop; -+ nop; + StorageDead(_7); + StorageDead(_5); + StorageDead(_4); drop(_3) -> [return: bb1, unwind unreachable]; } bb5: { -- _24 = Layout::from_size_align_unchecked::precondition_check(copy _16, copy _17) -> [return: bb6, unwind unreachable]; -+ _24 = Layout::from_size_align_unchecked::precondition_check(const 0_usize, const 1_usize) -> [return: bb6, unwind unreachable]; +- _20 = Layout::from_size_align_unchecked::precondition_check(copy _11, copy _12) -> [return: bb6, unwind unreachable]; ++ _20 = Layout::from_size_align_unchecked::precondition_check(const 0_usize, const 1_usize) -> [return: bb6, unwind unreachable]; } bb6: { - StorageDead(_23); - StorageLive(_25); -- _25 = copy _17 as std::ptr::Alignment (Transmute); -- _18 = Layout { size: copy _16, align: move _25 }; -+ _25 = const std::ptr::Alignment(std::ptr::alignment::AlignmentEnum::_Align1Shl0); -+ _18 = const Layout {{ size: 0_usize, align: std::ptr::Alignment(std::ptr::alignment::AlignmentEnum::_Align1Shl0) }}; - StorageDead(_25); - StorageLive(_19); -- _19 = std::alloc::Global::alloc_impl(const alloc::alloc::exchange_malloc::promoted[0], copy _18, const false) -> [return: bb7, unwind unreachable]; -+ _19 = std::alloc::Global::alloc_impl(const alloc::alloc::exchange_malloc::promoted[0], const Layout {{ size: 0_usize, align: std::ptr::Alignment(std::ptr::alignment::AlignmentEnum::_Align1Shl0) }}, const false) -> [return: bb7, unwind unreachable]; + StorageDead(_19); + StorageLive(_21); +- _21 = copy _12 as std::ptr::Alignment (Transmute); +- _14 = Layout { size: copy _11, align: move _21 }; ++ _21 = const std::ptr::Alignment(std::ptr::alignment::AlignmentEnum::_Align1Shl0); ++ _14 = const Layout {{ size: 0_usize, align: std::ptr::Alignment(std::ptr::alignment::AlignmentEnum::_Align1Shl0) }}; + StorageDead(_21); + StorageLive(_15); +- _15 = std::alloc::Global::alloc_impl(const alloc::alloc::exchange_malloc::promoted[0], copy _14, const false) -> [return: bb7, unwind unreachable]; ++ _15 = std::alloc::Global::alloc_impl(const alloc::alloc::exchange_malloc::promoted[0], const Layout {{ size: 0_usize, align: std::ptr::Alignment(std::ptr::alignment::AlignmentEnum::_Align1Shl0) }}, const false) -> [return: bb7, unwind unreachable]; } bb7: { - _20 = discriminant(_19); - switchInt(move _20) -> [0: bb4, 1: bb3, otherwise: bb2]; + _16 = discriminant(_15); + switchInt(move _16) -> [0: bb4, 1: bb3, otherwise: bb2]; } + } + 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 82a14a8b6ec99..30d8d63850a21 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 @@ -6,26 +6,24 @@ let _1: &std::boxed::Box<()>; let _2: &std::boxed::Box<()>; let _3: std::boxed::Box<()>; - let mut _4: (); - let mut _7: *const (); - let mut _9: *const [()]; - let mut _10: std::boxed::Box<()>; - let mut _11: *const (); - let mut _12: usize; + let mut _6: *const (); + let mut _8: *const [()]; + let mut _9: std::boxed::Box<()>; + let mut _10: *const (); + let mut _11: usize; scope 1 { debug vp_ctx => _1; - let _5: *const (); + let _4: *const (); scope 2 { - debug slf => _5; - let _6: *const [()]; + debug slf => _10; + let _5: *const [()]; scope 3 { - debug bytes => _6; - let _8: *mut (); + debug bytes => _5; + let _7: *mut (); scope 4 { - debug _x => _8; + debug _x => _7; } scope 7 (inlined foo) { - let mut _13: *const [()]; } } scope 5 (inlined slice_from_raw_parts::<()>) { @@ -37,54 +35,39 @@ bb0: { StorageLive(_1); -- StorageLive(_2); -+ nop; + StorageLive(_2); StorageLive(_3); - StorageLive(_4); -- _4 = (); -- _3 = Box::<()>::new(move _4) -> [return: bb1, unwind continue]; -+ _4 = const (); -+ _3 = Box::<()>::new(const ()) -> [return: bb1, unwind continue]; + _3 = Box::<()>::new(const ()) -> [return: bb1, unwind continue]; } bb1: { - StorageDead(_4); _2 = &_3; - _1 = &(*_2); -- StorageDead(_2); -- StorageLive(_5); -- _10 = copy (*_1); -+ nop; -+ nop; -+ _10 = copy (*_2); - _11 = copy ((_10.0: std::ptr::Unique<()>).0: std::ptr::NonNull<()>) as *const () (Transmute); - _5 = &raw const (*_11); -- StorageLive(_6); -+ nop; + _1 = copy _2; + StorageDead(_2); + StorageLive(_4); +- _9 = deref_copy _3; ++ _9 = copy _3; + _10 = copy ((_9.0: std::ptr::Unique<()>).0: std::ptr::NonNull<()>) as *const () (Transmute); + _4 = copy _10; + StorageLive(_5); + StorageLive(_6); +- _6 = copy _4; ++ _6 = copy _10; + StorageLive(_11); + _11 = const 1_usize; +- _5 = *const [()] from (copy _6, copy _11); ++ _5 = *const [()] from (copy _10, const 1_usize); + StorageDead(_11); + StorageDead(_6); StorageLive(_7); - _7 = copy _5; - StorageLive(_12); - _12 = const 1_usize; -- _6 = *const [()] from (copy _7, copy _12); -+ _6 = *const [()] from (copy _5, const 1_usize); - StorageDead(_12); - StorageDead(_7); StorageLive(_8); - StorageLive(_9); - _9 = copy _6; - StorageLive(_13); -- _13 = copy _9; -- _8 = copy _9 as *mut () (PtrToPtr); -+ _13 = copy _6; -+ _8 = copy _5 as *mut () (PtrToPtr); - StorageDead(_13); - StorageDead(_9); - _0 = const (); + _8 = copy _5; +- _7 = copy _8 as *mut () (PtrToPtr); ++ _7 = copy ((_9.0: std::ptr::Unique<()>).0: std::ptr::NonNull<()>) as *mut () (Transmute); StorageDead(_8); -- StorageDead(_6); -- StorageDead(_5); -+ nop; -+ nop; + StorageDead(_7); + StorageDead(_5); + StorageDead(_4); drop(_3) -> [return: bb2, unwind: bb3]; } 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 047579cdb5094..7673cf0f36471 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 @@ -6,28 +6,24 @@ let _1: &std::boxed::Box<()>; let _2: &std::boxed::Box<()>; let _3: std::boxed::Box<()>; - let mut _4: (); - let mut _7: *const (); - let mut _9: *const [()]; - let mut _10: std::boxed::Box<()>; - let mut _11: *const (); - let mut _16: usize; - let mut _17: usize; - let mut _27: usize; + let mut _6: *const (); + let mut _8: *const [()]; + let mut _9: std::boxed::Box<()>; + let mut _10: *const (); + let mut _23: usize; scope 1 { debug vp_ctx => _1; - let _5: *const (); + let _4: *const (); scope 2 { - debug slf => _5; - let _6: *const [()]; + debug slf => _10; + let _5: *const [()]; scope 3 { - debug bytes => _6; - let _8: *mut (); + debug bytes => _5; + let _7: *mut (); scope 4 { - debug _x => _8; + debug _x => _7; } scope 18 (inlined foo) { - let mut _28: *const [()]; } } scope 16 (inlined slice_from_raw_parts::<()>) { @@ -37,22 +33,21 @@ } } scope 5 (inlined Box::<()>::new) { - let mut _12: *mut u8; - let mut _13: *const (); - let mut _14: std::ptr::NonNull<()>; - let mut _15: std::ptr::Unique<()>; + let mut _11: usize; + let mut _12: usize; + let mut _13: *mut u8; scope 6 (inlined alloc::alloc::exchange_malloc) { - let _18: std::alloc::Layout; - let mut _19: std::result::Result, std::alloc::AllocError>; - let mut _20: isize; - let mut _22: !; + let _14: std::alloc::Layout; + let mut _15: std::result::Result, std::alloc::AllocError>; + let mut _16: isize; + let mut _18: !; scope 7 { - let _21: std::ptr::NonNull<[u8]>; + let _17: std::ptr::NonNull<[u8]>; scope 8 { scope 11 (inlined NonNull::<[u8]>::as_mut_ptr) { scope 12 (inlined NonNull::<[u8]>::as_non_null_ptr) { scope 13 (inlined NonNull::<[u8]>::cast::) { - let mut _26: *mut [u8]; + let mut _22: *mut [u8]; scope 14 (inlined NonNull::<[u8]>::as_ptr) { } } @@ -65,39 +60,31 @@ } } scope 9 (inlined #[track_caller] Layout::from_size_align_unchecked) { - let mut _23: bool; - let _24: (); - let mut _25: std::ptr::Alignment; + let mut _19: bool; + let _20: (); + let mut _21: std::ptr::Alignment; } } } bb0: { StorageLive(_1); -- StorageLive(_2); -+ nop; + StorageLive(_2); StorageLive(_3); - StorageLive(_4); -- _4 = (); -+ _4 = const (); + StorageLive(_11); StorageLive(_12); StorageLive(_13); +- _11 = SizeOf(()); +- _12 = AlignOf(()); ++ _11 = const 0_usize; ++ _12 = const 1_usize; StorageLive(_14); - StorageLive(_15); StorageLive(_16); -- _16 = const <() as std::mem::SizedTypeProperties>::SIZE; -+ _16 = const 0_usize; StorageLive(_17); -- _17 = const <() as std::mem::SizedTypeProperties>::ALIGN; -+ _17 = const 1_usize; - StorageLive(_18); - StorageLive(_20); - StorageLive(_21); - StorageLive(_22); - StorageLive(_24); - StorageLive(_23); - _23 = UbChecks(); - switchInt(move _23) -> [0: bb6, otherwise: bb5]; + StorageLive(_19); + _19 = const false; +- switchInt(move _19) -> [0: bb6, otherwise: bb5]; ++ switchInt(const false) -> [0: bb6, otherwise: bb5]; } bb1: { @@ -111,98 +98,75 @@ } bb3: { -- _22 = handle_alloc_error(move _18) -> unwind unreachable; -+ _22 = handle_alloc_error(const Layout {{ size: 0_usize, align: std::ptr::Alignment(std::ptr::alignment::AlignmentEnum::_Align1Shl0) }}) -> unwind unreachable; +- _18 = handle_alloc_error(move _14) -> unwind unreachable; ++ _18 = handle_alloc_error(const Layout {{ size: 0_usize, align: std::ptr::Alignment(std::ptr::alignment::AlignmentEnum::_Align1Shl0) }}) -> unwind unreachable; } bb4: { - _21 = copy ((_19 as Ok).0: std::ptr::NonNull<[u8]>); -- StorageLive(_26); -+ nop; - _26 = copy _21 as *mut [u8] (Transmute); - _12 = copy _26 as *mut u8 (PtrToPtr); -- StorageDead(_26); -+ nop; - StorageDead(_19); - StorageDead(_24); + _17 = copy ((_15 as Ok).0: std::ptr::NonNull<[u8]>); + StorageLive(_22); + _22 = copy _17 as *mut [u8] (Transmute); + _13 = copy _22 as *mut u8 (PtrToPtr); StorageDead(_22); - StorageDead(_21); - StorageDead(_20); - StorageDead(_18); + StorageDead(_15); StorageDead(_17); StorageDead(_16); -- _13 = copy _12 as *const () (PtrToPtr); -+ _13 = copy _26 as *const () (PtrToPtr); - _14 = NonNull::<()> { pointer: copy _13 }; - _15 = Unique::<()> { pointer: copy _14, _marker: const PhantomData::<()> }; - _3 = Box::<()>(move _15, const std::alloc::Global); -- (*_13) = move _4; -+ (*_13) = const (); - StorageDead(_15); StorageDead(_14); + _3 = ShallowInitBox(copy _13, ()); StorageDead(_13); StorageDead(_12); - StorageDead(_4); + StorageDead(_11); _2 = &_3; - _1 = &(*_2); -- StorageDead(_2); -- StorageLive(_5); -- _10 = copy (*_1); -+ nop; -+ nop; -+ _10 = copy (*_2); - _11 = copy ((_10.0: std::ptr::Unique<()>).0: std::ptr::NonNull<()>) as *const () (Transmute); - _5 = &raw const (*_11); -- StorageLive(_6); -+ nop; + _1 = copy _2; + StorageDead(_2); + StorageLive(_4); +- _9 = deref_copy _3; ++ _9 = copy _3; + _10 = copy ((_9.0: std::ptr::Unique<()>).0: std::ptr::NonNull<()>) as *const () (Transmute); + _4 = copy _10; + StorageLive(_5); + StorageLive(_6); +- _6 = copy _4; ++ _6 = copy _10; + StorageLive(_23); + _23 = const 1_usize; +- _5 = *const [()] from (copy _6, copy _23); ++ _5 = *const [()] from (copy _10, const 1_usize); + StorageDead(_23); + StorageDead(_6); StorageLive(_7); - _7 = copy _5; - StorageLive(_27); - _27 = const 1_usize; -- _6 = *const [()] from (copy _7, copy _27); -+ _6 = *const [()] from (copy _5, const 1_usize); - StorageDead(_27); - StorageDead(_7); StorageLive(_8); - StorageLive(_9); - _9 = copy _6; - StorageLive(_28); -- _28 = copy _9; -- _8 = copy _9 as *mut () (PtrToPtr); -+ _28 = copy _6; -+ _8 = copy _5 as *mut () (PtrToPtr); - StorageDead(_28); - StorageDead(_9); - _0 = const (); + _8 = copy _5; +- _7 = copy _8 as *mut () (PtrToPtr); ++ _7 = copy ((_9.0: std::ptr::Unique<()>).0: std::ptr::NonNull<()>) as *mut () (Transmute); StorageDead(_8); -- StorageDead(_6); -- StorageDead(_5); -+ nop; -+ nop; + StorageDead(_7); + StorageDead(_5); + StorageDead(_4); drop(_3) -> [return: bb1, unwind unreachable]; } bb5: { -- _24 = Layout::from_size_align_unchecked::precondition_check(copy _16, copy _17) -> [return: bb6, unwind unreachable]; -+ _24 = Layout::from_size_align_unchecked::precondition_check(const 0_usize, const 1_usize) -> [return: bb6, unwind unreachable]; +- _20 = Layout::from_size_align_unchecked::precondition_check(copy _11, copy _12) -> [return: bb6, unwind unreachable]; ++ _20 = Layout::from_size_align_unchecked::precondition_check(const 0_usize, const 1_usize) -> [return: bb6, unwind unreachable]; } bb6: { - StorageDead(_23); - StorageLive(_25); -- _25 = copy _17 as std::ptr::Alignment (Transmute); -- _18 = Layout { size: copy _16, align: move _25 }; -+ _25 = const std::ptr::Alignment(std::ptr::alignment::AlignmentEnum::_Align1Shl0); -+ _18 = const Layout {{ size: 0_usize, align: std::ptr::Alignment(std::ptr::alignment::AlignmentEnum::_Align1Shl0) }}; - StorageDead(_25); - StorageLive(_19); -- _19 = std::alloc::Global::alloc_impl(const alloc::alloc::exchange_malloc::promoted[0], copy _18, const false) -> [return: bb7, unwind unreachable]; -+ _19 = std::alloc::Global::alloc_impl(const alloc::alloc::exchange_malloc::promoted[0], const Layout {{ size: 0_usize, align: std::ptr::Alignment(std::ptr::alignment::AlignmentEnum::_Align1Shl0) }}, const false) -> [return: bb7, unwind unreachable]; + StorageDead(_19); + StorageLive(_21); +- _21 = copy _12 as std::ptr::Alignment (Transmute); +- _14 = Layout { size: copy _11, align: move _21 }; ++ _21 = const std::ptr::Alignment(std::ptr::alignment::AlignmentEnum::_Align1Shl0); ++ _14 = const Layout {{ size: 0_usize, align: std::ptr::Alignment(std::ptr::alignment::AlignmentEnum::_Align1Shl0) }}; + StorageDead(_21); + StorageLive(_15); +- _15 = std::alloc::Global::alloc_impl(const alloc::alloc::exchange_malloc::promoted[0], copy _14, const false) -> [return: bb7, unwind unreachable]; ++ _15 = std::alloc::Global::alloc_impl(const alloc::alloc::exchange_malloc::promoted[0], const Layout {{ size: 0_usize, align: std::ptr::Alignment(std::ptr::alignment::AlignmentEnum::_Align1Shl0) }}, const false) -> [return: bb7, unwind unreachable]; } bb7: { - _20 = discriminant(_19); - switchInt(move _20) -> [0: bb4, 1: bb3, otherwise: bb2]; + _16 = discriminant(_15); + switchInt(move _16) -> [0: bb4, 1: bb3, otherwise: bb2]; } + } + 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 82a14a8b6ec99..30d8d63850a21 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 @@ -6,26 +6,24 @@ let _1: &std::boxed::Box<()>; let _2: &std::boxed::Box<()>; let _3: std::boxed::Box<()>; - let mut _4: (); - let mut _7: *const (); - let mut _9: *const [()]; - let mut _10: std::boxed::Box<()>; - let mut _11: *const (); - let mut _12: usize; + let mut _6: *const (); + let mut _8: *const [()]; + let mut _9: std::boxed::Box<()>; + let mut _10: *const (); + let mut _11: usize; scope 1 { debug vp_ctx => _1; - let _5: *const (); + let _4: *const (); scope 2 { - debug slf => _5; - let _6: *const [()]; + debug slf => _10; + let _5: *const [()]; scope 3 { - debug bytes => _6; - let _8: *mut (); + debug bytes => _5; + let _7: *mut (); scope 4 { - debug _x => _8; + debug _x => _7; } scope 7 (inlined foo) { - let mut _13: *const [()]; } } scope 5 (inlined slice_from_raw_parts::<()>) { @@ -37,54 +35,39 @@ bb0: { StorageLive(_1); -- StorageLive(_2); -+ nop; + StorageLive(_2); StorageLive(_3); - StorageLive(_4); -- _4 = (); -- _3 = Box::<()>::new(move _4) -> [return: bb1, unwind continue]; -+ _4 = const (); -+ _3 = Box::<()>::new(const ()) -> [return: bb1, unwind continue]; + _3 = Box::<()>::new(const ()) -> [return: bb1, unwind continue]; } bb1: { - StorageDead(_4); _2 = &_3; - _1 = &(*_2); -- StorageDead(_2); -- StorageLive(_5); -- _10 = copy (*_1); -+ nop; -+ nop; -+ _10 = copy (*_2); - _11 = copy ((_10.0: std::ptr::Unique<()>).0: std::ptr::NonNull<()>) as *const () (Transmute); - _5 = &raw const (*_11); -- StorageLive(_6); -+ nop; + _1 = copy _2; + StorageDead(_2); + StorageLive(_4); +- _9 = deref_copy _3; ++ _9 = copy _3; + _10 = copy ((_9.0: std::ptr::Unique<()>).0: std::ptr::NonNull<()>) as *const () (Transmute); + _4 = copy _10; + StorageLive(_5); + StorageLive(_6); +- _6 = copy _4; ++ _6 = copy _10; + StorageLive(_11); + _11 = const 1_usize; +- _5 = *const [()] from (copy _6, copy _11); ++ _5 = *const [()] from (copy _10, const 1_usize); + StorageDead(_11); + StorageDead(_6); StorageLive(_7); - _7 = copy _5; - StorageLive(_12); - _12 = const 1_usize; -- _6 = *const [()] from (copy _7, copy _12); -+ _6 = *const [()] from (copy _5, const 1_usize); - StorageDead(_12); - StorageDead(_7); StorageLive(_8); - StorageLive(_9); - _9 = copy _6; - StorageLive(_13); -- _13 = copy _9; -- _8 = copy _9 as *mut () (PtrToPtr); -+ _13 = copy _6; -+ _8 = copy _5 as *mut () (PtrToPtr); - StorageDead(_13); - StorageDead(_9); - _0 = const (); + _8 = copy _5; +- _7 = copy _8 as *mut () (PtrToPtr); ++ _7 = copy ((_9.0: std::ptr::Unique<()>).0: std::ptr::NonNull<()>) as *mut () (Transmute); StorageDead(_8); -- StorageDead(_6); -- StorageDead(_5); -+ nop; -+ nop; + StorageDead(_7); + StorageDead(_5); + StorageDead(_4); drop(_3) -> [return: bb2, unwind: bb3]; } diff --git a/tests/mir-opt/funky_arms.float_to_exponential_common.GVN.32bit.panic-abort.diff b/tests/mir-opt/funky_arms.float_to_exponential_common.GVN.32bit.panic-abort.diff index 6baa902b6f4bd..14058c5944bb6 100644 --- a/tests/mir-opt/funky_arms.float_to_exponential_common.GVN.32bit.panic-abort.diff +++ b/tests/mir-opt/funky_arms.float_to_exponential_common.GVN.32bit.panic-abort.diff @@ -78,8 +78,7 @@ } bb4: { -- StorageLive(_8); -+ nop; + StorageLive(_8); _8 = copy ((_6 as Some).0: usize); StorageLive(_9); _9 = copy _1; @@ -108,8 +107,7 @@ StorageDead(_11); StorageDead(_10); StorageDead(_9); -- StorageDead(_8); -+ nop; + StorageDead(_8); goto -> bb8; } diff --git a/tests/mir-opt/funky_arms.float_to_exponential_common.GVN.32bit.panic-unwind.diff b/tests/mir-opt/funky_arms.float_to_exponential_common.GVN.32bit.panic-unwind.diff index 36540e038654f..24c3ae1b1b2d4 100644 --- a/tests/mir-opt/funky_arms.float_to_exponential_common.GVN.32bit.panic-unwind.diff +++ b/tests/mir-opt/funky_arms.float_to_exponential_common.GVN.32bit.panic-unwind.diff @@ -78,8 +78,7 @@ } bb4: { -- StorageLive(_8); -+ nop; + StorageLive(_8); _8 = copy ((_6 as Some).0: usize); StorageLive(_9); _9 = copy _1; @@ -108,8 +107,7 @@ StorageDead(_11); StorageDead(_10); StorageDead(_9); -- StorageDead(_8); -+ nop; + StorageDead(_8); goto -> bb8; } diff --git a/tests/mir-opt/funky_arms.float_to_exponential_common.GVN.64bit.panic-abort.diff b/tests/mir-opt/funky_arms.float_to_exponential_common.GVN.64bit.panic-abort.diff index 41c350f3eaeb5..ffbb51be657d9 100644 --- a/tests/mir-opt/funky_arms.float_to_exponential_common.GVN.64bit.panic-abort.diff +++ b/tests/mir-opt/funky_arms.float_to_exponential_common.GVN.64bit.panic-abort.diff @@ -78,8 +78,7 @@ } bb4: { -- StorageLive(_8); -+ nop; + StorageLive(_8); _8 = copy ((_6 as Some).0: usize); StorageLive(_9); _9 = copy _1; @@ -108,8 +107,7 @@ StorageDead(_11); StorageDead(_10); StorageDead(_9); -- StorageDead(_8); -+ nop; + StorageDead(_8); goto -> bb8; } diff --git a/tests/mir-opt/funky_arms.float_to_exponential_common.GVN.64bit.panic-unwind.diff b/tests/mir-opt/funky_arms.float_to_exponential_common.GVN.64bit.panic-unwind.diff index b839bf81eaf45..1fbac464c9d34 100644 --- a/tests/mir-opt/funky_arms.float_to_exponential_common.GVN.64bit.panic-unwind.diff +++ b/tests/mir-opt/funky_arms.float_to_exponential_common.GVN.64bit.panic-unwind.diff @@ -78,8 +78,7 @@ } bb4: { -- StorageLive(_8); -+ nop; + StorageLive(_8); _8 = copy ((_6 as Some).0: usize); StorageLive(_9); _9 = copy _1; @@ -108,8 +107,7 @@ StorageDead(_11); StorageDead(_10); StorageDead(_9); -- StorageDead(_8); -+ nop; + StorageDead(_8); goto -> bb8; } diff --git a/tests/mir-opt/gvn.aggregate_struct_then_transmute.GVN.panic-abort.diff b/tests/mir-opt/gvn.aggregate_struct_then_transmute.GVN.panic-abort.diff index 5ae575f300afb..9f8a839eee9a0 100644 --- a/tests/mir-opt/gvn.aggregate_struct_then_transmute.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn.aggregate_struct_then_transmute.GVN.panic-abort.diff @@ -91,8 +91,7 @@ } bb0: { -- StorageLive(_3); -+ nop; + StorageLive(_3); StorageLive(_4); _4 = copy _1; - _3 = MyId(move _4); @@ -113,8 +112,7 @@ bb1: { StorageDead(_6); StorageDead(_5); -- StorageLive(_8); -+ nop; + StorageLive(_8); StorageLive(_9); _9 = copy _1; StorageLive(_10); @@ -139,8 +137,7 @@ bb2: { StorageDead(_12); StorageDead(_11); -- StorageLive(_14); -+ nop; + StorageLive(_14); StorageLive(_15); _15 = copy _1; - _14 = Result::::Err(move _15); @@ -161,8 +158,7 @@ bb3: { StorageDead(_17); StorageDead(_16); -- StorageLive(_19); -+ nop; + StorageLive(_19); StorageLive(_20); _20 = copy _1; - _19 = Option::::Some(move _20); @@ -201,8 +197,7 @@ bb5: { StorageDead(_27); StorageDead(_26); -- StorageLive(_29); -+ nop; + StorageLive(_29); StorageLive(_30); _30 = copy _1; StorageLive(_31); @@ -248,8 +243,7 @@ bb7: { StorageDead(_39); StorageDead(_38); -- StorageLive(_41); -+ nop; + StorageLive(_41); StorageLive(_42); _42 = copy _1; - _41 = (move _42,); @@ -269,8 +263,7 @@ bb8: { StorageDead(_44); StorageDead(_43); -- StorageLive(_46); -+ nop; + StorageLive(_46); StorageLive(_47); _47 = copy _1; - _46 = [move _47]; @@ -290,8 +283,7 @@ bb9: { StorageDead(_49); StorageDead(_48); -- StorageLive(_51); -+ nop; + StorageLive(_51); StorageLive(_52); _52 = copy _2; StorageLive(_53); @@ -316,24 +308,16 @@ StorageDead(_55); StorageDead(_54); _0 = const (); -- StorageDead(_51); -- StorageDead(_46); -- StorageDead(_41); -+ nop; -+ nop; -+ nop; + StorageDead(_51); + StorageDead(_46); + StorageDead(_41); StorageDead(_35); -- StorageDead(_29); -+ nop; + StorageDead(_29); StorageDead(_24); -- StorageDead(_19); -- StorageDead(_14); -- StorageDead(_8); -- StorageDead(_3); -+ nop; -+ nop; -+ nop; -+ nop; + StorageDead(_19); + StorageDead(_14); + StorageDead(_8); + StorageDead(_3); return; } } diff --git a/tests/mir-opt/gvn.aggregate_struct_then_transmute.GVN.panic-unwind.diff b/tests/mir-opt/gvn.aggregate_struct_then_transmute.GVN.panic-unwind.diff index 3119a93fb8912..f04f778349dba 100644 --- a/tests/mir-opt/gvn.aggregate_struct_then_transmute.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn.aggregate_struct_then_transmute.GVN.panic-unwind.diff @@ -91,8 +91,7 @@ } bb0: { -- StorageLive(_3); -+ nop; + StorageLive(_3); StorageLive(_4); _4 = copy _1; - _3 = MyId(move _4); @@ -113,8 +112,7 @@ bb1: { StorageDead(_6); StorageDead(_5); -- StorageLive(_8); -+ nop; + StorageLive(_8); StorageLive(_9); _9 = copy _1; StorageLive(_10); @@ -139,8 +137,7 @@ bb2: { StorageDead(_12); StorageDead(_11); -- StorageLive(_14); -+ nop; + StorageLive(_14); StorageLive(_15); _15 = copy _1; - _14 = Result::::Err(move _15); @@ -161,8 +158,7 @@ bb3: { StorageDead(_17); StorageDead(_16); -- StorageLive(_19); -+ nop; + StorageLive(_19); StorageLive(_20); _20 = copy _1; - _19 = Option::::Some(move _20); @@ -201,8 +197,7 @@ bb5: { StorageDead(_27); StorageDead(_26); -- StorageLive(_29); -+ nop; + StorageLive(_29); StorageLive(_30); _30 = copy _1; StorageLive(_31); @@ -248,8 +243,7 @@ bb7: { StorageDead(_39); StorageDead(_38); -- StorageLive(_41); -+ nop; + StorageLive(_41); StorageLive(_42); _42 = copy _1; - _41 = (move _42,); @@ -269,8 +263,7 @@ bb8: { StorageDead(_44); StorageDead(_43); -- StorageLive(_46); -+ nop; + StorageLive(_46); StorageLive(_47); _47 = copy _1; - _46 = [move _47]; @@ -290,8 +283,7 @@ bb9: { StorageDead(_49); StorageDead(_48); -- StorageLive(_51); -+ nop; + StorageLive(_51); StorageLive(_52); _52 = copy _2; StorageLive(_53); @@ -316,24 +308,16 @@ StorageDead(_55); StorageDead(_54); _0 = const (); -- StorageDead(_51); -- StorageDead(_46); -- StorageDead(_41); -+ nop; -+ nop; -+ nop; + StorageDead(_51); + StorageDead(_46); + StorageDead(_41); StorageDead(_35); -- StorageDead(_29); -+ nop; + StorageDead(_29); StorageDead(_24); -- StorageDead(_19); -- StorageDead(_14); -- StorageDead(_8); -- StorageDead(_3); -+ nop; -+ nop; -+ nop; -+ nop; + StorageDead(_19); + StorageDead(_14); + StorageDead(_8); + StorageDead(_3); return; } } diff --git a/tests/mir-opt/gvn.arithmetic.GVN.panic-abort.diff b/tests/mir-opt/gvn.arithmetic.GVN.panic-abort.diff index f980645b1d092..363c2f6ad37cf 100644 --- a/tests/mir-opt/gvn.arithmetic.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn.arithmetic.GVN.panic-abort.diff @@ -108,8 +108,7 @@ StorageDead(_6); StorageDead(_5); StorageLive(_8); -- StorageLive(_9); -+ nop; + StorageLive(_9); StorageLive(_10); _10 = copy _1; StorageLive(_11); @@ -123,8 +122,7 @@ } bb3: { -- StorageDead(_9); -+ nop; + StorageDead(_9); StorageDead(_8); StorageLive(_12); StorageLive(_13); diff --git a/tests/mir-opt/gvn.arithmetic.GVN.panic-unwind.diff b/tests/mir-opt/gvn.arithmetic.GVN.panic-unwind.diff index b8e4967fe8b18..f135532a3f202 100644 --- a/tests/mir-opt/gvn.arithmetic.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn.arithmetic.GVN.panic-unwind.diff @@ -108,8 +108,7 @@ StorageDead(_6); StorageDead(_5); StorageLive(_8); -- StorageLive(_9); -+ nop; + StorageLive(_9); StorageLive(_10); _10 = copy _1; StorageLive(_11); @@ -123,8 +122,7 @@ } bb3: { -- StorageDead(_9); -+ nop; + StorageDead(_9); StorageDead(_8); StorageLive(_12); StorageLive(_13); diff --git a/tests/mir-opt/gvn.arithmetic_checked.GVN.panic-abort.diff b/tests/mir-opt/gvn.arithmetic_checked.GVN.panic-abort.diff index acf8bfc71beda..03db197c6a6cc 100644 --- a/tests/mir-opt/gvn.arithmetic_checked.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn.arithmetic_checked.GVN.panic-abort.diff @@ -70,8 +70,7 @@ StorageDead(_7); StorageDead(_6); StorageLive(_10); -- StorageLive(_11); -+ nop; + StorageLive(_11); StorageLive(_12); _12 = copy _1; StorageLive(_13); @@ -92,8 +91,7 @@ } bb6: { -- StorageDead(_11); -+ nop; + StorageDead(_11); StorageDead(_10); StorageLive(_15); StorageLive(_16); diff --git a/tests/mir-opt/gvn.arithmetic_checked.GVN.panic-unwind.diff b/tests/mir-opt/gvn.arithmetic_checked.GVN.panic-unwind.diff index f3f6b381a81ca..61d4ec54a14d7 100644 --- a/tests/mir-opt/gvn.arithmetic_checked.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn.arithmetic_checked.GVN.panic-unwind.diff @@ -70,8 +70,7 @@ StorageDead(_7); StorageDead(_6); StorageLive(_10); -- StorageLive(_11); -+ nop; + StorageLive(_11); StorageLive(_12); _12 = copy _1; StorageLive(_13); @@ -92,8 +91,7 @@ } bb6: { -- StorageDead(_11); -+ nop; + StorageDead(_11); StorageDead(_10); StorageLive(_15); StorageLive(_16); diff --git a/tests/mir-opt/gvn.cast.GVN.panic-abort.diff b/tests/mir-opt/gvn.cast.GVN.panic-abort.diff index 1d523d22ca646..71566213f4123 100644 --- a/tests/mir-opt/gvn.cast.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn.cast.GVN.panic-abort.diff @@ -104,14 +104,11 @@ } bb0: { -- StorageLive(_1); -+ nop; + StorageLive(_1); _1 = const 1_i64; -- StorageLive(_2); -+ nop; + StorageLive(_2); _2 = const 1_u64; -- StorageLive(_3); -+ nop; + StorageLive(_3); _3 = const 1f64; StorageLive(_4); StorageLive(_5); @@ -552,12 +549,9 @@ StorageDead(_90); StorageDead(_89); _0 = const (); -- StorageDead(_3); -- StorageDead(_2); -- StorageDead(_1); -+ nop; -+ nop; -+ nop; + StorageDead(_3); + StorageDead(_2); + StorageDead(_1); return; } } diff --git a/tests/mir-opt/gvn.cast.GVN.panic-unwind.diff b/tests/mir-opt/gvn.cast.GVN.panic-unwind.diff index 3541c10da6437..c0cd4882cd67a 100644 --- a/tests/mir-opt/gvn.cast.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn.cast.GVN.panic-unwind.diff @@ -104,14 +104,11 @@ } bb0: { -- StorageLive(_1); -+ nop; + StorageLive(_1); _1 = const 1_i64; -- StorageLive(_2); -+ nop; + StorageLive(_2); _2 = const 1_u64; -- StorageLive(_3); -+ nop; + StorageLive(_3); _3 = const 1f64; StorageLive(_4); StorageLive(_5); @@ -552,12 +549,9 @@ StorageDead(_90); StorageDead(_89); _0 = const (); -- StorageDead(_3); -- StorageDead(_2); -- StorageDead(_1); -+ nop; -+ nop; -+ nop; + StorageDead(_3); + StorageDead(_2); + StorageDead(_1); return; } } diff --git a/tests/mir-opt/gvn.cast_pointer_eq.GVN.panic-abort.diff b/tests/mir-opt/gvn.cast_pointer_eq.GVN.panic-abort.diff index f66aed0f44150..7dc5180a0a5cc 100644 --- a/tests/mir-opt/gvn.cast_pointer_eq.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn.cast_pointer_eq.GVN.panic-abort.diff @@ -49,8 +49,7 @@ } bb0: { -- StorageLive(_5); -+ nop; + StorageLive(_5); StorageLive(_6); _6 = copy _1; - _5 = move _6 as *const u32 (PtrToPtr); @@ -78,10 +77,9 @@ StorageDead(_12); - _10 = move _11 as *const u32 (PtrToPtr); - StorageDead(_11); -- StorageLive(_13); + _10 = copy _11; + nop; -+ nop; + StorageLive(_13); StorageLive(_14); _14 = copy _4; - _13 = move _14 as *const u32 (PtrToPtr); @@ -122,12 +120,10 @@ StorageDead(_21); StorageDead(_18); StorageDead(_15); -- StorageDead(_13); -+ nop; + StorageDead(_13); StorageDead(_10); StorageDead(_7); -- StorageDead(_5); -+ nop; + StorageDead(_5); return; } } diff --git a/tests/mir-opt/gvn.cast_pointer_eq.GVN.panic-unwind.diff b/tests/mir-opt/gvn.cast_pointer_eq.GVN.panic-unwind.diff index f66aed0f44150..7dc5180a0a5cc 100644 --- a/tests/mir-opt/gvn.cast_pointer_eq.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn.cast_pointer_eq.GVN.panic-unwind.diff @@ -49,8 +49,7 @@ } bb0: { -- StorageLive(_5); -+ nop; + StorageLive(_5); StorageLive(_6); _6 = copy _1; - _5 = move _6 as *const u32 (PtrToPtr); @@ -78,10 +77,9 @@ StorageDead(_12); - _10 = move _11 as *const u32 (PtrToPtr); - StorageDead(_11); -- StorageLive(_13); + _10 = copy _11; + nop; -+ nop; + StorageLive(_13); StorageLive(_14); _14 = copy _4; - _13 = move _14 as *const u32 (PtrToPtr); @@ -122,12 +120,10 @@ StorageDead(_21); StorageDead(_18); StorageDead(_15); -- StorageDead(_13); -+ nop; + StorageDead(_13); StorageDead(_10); StorageDead(_7); -- StorageDead(_5); -+ nop; + StorageDead(_5); return; } } diff --git a/tests/mir-opt/gvn.casts_before_aggregate_raw_ptr.GVN.panic-abort.diff b/tests/mir-opt/gvn.casts_before_aggregate_raw_ptr.GVN.panic-abort.diff index fd09310fabdeb..bb35b7ef57b2c 100644 --- a/tests/mir-opt/gvn.casts_before_aggregate_raw_ptr.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn.casts_before_aggregate_raw_ptr.GVN.panic-abort.diff @@ -22,22 +22,19 @@ } bb0: { -- StorageLive(_2); -+ nop; + StorageLive(_2); StorageLive(_3); _3 = copy _1; - _2 = move _3 as *const [u8; 4] (PtrToPtr); + _2 = copy _1 as *const [u8; 4] (PtrToPtr); StorageDead(_3); -- StorageLive(_4); -+ nop; + StorageLive(_4); StorageLive(_5); _5 = copy _2; - _4 = move _5 as *const u8 (PtrToPtr); + _4 = copy _1 as *const u8 (PtrToPtr); StorageDead(_5); -- StorageLive(_6); -+ nop; + StorageLive(_6); StorageLive(_7); _7 = copy _4; - _6 = move _7 as *const () (PtrToPtr); @@ -48,12 +45,9 @@ - _0 = *const [u8] from (move _8, const 4_usize); + _0 = *const [u8] from (copy _1, const 4_usize); StorageDead(_8); -- StorageDead(_6); -- StorageDead(_4); -- StorageDead(_2); -+ nop; -+ nop; -+ nop; + StorageDead(_6); + StorageDead(_4); + StorageDead(_2); return; } } diff --git a/tests/mir-opt/gvn.casts_before_aggregate_raw_ptr.GVN.panic-unwind.diff b/tests/mir-opt/gvn.casts_before_aggregate_raw_ptr.GVN.panic-unwind.diff index fd09310fabdeb..bb35b7ef57b2c 100644 --- a/tests/mir-opt/gvn.casts_before_aggregate_raw_ptr.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn.casts_before_aggregate_raw_ptr.GVN.panic-unwind.diff @@ -22,22 +22,19 @@ } bb0: { -- StorageLive(_2); -+ nop; + StorageLive(_2); StorageLive(_3); _3 = copy _1; - _2 = move _3 as *const [u8; 4] (PtrToPtr); + _2 = copy _1 as *const [u8; 4] (PtrToPtr); StorageDead(_3); -- StorageLive(_4); -+ nop; + StorageLive(_4); StorageLive(_5); _5 = copy _2; - _4 = move _5 as *const u8 (PtrToPtr); + _4 = copy _1 as *const u8 (PtrToPtr); StorageDead(_5); -- StorageLive(_6); -+ nop; + StorageLive(_6); StorageLive(_7); _7 = copy _4; - _6 = move _7 as *const () (PtrToPtr); @@ -48,12 +45,9 @@ - _0 = *const [u8] from (move _8, const 4_usize); + _0 = *const [u8] from (copy _1, const 4_usize); StorageDead(_8); -- StorageDead(_6); -- StorageDead(_4); -- StorageDead(_2); -+ nop; -+ nop; -+ nop; + StorageDead(_6); + StorageDead(_4); + StorageDead(_2); return; } } diff --git a/tests/mir-opt/gvn.constant_index_overflow.GVN.panic-abort.diff b/tests/mir-opt/gvn.constant_index_overflow.GVN.panic-abort.diff index 183b4d2599f53..5ce130fbace82 100644 --- a/tests/mir-opt/gvn.constant_index_overflow.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn.constant_index_overflow.GVN.panic-abort.diff @@ -25,9 +25,8 @@ } bb0: { -- StorageLive(_2); + StorageLive(_2); - _2 = const core::num::::MAX as usize (IntToInt); -+ nop; + _2 = const usize::MAX; StorageLive(_3); StorageLive(_4); @@ -96,8 +95,7 @@ bb7: { StorageDead(_14); StorageDead(_3); -- StorageDead(_2); -+ nop; + StorageDead(_2); return; } } diff --git a/tests/mir-opt/gvn.constant_index_overflow.GVN.panic-unwind.diff b/tests/mir-opt/gvn.constant_index_overflow.GVN.panic-unwind.diff index 03e8aa3bd9b98..f81b8cbecb663 100644 --- a/tests/mir-opt/gvn.constant_index_overflow.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn.constant_index_overflow.GVN.panic-unwind.diff @@ -25,9 +25,8 @@ } bb0: { -- StorageLive(_2); + StorageLive(_2); - _2 = const core::num::::MAX as usize (IntToInt); -+ nop; + _2 = const usize::MAX; StorageLive(_3); StorageLive(_4); @@ -96,8 +95,7 @@ bb7: { StorageDead(_14); StorageDead(_3); -- StorageDead(_2); -+ nop; + StorageDead(_2); return; } } diff --git a/tests/mir-opt/gvn.fn_pointers.GVN.panic-abort.diff b/tests/mir-opt/gvn.fn_pointers.GVN.panic-abort.diff index f3f631956374d..f8180886e97be 100644 --- a/tests/mir-opt/gvn.fn_pointers.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn.fn_pointers.GVN.panic-abort.diff @@ -8,10 +8,10 @@ let mut _3: fn(u8) -> u8; let _5: (); let mut _6: fn(u8) -> u8; - let mut _9: {closure@$DIR/gvn.rs:617:19: 617:21}; + let mut _9: {closure@$DIR/gvn.rs:620:19: 620:21}; let _10: (); let mut _11: fn(); - let mut _13: {closure@$DIR/gvn.rs:617:19: 617:21}; + let mut _13: {closure@$DIR/gvn.rs:620:19: 620:21}; let _14: (); let mut _15: fn(); scope 1 { @@ -19,7 +19,7 @@ let _4: fn(u8) -> u8; scope 2 { debug g => _4; - let _7: {closure@$DIR/gvn.rs:617:19: 617:21}; + let _7: {closure@$DIR/gvn.rs:620:19: 620:21}; scope 3 { debug closure => _7; let _8: fn(); @@ -35,8 +35,7 @@ } bb0: { -- StorageLive(_1); -+ nop; + StorageLive(_1); _1 = identity:: as fn(u8) -> u8 (PointerCoercion(ReifyFnPointer, AsCast)); StorageLive(_2); StorageLive(_3); @@ -48,8 +47,7 @@ bb1: { StorageDead(_3); StorageDead(_2); -- StorageLive(_4); -+ nop; + StorageLive(_4); _4 = identity:: as fn(u8) -> u8 (PointerCoercion(ReifyFnPointer, AsCast)); StorageLive(_5); StorageLive(_6); @@ -61,17 +59,15 @@ bb2: { StorageDead(_6); StorageDead(_5); -- StorageLive(_7); -- _7 = {closure@$DIR/gvn.rs:617:19: 617:21}; -- StorageLive(_8); -+ nop; -+ _7 = const ZeroSized: {closure@$DIR/gvn.rs:617:19: 617:21}; -+ nop; + StorageLive(_7); +- _7 = {closure@$DIR/gvn.rs:620:19: 620:21}; ++ _7 = const ZeroSized: {closure@$DIR/gvn.rs:620:19: 620:21}; + StorageLive(_8); StorageLive(_9); - _9 = copy _7; - _8 = move _9 as fn() (PointerCoercion(ClosureFnPointer(Safe), AsCast)); -+ _9 = const ZeroSized: {closure@$DIR/gvn.rs:617:19: 617:21}; -+ _8 = const ZeroSized: {closure@$DIR/gvn.rs:617:19: 617:21} as fn() (PointerCoercion(ClosureFnPointer(Safe), AsCast)); ++ _9 = const ZeroSized: {closure@$DIR/gvn.rs:620:19: 620:21}; ++ _8 = const ZeroSized: {closure@$DIR/gvn.rs:620:19: 620:21} as fn() (PointerCoercion(ClosureFnPointer(Safe), AsCast)); StorageDead(_9); StorageLive(_10); StorageLive(_11); @@ -83,13 +79,12 @@ bb3: { StorageDead(_11); StorageDead(_10); -- StorageLive(_12); -+ nop; + StorageLive(_12); StorageLive(_13); - _13 = copy _7; - _12 = move _13 as fn() (PointerCoercion(ClosureFnPointer(Safe), AsCast)); -+ _13 = const ZeroSized: {closure@$DIR/gvn.rs:617:19: 617:21}; -+ _12 = const ZeroSized: {closure@$DIR/gvn.rs:617:19: 617:21} as fn() (PointerCoercion(ClosureFnPointer(Safe), AsCast)); ++ _13 = const ZeroSized: {closure@$DIR/gvn.rs:620:19: 620:21}; ++ _12 = const ZeroSized: {closure@$DIR/gvn.rs:620:19: 620:21} as fn() (PointerCoercion(ClosureFnPointer(Safe), AsCast)); StorageDead(_13); StorageLive(_14); StorageLive(_15); @@ -102,16 +97,11 @@ StorageDead(_15); StorageDead(_14); _0 = const (); -- StorageDead(_12); -- StorageDead(_8); -- StorageDead(_7); -- StorageDead(_4); -- StorageDead(_1); -+ nop; -+ nop; -+ nop; -+ nop; -+ nop; + StorageDead(_12); + StorageDead(_8); + StorageDead(_7); + StorageDead(_4); + StorageDead(_1); return; } } diff --git a/tests/mir-opt/gvn.fn_pointers.GVN.panic-unwind.diff b/tests/mir-opt/gvn.fn_pointers.GVN.panic-unwind.diff index 029e736a97952..44e6e914cd92c 100644 --- a/tests/mir-opt/gvn.fn_pointers.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn.fn_pointers.GVN.panic-unwind.diff @@ -8,10 +8,10 @@ let mut _3: fn(u8) -> u8; let _5: (); let mut _6: fn(u8) -> u8; - let mut _9: {closure@$DIR/gvn.rs:617:19: 617:21}; + let mut _9: {closure@$DIR/gvn.rs:620:19: 620:21}; let _10: (); let mut _11: fn(); - let mut _13: {closure@$DIR/gvn.rs:617:19: 617:21}; + let mut _13: {closure@$DIR/gvn.rs:620:19: 620:21}; let _14: (); let mut _15: fn(); scope 1 { @@ -19,7 +19,7 @@ let _4: fn(u8) -> u8; scope 2 { debug g => _4; - let _7: {closure@$DIR/gvn.rs:617:19: 617:21}; + let _7: {closure@$DIR/gvn.rs:620:19: 620:21}; scope 3 { debug closure => _7; let _8: fn(); @@ -35,8 +35,7 @@ } bb0: { -- StorageLive(_1); -+ nop; + StorageLive(_1); _1 = identity:: as fn(u8) -> u8 (PointerCoercion(ReifyFnPointer, AsCast)); StorageLive(_2); StorageLive(_3); @@ -48,8 +47,7 @@ bb1: { StorageDead(_3); StorageDead(_2); -- StorageLive(_4); -+ nop; + StorageLive(_4); _4 = identity:: as fn(u8) -> u8 (PointerCoercion(ReifyFnPointer, AsCast)); StorageLive(_5); StorageLive(_6); @@ -61,17 +59,15 @@ bb2: { StorageDead(_6); StorageDead(_5); -- StorageLive(_7); -- _7 = {closure@$DIR/gvn.rs:617:19: 617:21}; -- StorageLive(_8); -+ nop; -+ _7 = const ZeroSized: {closure@$DIR/gvn.rs:617:19: 617:21}; -+ nop; + StorageLive(_7); +- _7 = {closure@$DIR/gvn.rs:620:19: 620:21}; ++ _7 = const ZeroSized: {closure@$DIR/gvn.rs:620:19: 620:21}; + StorageLive(_8); StorageLive(_9); - _9 = copy _7; - _8 = move _9 as fn() (PointerCoercion(ClosureFnPointer(Safe), AsCast)); -+ _9 = const ZeroSized: {closure@$DIR/gvn.rs:617:19: 617:21}; -+ _8 = const ZeroSized: {closure@$DIR/gvn.rs:617:19: 617:21} as fn() (PointerCoercion(ClosureFnPointer(Safe), AsCast)); ++ _9 = const ZeroSized: {closure@$DIR/gvn.rs:620:19: 620:21}; ++ _8 = const ZeroSized: {closure@$DIR/gvn.rs:620:19: 620:21} as fn() (PointerCoercion(ClosureFnPointer(Safe), AsCast)); StorageDead(_9); StorageLive(_10); StorageLive(_11); @@ -83,13 +79,12 @@ bb3: { StorageDead(_11); StorageDead(_10); -- StorageLive(_12); -+ nop; + StorageLive(_12); StorageLive(_13); - _13 = copy _7; - _12 = move _13 as fn() (PointerCoercion(ClosureFnPointer(Safe), AsCast)); -+ _13 = const ZeroSized: {closure@$DIR/gvn.rs:617:19: 617:21}; -+ _12 = const ZeroSized: {closure@$DIR/gvn.rs:617:19: 617:21} as fn() (PointerCoercion(ClosureFnPointer(Safe), AsCast)); ++ _13 = const ZeroSized: {closure@$DIR/gvn.rs:620:19: 620:21}; ++ _12 = const ZeroSized: {closure@$DIR/gvn.rs:620:19: 620:21} as fn() (PointerCoercion(ClosureFnPointer(Safe), AsCast)); StorageDead(_13); StorageLive(_14); StorageLive(_15); @@ -102,16 +97,11 @@ StorageDead(_15); StorageDead(_14); _0 = const (); -- StorageDead(_12); -- StorageDead(_8); -- StorageDead(_7); -- StorageDead(_4); -- StorageDead(_1); -+ nop; -+ nop; -+ nop; -+ nop; -+ nop; + StorageDead(_12); + StorageDead(_8); + StorageDead(_7); + StorageDead(_4); + StorageDead(_1); return; } } diff --git a/tests/mir-opt/gvn.manual_slice_mut_len.GVN.panic-abort.diff b/tests/mir-opt/gvn.manual_slice_mut_len.GVN.panic-abort.diff index 936fa3db82a73..7741d0907d2ba 100644 --- a/tests/mir-opt/gvn.manual_slice_mut_len.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn.manual_slice_mut_len.GVN.panic-abort.diff @@ -16,11 +16,9 @@ } bb0: { -- StorageLive(_2); -+ nop; + StorageLive(_2); _2 = &raw mut (*_1); -- StorageLive(_3); -+ nop; + StorageLive(_3); StorageLive(_4); _4 = copy _2; - _3 = move _4 as *const [i32] (PtrToPtr); @@ -31,10 +29,8 @@ - _0 = PtrMetadata(move _5); + _0 = PtrMetadata(copy _1); StorageDead(_5); -- StorageDead(_3); -- StorageDead(_2); -+ nop; -+ nop; + StorageDead(_3); + StorageDead(_2); return; } } diff --git a/tests/mir-opt/gvn.manual_slice_mut_len.GVN.panic-unwind.diff b/tests/mir-opt/gvn.manual_slice_mut_len.GVN.panic-unwind.diff index 936fa3db82a73..7741d0907d2ba 100644 --- a/tests/mir-opt/gvn.manual_slice_mut_len.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn.manual_slice_mut_len.GVN.panic-unwind.diff @@ -16,11 +16,9 @@ } bb0: { -- StorageLive(_2); -+ nop; + StorageLive(_2); _2 = &raw mut (*_1); -- StorageLive(_3); -+ nop; + StorageLive(_3); StorageLive(_4); _4 = copy _2; - _3 = move _4 as *const [i32] (PtrToPtr); @@ -31,10 +29,8 @@ - _0 = PtrMetadata(move _5); + _0 = PtrMetadata(copy _1); StorageDead(_5); -- StorageDead(_3); -- StorageDead(_2); -+ nop; -+ nop; + StorageDead(_3); + StorageDead(_2); return; } } diff --git a/tests/mir-opt/gvn.meta_of_ref_to_slice.GVN.panic-abort.diff b/tests/mir-opt/gvn.meta_of_ref_to_slice.GVN.panic-abort.diff index 3ed6c2b5308fb..1825d68f1939c 100644 --- a/tests/mir-opt/gvn.meta_of_ref_to_slice.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn.meta_of_ref_to_slice.GVN.panic-abort.diff @@ -12,8 +12,7 @@ } bb0: { -- StorageLive(_2); -+ nop; + StorageLive(_2); StorageLive(_3); _3 = copy _1; - _2 = *const [i32] from (move _3, const 1_usize); @@ -24,8 +23,7 @@ - _0 = PtrMetadata(move _4); + _0 = const 1_usize; StorageDead(_4); -- StorageDead(_2); -+ nop; + StorageDead(_2); return; } } diff --git a/tests/mir-opt/gvn.meta_of_ref_to_slice.GVN.panic-unwind.diff b/tests/mir-opt/gvn.meta_of_ref_to_slice.GVN.panic-unwind.diff index 3ed6c2b5308fb..1825d68f1939c 100644 --- a/tests/mir-opt/gvn.meta_of_ref_to_slice.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn.meta_of_ref_to_slice.GVN.panic-unwind.diff @@ -12,8 +12,7 @@ } bb0: { -- StorageLive(_2); -+ nop; + StorageLive(_2); StorageLive(_3); _3 = copy _1; - _2 = *const [i32] from (move _3, const 1_usize); @@ -24,8 +23,7 @@ - _0 = PtrMetadata(move _4); + _0 = const 1_usize; StorageDead(_4); -- StorageDead(_2); -+ nop; + StorageDead(_2); return; } } diff --git a/tests/mir-opt/gvn.references.GVN.panic-abort.diff b/tests/mir-opt/gvn.references.GVN.panic-abort.diff index 62a487dee8215..429c7df2f361e 100644 --- a/tests/mir-opt/gvn.references.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn.references.GVN.panic-abort.diff @@ -112,8 +112,7 @@ bb8: { StorageDead(_17); StorageDead(_16); -- StorageLive(_18); -+ nop; + StorageLive(_18); _18 = &mut _1; StorageLive(_19); StorageLive(_20); @@ -168,8 +167,7 @@ StorageDead(_28); _0 = const (); StorageDead(_19); -- StorageDead(_18); -+ nop; + StorageDead(_18); drop(_1) -> [return: bb13, unwind unreachable]; } diff --git a/tests/mir-opt/gvn.references.GVN.panic-unwind.diff b/tests/mir-opt/gvn.references.GVN.panic-unwind.diff index 6dd986907fcc6..c2d67507c39d3 100644 --- a/tests/mir-opt/gvn.references.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn.references.GVN.panic-unwind.diff @@ -112,8 +112,7 @@ bb8: { StorageDead(_17); StorageDead(_16); -- StorageLive(_18); -+ nop; + StorageLive(_18); _18 = &mut _1; StorageLive(_19); StorageLive(_20); @@ -168,8 +167,7 @@ StorageDead(_28); _0 = const (); StorageDead(_19); -- StorageDead(_18); -+ nop; + StorageDead(_18); drop(_1) -> [return: bb13, unwind: bb15]; } diff --git a/tests/mir-opt/gvn.repeat.GVN.panic-abort.diff b/tests/mir-opt/gvn.repeat.GVN.panic-abort.diff index ef2eb1a66779d..0b8b682ba52ce 100644 --- a/tests/mir-opt/gvn.repeat.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn.repeat.GVN.panic-abort.diff @@ -23,8 +23,7 @@ } bb0: { -- StorageLive(_1); -+ nop; + StorageLive(_1); _1 = const 5_i32; StorageLive(_2); StorageLive(_3); @@ -71,8 +70,7 @@ StorageDead(_3); _0 = const (); StorageDead(_2); -- StorageDead(_1); -+ nop; + StorageDead(_1); return; } } diff --git a/tests/mir-opt/gvn.repeat.GVN.panic-unwind.diff b/tests/mir-opt/gvn.repeat.GVN.panic-unwind.diff index ef2eb1a66779d..0b8b682ba52ce 100644 --- a/tests/mir-opt/gvn.repeat.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn.repeat.GVN.panic-unwind.diff @@ -23,8 +23,7 @@ } bb0: { -- StorageLive(_1); -+ nop; + StorageLive(_1); _1 = const 5_i32; StorageLive(_2); StorageLive(_3); @@ -71,8 +70,7 @@ StorageDead(_3); _0 = const (); StorageDead(_2); -- StorageDead(_1); -+ nop; + StorageDead(_1); return; } } diff --git a/tests/mir-opt/gvn.slice_const_length.GVN.panic-abort.diff b/tests/mir-opt/gvn.slice_const_length.GVN.panic-abort.diff index 1a6204e4ac8ae..412f908821ab6 100644 --- a/tests/mir-opt/gvn.slice_const_length.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn.slice_const_length.GVN.panic-abort.diff @@ -17,8 +17,7 @@ } bb0: { -- StorageLive(_2); -+ nop; + StorageLive(_2); StorageLive(_3); _3 = &(*_1); _2 = core::slice::::as_ptr(move _3) -> [return: bb1, unwind unreachable]; @@ -26,8 +25,7 @@ bb1: { StorageDead(_3); -- StorageLive(_4); -+ nop; + StorageLive(_4); _4 = const 123_usize; StorageLive(_5); _5 = copy _2; @@ -38,10 +36,8 @@ + _0 = *const [i32] from (copy _2, const 123_usize); StorageDead(_6); StorageDead(_5); -- StorageDead(_4); -- StorageDead(_2); -+ nop; -+ nop; + StorageDead(_4); + StorageDead(_2); return; } } diff --git a/tests/mir-opt/gvn.slice_const_length.GVN.panic-unwind.diff b/tests/mir-opt/gvn.slice_const_length.GVN.panic-unwind.diff index 62d57b0fe2831..6f166971631c2 100644 --- a/tests/mir-opt/gvn.slice_const_length.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn.slice_const_length.GVN.panic-unwind.diff @@ -17,8 +17,7 @@ } bb0: { -- StorageLive(_2); -+ nop; + StorageLive(_2); StorageLive(_3); _3 = &(*_1); _2 = core::slice::::as_ptr(move _3) -> [return: bb1, unwind continue]; @@ -26,8 +25,7 @@ bb1: { StorageDead(_3); -- StorageLive(_4); -+ nop; + StorageLive(_4); _4 = const 123_usize; StorageLive(_5); _5 = copy _2; @@ -38,10 +36,8 @@ + _0 = *const [i32] from (copy _2, const 123_usize); StorageDead(_6); StorageDead(_5); -- StorageDead(_4); -- StorageDead(_2); -+ nop; -+ nop; + StorageDead(_4); + StorageDead(_2); return; } } diff --git a/tests/mir-opt/gvn.slice_from_raw_parts_as_ptr.GVN.panic-abort.diff b/tests/mir-opt/gvn.slice_from_raw_parts_as_ptr.GVN.panic-abort.diff index 4a2cc25189191..ab4971cc6c017 100644 --- a/tests/mir-opt/gvn.slice_from_raw_parts_as_ptr.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn.slice_from_raw_parts_as_ptr.GVN.panic-abort.diff @@ -17,8 +17,7 @@ } bb0: { -- StorageLive(_3); -+ nop; + StorageLive(_3); StorageLive(_4); _4 = copy _1; StorageLive(_5); @@ -43,8 +42,7 @@ + _0 = (copy _1, move _8); StorageDead(_8); StorageDead(_6); -- StorageDead(_3); -+ nop; + StorageDead(_3); return; } } diff --git a/tests/mir-opt/gvn.slice_from_raw_parts_as_ptr.GVN.panic-unwind.diff b/tests/mir-opt/gvn.slice_from_raw_parts_as_ptr.GVN.panic-unwind.diff index 4a2cc25189191..ab4971cc6c017 100644 --- a/tests/mir-opt/gvn.slice_from_raw_parts_as_ptr.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn.slice_from_raw_parts_as_ptr.GVN.panic-unwind.diff @@ -17,8 +17,7 @@ } bb0: { -- StorageLive(_3); -+ nop; + StorageLive(_3); StorageLive(_4); _4 = copy _1; StorageLive(_5); @@ -43,8 +42,7 @@ + _0 = (copy _1, move _8); StorageDead(_8); StorageDead(_6); -- StorageDead(_3); -+ nop; + StorageDead(_3); return; } } diff --git a/tests/mir-opt/gvn.slices.GVN.panic-abort.diff b/tests/mir-opt/gvn.slices.GVN.panic-abort.diff index 091c3bd5c7b2a..00807a6d40214 100644 --- a/tests/mir-opt/gvn.slices.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn.slices.GVN.panic-abort.diff @@ -82,8 +82,7 @@ } bb0: { -- StorageLive(_1); -+ nop; + StorageLive(_1); _1 = const "my favourite slice"; StorageLive(_2); StorageLive(_3); @@ -113,9 +112,8 @@ StorageLive(_7); StorageLive(_8); - StorageLive(_9); -- StorageLive(_10); -+ nop; + nop; + StorageLive(_10); StorageLive(_11); _11 = &(*_1); _10 = core::str::::as_ptr(move _11) -> [return: bb3, unwind unreachable]; @@ -125,9 +123,8 @@ StorageDead(_11); _9 = &_10; - StorageLive(_12); -- StorageLive(_13); -+ nop; + nop; + StorageLive(_13); StorageLive(_14); - _14 = &(*_4); + _14 = &(*_1); @@ -168,14 +165,11 @@ StorageDead(_17); StorageDead(_16); StorageDead(_15); -- StorageDead(_13); -- StorageDead(_10); -+ nop; -+ nop; + StorageDead(_13); + StorageDead(_10); StorageDead(_8); StorageDead(_7); -- StorageLive(_29); -+ nop; + StorageLive(_29); StorageLive(_30); _30 = &(*_1); _29 = move _30 as &[u8] (Transmute); @@ -190,9 +184,8 @@ bb6: { StorageDead(_19); StorageDead(_18); -- StorageLive(_21); + StorageLive(_21); - _21 = core::panicking::AssertKind::Eq; -+ nop; + _21 = const core::panicking::AssertKind::Eq; StorageLive(_22); StorageLive(_23); @@ -220,9 +213,8 @@ StorageLive(_33); StorageLive(_34); - StorageLive(_35); -- StorageLive(_36); -+ nop; + nop; + StorageLive(_36); StorageLive(_37); _37 = &(*_1); _36 = core::str::::as_ptr(move _37) -> [return: bb8, unwind unreachable]; @@ -232,9 +224,8 @@ StorageDead(_37); _35 = &_36; - StorageLive(_38); -- StorageLive(_39); -+ nop; + nop; + StorageLive(_39); StorageLive(_40); _40 = &(*_29); _39 = core::slice::::as_ptr(move _40) -> [return: bb9, unwind unreachable]; @@ -274,27 +265,22 @@ StorageDead(_43); StorageDead(_42); StorageDead(_41); -- StorageDead(_39); -- StorageDead(_36); -+ nop; -+ nop; + StorageDead(_39); + StorageDead(_36); StorageDead(_34); StorageDead(_33); _0 = const (); -- StorageDead(_29); -+ nop; + StorageDead(_29); StorageDead(_4); -- StorageDead(_1); -+ nop; + StorageDead(_1); return; } bb11: { StorageDead(_45); StorageDead(_44); -- StorageLive(_47); + StorageLive(_47); - _47 = core::panicking::AssertKind::Eq; -+ nop; + _47 = const core::panicking::AssertKind::Eq; StorageLive(_48); StorageLive(_49); diff --git a/tests/mir-opt/gvn.slices.GVN.panic-unwind.diff b/tests/mir-opt/gvn.slices.GVN.panic-unwind.diff index 9768956c9c870..49973083b1cef 100644 --- a/tests/mir-opt/gvn.slices.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn.slices.GVN.panic-unwind.diff @@ -82,8 +82,7 @@ } bb0: { -- StorageLive(_1); -+ nop; + StorageLive(_1); _1 = const "my favourite slice"; StorageLive(_2); StorageLive(_3); @@ -113,9 +112,8 @@ StorageLive(_7); StorageLive(_8); - StorageLive(_9); -- StorageLive(_10); -+ nop; + nop; + StorageLive(_10); StorageLive(_11); _11 = &(*_1); _10 = core::str::::as_ptr(move _11) -> [return: bb3, unwind continue]; @@ -125,9 +123,8 @@ StorageDead(_11); _9 = &_10; - StorageLive(_12); -- StorageLive(_13); -+ nop; + nop; + StorageLive(_13); StorageLive(_14); - _14 = &(*_4); + _14 = &(*_1); @@ -168,14 +165,11 @@ StorageDead(_17); StorageDead(_16); StorageDead(_15); -- StorageDead(_13); -- StorageDead(_10); -+ nop; -+ nop; + StorageDead(_13); + StorageDead(_10); StorageDead(_8); StorageDead(_7); -- StorageLive(_29); -+ nop; + StorageLive(_29); StorageLive(_30); _30 = &(*_1); _29 = move _30 as &[u8] (Transmute); @@ -190,9 +184,8 @@ bb6: { StorageDead(_19); StorageDead(_18); -- StorageLive(_21); + StorageLive(_21); - _21 = core::panicking::AssertKind::Eq; -+ nop; + _21 = const core::panicking::AssertKind::Eq; StorageLive(_22); StorageLive(_23); @@ -220,9 +213,8 @@ StorageLive(_33); StorageLive(_34); - StorageLive(_35); -- StorageLive(_36); -+ nop; + nop; + StorageLive(_36); StorageLive(_37); _37 = &(*_1); _36 = core::str::::as_ptr(move _37) -> [return: bb8, unwind continue]; @@ -232,9 +224,8 @@ StorageDead(_37); _35 = &_36; - StorageLive(_38); -- StorageLive(_39); -+ nop; + nop; + StorageLive(_39); StorageLive(_40); _40 = &(*_29); _39 = core::slice::::as_ptr(move _40) -> [return: bb9, unwind continue]; @@ -274,27 +265,22 @@ StorageDead(_43); StorageDead(_42); StorageDead(_41); -- StorageDead(_39); -- StorageDead(_36); -+ nop; -+ nop; + StorageDead(_39); + StorageDead(_36); StorageDead(_34); StorageDead(_33); _0 = const (); -- StorageDead(_29); -+ nop; + StorageDead(_29); StorageDead(_4); -- StorageDead(_1); -+ nop; + StorageDead(_1); return; } bb11: { StorageDead(_45); StorageDead(_44); -- StorageLive(_47); + StorageLive(_47); - _47 = core::panicking::AssertKind::Eq; -+ nop; + _47 = const core::panicking::AssertKind::Eq; StorageLive(_48); StorageLive(_49); diff --git a/tests/mir-opt/gvn.transmute_then_cast_pointer.GVN.panic-abort.diff b/tests/mir-opt/gvn.transmute_then_cast_pointer.GVN.panic-abort.diff index 0bec425dd9957..230a420d0c3d6 100644 --- a/tests/mir-opt/gvn.transmute_then_cast_pointer.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn.transmute_then_cast_pointer.GVN.panic-abort.diff @@ -34,8 +34,7 @@ } bb0: { -- StorageLive(_3); -+ nop; + StorageLive(_3); StorageLive(_4); _4 = copy _1; - _3 = move _4 as *mut u8 (Transmute); @@ -54,8 +53,7 @@ bb1: { StorageDead(_6); StorageDead(_5); -- StorageLive(_8); -+ nop; + StorageLive(_8); StorageLive(_9); StorageLive(_10); StorageLive(_11); @@ -82,8 +80,7 @@ bb2: { StorageDead(_14); StorageDead(_13); -- StorageLive(_16); -+ nop; + StorageLive(_16); StorageLive(_17); _17 = copy _2; - _16 = move _17 as *const [u8] (Transmute); @@ -103,12 +100,9 @@ StorageDead(_19); StorageDead(_18); _0 = const (); -- StorageDead(_16); -- StorageDead(_8); -- StorageDead(_3); -+ nop; -+ nop; -+ nop; + StorageDead(_16); + StorageDead(_8); + StorageDead(_3); return; } } diff --git a/tests/mir-opt/gvn.transmute_then_cast_pointer.GVN.panic-unwind.diff b/tests/mir-opt/gvn.transmute_then_cast_pointer.GVN.panic-unwind.diff index 14f2fe08a86a2..a20b9cef59ae3 100644 --- a/tests/mir-opt/gvn.transmute_then_cast_pointer.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn.transmute_then_cast_pointer.GVN.panic-unwind.diff @@ -34,8 +34,7 @@ } bb0: { -- StorageLive(_3); -+ nop; + StorageLive(_3); StorageLive(_4); _4 = copy _1; - _3 = move _4 as *mut u8 (Transmute); @@ -54,8 +53,7 @@ bb1: { StorageDead(_6); StorageDead(_5); -- StorageLive(_8); -+ nop; + StorageLive(_8); StorageLive(_9); StorageLive(_10); StorageLive(_11); @@ -82,8 +80,7 @@ bb2: { StorageDead(_14); StorageDead(_13); -- StorageLive(_16); -+ nop; + StorageLive(_16); StorageLive(_17); _17 = copy _2; - _16 = move _17 as *const [u8] (Transmute); @@ -103,12 +100,9 @@ StorageDead(_19); StorageDead(_18); _0 = const (); -- StorageDead(_16); -- StorageDead(_8); -- StorageDead(_3); -+ nop; -+ nop; -+ nop; + StorageDead(_16); + StorageDead(_8); + StorageDead(_3); return; } } diff --git a/tests/mir-opt/gvn.transmute_then_transmute_again.GVN.panic-abort.diff b/tests/mir-opt/gvn.transmute_then_transmute_again.GVN.panic-abort.diff index 962fecd2586eb..7eea36055f57a 100644 --- a/tests/mir-opt/gvn.transmute_then_transmute_again.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn.transmute_then_transmute_again.GVN.panic-abort.diff @@ -23,8 +23,7 @@ } bb0: { -- StorageLive(_3); -+ nop; + StorageLive(_3); StorageLive(_4); _4 = copy _1; - _3 = move _4 as char (Transmute); @@ -43,8 +42,7 @@ bb1: { StorageDead(_6); StorageDead(_5); -- StorageLive(_8); -+ nop; + StorageLive(_8); StorageLive(_9); _9 = copy _2; - _8 = move _9 as u32 (Transmute); @@ -64,10 +62,8 @@ StorageDead(_11); StorageDead(_10); _0 = const (); -- StorageDead(_8); -- StorageDead(_3); -+ nop; -+ nop; + StorageDead(_8); + StorageDead(_3); return; } } diff --git a/tests/mir-opt/gvn.transmute_then_transmute_again.GVN.panic-unwind.diff b/tests/mir-opt/gvn.transmute_then_transmute_again.GVN.panic-unwind.diff index e32397c1aed07..b133b403729f4 100644 --- a/tests/mir-opt/gvn.transmute_then_transmute_again.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn.transmute_then_transmute_again.GVN.panic-unwind.diff @@ -23,8 +23,7 @@ } bb0: { -- StorageLive(_3); -+ nop; + StorageLive(_3); StorageLive(_4); _4 = copy _1; - _3 = move _4 as char (Transmute); @@ -43,8 +42,7 @@ bb1: { StorageDead(_6); StorageDead(_5); -- StorageLive(_8); -+ nop; + StorageLive(_8); StorageLive(_9); _9 = copy _2; - _8 = move _9 as u32 (Transmute); @@ -64,10 +62,8 @@ StorageDead(_11); StorageDead(_10); _0 = const (); -- StorageDead(_8); -- StorageDead(_3); -+ nop; -+ nop; + StorageDead(_8); + StorageDead(_3); return; } } diff --git a/tests/mir-opt/gvn.unary.GVN.panic-abort.diff b/tests/mir-opt/gvn.unary.GVN.panic-abort.diff index d14aec6df5fae..2b23b0a32d551 100644 --- a/tests/mir-opt/gvn.unary.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn.unary.GVN.panic-abort.diff @@ -51,8 +51,7 @@ bb1: { StorageDead(_3); StorageDead(_2); -- StorageLive(_6); -+ nop; + StorageLive(_6); StorageLive(_7); _7 = copy _1; - _6 = Lt(move _7, const 13_i64); @@ -145,8 +144,7 @@ StorageDead(_23); StorageDead(_22); _0 = const (); -- StorageDead(_6); -+ nop; + StorageDead(_6); return; } } diff --git a/tests/mir-opt/gvn.unary.GVN.panic-unwind.diff b/tests/mir-opt/gvn.unary.GVN.panic-unwind.diff index 5978f1faa1f68..a2ca0dcb18dbd 100644 --- a/tests/mir-opt/gvn.unary.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn.unary.GVN.panic-unwind.diff @@ -51,8 +51,7 @@ bb1: { StorageDead(_3); StorageDead(_2); -- StorageLive(_6); -+ nop; + StorageLive(_6); StorageLive(_7); _7 = copy _1; - _6 = Lt(move _7, const 13_i64); @@ -145,8 +144,7 @@ StorageDead(_23); StorageDead(_22); _0 = const (); -- StorageDead(_6); -+ nop; + StorageDead(_6); return; } } diff --git a/tests/mir-opt/gvn.wide_ptr_integer.GVN.panic-abort.diff b/tests/mir-opt/gvn.wide_ptr_integer.GVN.panic-abort.diff index bb938f3ba6a9a..0d0c17c7c76a8 100644 --- a/tests/mir-opt/gvn.wide_ptr_integer.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn.wide_ptr_integer.GVN.panic-abort.diff @@ -39,16 +39,14 @@ } bb0: { -- StorageLive(_1); -+ nop; + StorageLive(_1); StorageLive(_2); - _2 = (const 1_usize, const 1_usize); - _1 = move _2 as *const [u8] (Transmute); + _2 = const (1_usize, 1_usize); + _1 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8]; StorageDead(_2); -- StorageLive(_3); -+ nop; + StorageLive(_3); StorageLive(_4); - _4 = (const 1_usize, const 2_usize); - _3 = move _4 as *const [u8] (Transmute); @@ -170,10 +168,8 @@ StorageDead(_26); StorageDead(_25); _0 = const (); -- StorageDead(_3); -- StorageDead(_1); -+ nop; -+ nop; + StorageDead(_3); + StorageDead(_1); return; } } diff --git a/tests/mir-opt/gvn.wide_ptr_integer.GVN.panic-unwind.diff b/tests/mir-opt/gvn.wide_ptr_integer.GVN.panic-unwind.diff index 81432d687eb32..885ca25c32990 100644 --- a/tests/mir-opt/gvn.wide_ptr_integer.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn.wide_ptr_integer.GVN.panic-unwind.diff @@ -39,16 +39,14 @@ } bb0: { -- StorageLive(_1); -+ nop; + StorageLive(_1); StorageLive(_2); - _2 = (const 1_usize, const 1_usize); - _1 = move _2 as *const [u8] (Transmute); + _2 = const (1_usize, 1_usize); + _1 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8]; StorageDead(_2); -- StorageLive(_3); -+ nop; + StorageLive(_3); StorageLive(_4); - _4 = (const 1_usize, const 2_usize); - _3 = move _4 as *const [u8] (Transmute); @@ -170,10 +168,8 @@ StorageDead(_26); StorageDead(_25); _0 = const (); -- StorageDead(_3); -- StorageDead(_1); -+ nop; -+ nop; + StorageDead(_3); + StorageDead(_1); return; } } diff --git a/tests/mir-opt/gvn_clone.{impl#0}-clone.GVN.diff b/tests/mir-opt/gvn_clone.{impl#0}-clone.GVN.diff index 0f23415ec53bb..9381c7c0af537 100644 --- a/tests/mir-opt/gvn_clone.{impl#0}-clone.GVN.diff +++ b/tests/mir-opt/gvn_clone.{impl#0}-clone.GVN.diff @@ -17,8 +17,7 @@ bb0: { StorageLive(_2); StorageLive(_3); -- StorageLive(_4); -+ nop; + StorageLive(_4); _4 = &((*_1).0: i32); _3 = copy _4; - _2 = copy (*_3); @@ -30,8 +29,7 @@ StorageDead(_3); StorageLive(_5); StorageLive(_6); -- StorageLive(_7); -+ nop; + StorageLive(_7); _7 = &((*_1).1: u64); _6 = copy _7; - _5 = copy (*_6); @@ -43,8 +41,7 @@ StorageDead(_6); StorageLive(_8); StorageLive(_9); -- StorageLive(_10); -+ nop; + StorageLive(_10); _10 = &((*_1).2: [i8; 3]); _9 = copy _10; - _8 = copy (*_9); @@ -55,15 +52,12 @@ bb3: { StorageDead(_9); - _0 = AllCopy { a: move _2, b: move _5, c: move _8 }; -- StorageDead(_10); + _0 = copy (*_1); -+ nop; + StorageDead(_10); StorageDead(_8); -- StorageDead(_7); -+ nop; + StorageDead(_7); StorageDead(_5); -- StorageDead(_4); -+ nop; + StorageDead(_4); StorageDead(_2); return; } diff --git a/tests/mir-opt/gvn_copy_aggregate.all_copy.GVN.diff b/tests/mir-opt/gvn_copy_aggregate.all_copy.GVN.diff index f6345d5809f29..e88fc3e8553c3 100644 --- a/tests/mir-opt/gvn_copy_aggregate.all_copy.GVN.diff +++ b/tests/mir-opt/gvn_copy_aggregate.all_copy.GVN.diff @@ -21,14 +21,11 @@ } bb0: { -- StorageLive(_2); -+ nop; + StorageLive(_2); _2 = copy ((*_1).0: i32); -- StorageLive(_3); -+ nop; + StorageLive(_3); _3 = copy ((*_1).1: u64); -- StorageLive(_4); -+ nop; + StorageLive(_4); _4 = copy ((*_1).2: [i8; 3]); StorageLive(_5); _5 = copy _2; @@ -41,12 +38,9 @@ StorageDead(_7); StorageDead(_6); StorageDead(_5); -- StorageDead(_4); -- StorageDead(_3); -- StorageDead(_2); -+ nop; -+ nop; -+ nop; + StorageDead(_4); + StorageDead(_3); + StorageDead(_2); return; } } diff --git a/tests/mir-opt/gvn_copy_aggregate.all_copy_2.GVN.diff b/tests/mir-opt/gvn_copy_aggregate.all_copy_2.GVN.diff index eed8cb7d62e70..a9fb55f1d8f9a 100644 --- a/tests/mir-opt/gvn_copy_aggregate.all_copy_2.GVN.diff +++ b/tests/mir-opt/gvn_copy_aggregate.all_copy_2.GVN.diff @@ -24,20 +24,18 @@ } bb0: { -- StorageLive(_2); -+ nop; - _8 = copy (*_1); + StorageLive(_2); +- _8 = deref_copy (*_1); ++ _8 = copy (*_1); _2 = copy ((*_8).0: i32); -- StorageLive(_3); -- _9 = copy (*_1); + StorageLive(_3); +- _9 = deref_copy (*_1); - _3 = copy ((*_9).1: u64); -- StorageLive(_4); -- _10 = copy (*_1); -- _4 = copy ((*_10).2: [i8; 3]); -+ nop; + _9 = copy _8; + _3 = copy ((*_8).1: u64); -+ nop; + StorageLive(_4); +- _10 = deref_copy (*_1); +- _4 = copy ((*_10).2: [i8; 3]); + _10 = copy _8; + _4 = copy ((*_8).2: [i8; 3]); StorageLive(_5); @@ -51,12 +49,9 @@ StorageDead(_7); StorageDead(_6); StorageDead(_5); -- StorageDead(_4); -- StorageDead(_3); -- StorageDead(_2); -+ nop; -+ nop; -+ nop; + StorageDead(_4); + StorageDead(_3); + StorageDead(_2); return; } } diff --git a/tests/mir-opt/gvn_copy_aggregate.all_copy_different_type.GVN.diff b/tests/mir-opt/gvn_copy_aggregate.all_copy_different_type.GVN.diff index 37652095fa440..5f22429b4a2a1 100644 --- a/tests/mir-opt/gvn_copy_aggregate.all_copy_different_type.GVN.diff +++ b/tests/mir-opt/gvn_copy_aggregate.all_copy_different_type.GVN.diff @@ -21,14 +21,11 @@ } bb0: { -- StorageLive(_2); -+ nop; + StorageLive(_2); _2 = copy ((*_1).0: i32); -- StorageLive(_3); -+ nop; + StorageLive(_3); _3 = copy ((*_1).1: u64); -- StorageLive(_4); -+ nop; + StorageLive(_4); _4 = copy ((*_1).2: [i8; 3]); StorageLive(_5); _5 = copy _2; @@ -41,12 +38,9 @@ StorageDead(_7); StorageDead(_6); StorageDead(_5); -- StorageDead(_4); -- StorageDead(_3); -- StorageDead(_2); -+ nop; -+ nop; -+ nop; + StorageDead(_4); + StorageDead(_3); + StorageDead(_2); return; } } diff --git a/tests/mir-opt/gvn_copy_aggregate.all_copy_has_changed.GVN.diff b/tests/mir-opt/gvn_copy_aggregate.all_copy_has_changed.GVN.diff index 8012c26499c98..7a90189c4c496 100644 --- a/tests/mir-opt/gvn_copy_aggregate.all_copy_has_changed.GVN.diff +++ b/tests/mir-opt/gvn_copy_aggregate.all_copy_has_changed.GVN.diff @@ -21,14 +21,11 @@ } bb0: { -- StorageLive(_2); -+ nop; + StorageLive(_2); _2 = copy ((*_1).0: i32); -- StorageLive(_3); -+ nop; + StorageLive(_3); _3 = copy ((*_1).1: u64); -- StorageLive(_4); -+ nop; + StorageLive(_4); _4 = copy ((*_1).2: [i8; 3]); ((*_1).0: i32) = const 1_i32; StorageLive(_5); @@ -42,12 +39,9 @@ StorageDead(_7); StorageDead(_6); StorageDead(_5); -- StorageDead(_4); -- StorageDead(_3); -- StorageDead(_2); -+ nop; -+ nop; -+ nop; + StorageDead(_4); + StorageDead(_3); + StorageDead(_2); return; } } diff --git a/tests/mir-opt/gvn_copy_aggregate.all_copy_move.GVN.diff b/tests/mir-opt/gvn_copy_aggregate.all_copy_move.GVN.diff index 911b787a64bdb..416ee4ce7eea1 100644 --- a/tests/mir-opt/gvn_copy_aggregate.all_copy_move.GVN.diff +++ b/tests/mir-opt/gvn_copy_aggregate.all_copy_move.GVN.diff @@ -21,14 +21,11 @@ } bb0: { -- StorageLive(_2); -+ nop; + StorageLive(_2); _2 = copy (_1.0: i32); -- StorageLive(_3); -+ nop; + StorageLive(_3); _3 = copy (_1.1: u64); -- StorageLive(_4); -+ nop; + StorageLive(_4); _4 = copy (_1.2: [i8; 3]); StorageLive(_5); _5 = copy _2; @@ -41,12 +38,9 @@ StorageDead(_7); StorageDead(_6); StorageDead(_5); -- StorageDead(_4); -- StorageDead(_3); -- StorageDead(_2); -+ nop; -+ nop; -+ nop; + StorageDead(_4); + StorageDead(_3); + StorageDead(_2); return; } } diff --git a/tests/mir-opt/gvn_copy_aggregate.all_copy_ret_2.GVN.diff b/tests/mir-opt/gvn_copy_aggregate.all_copy_ret_2.GVN.diff index 5c6e2a6bc67db..fccbe492b4795 100644 --- a/tests/mir-opt/gvn_copy_aggregate.all_copy_ret_2.GVN.diff +++ b/tests/mir-opt/gvn_copy_aggregate.all_copy_ret_2.GVN.diff @@ -26,17 +26,13 @@ } bb0: { -- StorageLive(_2); -+ nop; + StorageLive(_2); _2 = copy ((*_1).0: i32); -- StorageLive(_3); -+ nop; + StorageLive(_3); _3 = copy ((*_1).1: u64); -- StorageLive(_4); -+ nop; + StorageLive(_4); _4 = copy ((*_1).2: [i8; 3]); -- StorageLive(_5); -+ nop; + StorageLive(_5); StorageLive(_6); _6 = copy _2; StorageLive(_7); @@ -63,14 +59,10 @@ - _0 = (move _5, move _9); + _0 = (copy _5, copy _5); StorageDead(_9); -- StorageDead(_5); -- StorageDead(_4); -- StorageDead(_3); -- StorageDead(_2); -+ nop; -+ nop; -+ nop; -+ nop; + StorageDead(_5); + StorageDead(_4); + StorageDead(_3); + StorageDead(_2); return; } } diff --git a/tests/mir-opt/gvn_copy_aggregate.all_copy_use_changed.GVN.diff b/tests/mir-opt/gvn_copy_aggregate.all_copy_use_changed.GVN.diff index dc65cccb7bd6e..e3842c9064fe4 100644 --- a/tests/mir-opt/gvn_copy_aggregate.all_copy_use_changed.GVN.diff +++ b/tests/mir-opt/gvn_copy_aggregate.all_copy_use_changed.GVN.diff @@ -29,11 +29,9 @@ _3 = copy ((*_1).0: i32); _2 = move _3; StorageDead(_3); -- StorageLive(_4); -+ nop; + StorageLive(_4); _4 = copy ((*_1).1: u64); -- StorageLive(_5); -+ nop; + StorageLive(_5); _5 = copy ((*_1).2: [i8; 3]); StorageLive(_6); _6 = copy _2; @@ -46,10 +44,8 @@ StorageDead(_8); StorageDead(_7); StorageDead(_6); -- StorageDead(_5); -- StorageDead(_4); -+ nop; -+ nop; + StorageDead(_5); + StorageDead(_4); StorageDead(_2); return; } diff --git a/tests/mir-opt/gvn_copy_aggregate.all_copy_use_changed_2.GVN.diff b/tests/mir-opt/gvn_copy_aggregate.all_copy_use_changed_2.GVN.diff index 08a4a078adcb4..3769c3cfa2ee4 100644 --- a/tests/mir-opt/gvn_copy_aggregate.all_copy_use_changed_2.GVN.diff +++ b/tests/mir-opt/gvn_copy_aggregate.all_copy_use_changed_2.GVN.diff @@ -24,11 +24,9 @@ bb0: { StorageLive(_2); _2 = copy ((*_1).0: i32); -- StorageLive(_3); -+ nop; + StorageLive(_3); _3 = copy ((*_1).1: u64); -- StorageLive(_4); -+ nop; + StorageLive(_4); _4 = copy ((*_1).2: [i8; 3]); ((*_1).0: i32) = const 1_i32; StorageLive(_5); @@ -46,10 +44,8 @@ StorageDead(_8); StorageDead(_7); StorageDead(_6); -- StorageDead(_4); -- StorageDead(_3); -+ nop; -+ nop; + StorageDead(_4); + StorageDead(_3); StorageDead(_2); return; } diff --git a/tests/mir-opt/gvn_copy_aggregate.enum_different_variant.GVN.diff b/tests/mir-opt/gvn_copy_aggregate.enum_different_variant.GVN.diff index 99318d395e218..a7063289e8ae6 100644 --- a/tests/mir-opt/gvn_copy_aggregate.enum_different_variant.GVN.diff +++ b/tests/mir-opt/gvn_copy_aggregate.enum_different_variant.GVN.diff @@ -66,20 +66,16 @@ bb2: { StorageLive(_12); _12 = &(((*_1) as B).0: AllCopy); -- StorageLive(_13); + StorageLive(_13); - _13 = copy ((*_12).0: i32); -- StorageLive(_14); -- _14 = copy ((*_12).1: u64); -- StorageLive(_15); -- _15 = copy ((*_12).2: [i8; 3]); -- StorageLive(_16); -+ nop; + _13 = copy ((((*_1) as B).0: AllCopy).0: i32); -+ nop; + StorageLive(_14); +- _14 = copy ((*_12).1: u64); + _14 = copy ((((*_1) as B).0: AllCopy).1: u64); -+ nop; + StorageLive(_15); +- _15 = copy ((*_12).2: [i8; 3]); + _15 = copy ((((*_1) as B).0: AllCopy).2: [i8; 3]); -+ nop; + StorageLive(_16); StorageLive(_17); _17 = copy _13; StorageLive(_18); @@ -97,14 +93,10 @@ + _20 = copy _16; + _0 = Enum1::A(copy _16); StorageDead(_20); -- StorageDead(_16); -- StorageDead(_15); -- StorageDead(_14); -- StorageDead(_13); -+ nop; -+ nop; -+ nop; -+ nop; + StorageDead(_16); + StorageDead(_15); + StorageDead(_14); + StorageDead(_13); StorageDead(_12); goto -> bb4; } @@ -112,20 +104,16 @@ bb3: { StorageLive(_3); _3 = &(((*_1) as A).0: AllCopy); -- StorageLive(_4); + StorageLive(_4); - _4 = copy ((*_3).0: i32); -- StorageLive(_5); -- _5 = copy ((*_3).1: u64); -- StorageLive(_6); -- _6 = copy ((*_3).2: [i8; 3]); -- StorageLive(_7); -+ nop; + _4 = copy ((((*_1) as A).0: AllCopy).0: i32); -+ nop; + StorageLive(_5); +- _5 = copy ((*_3).1: u64); + _5 = copy ((((*_1) as A).0: AllCopy).1: u64); -+ nop; + StorageLive(_6); +- _6 = copy ((*_3).2: [i8; 3]); + _6 = copy ((((*_1) as A).0: AllCopy).2: [i8; 3]); -+ nop; + StorageLive(_7); StorageLive(_8); _8 = copy _4; StorageLive(_9); @@ -143,14 +131,10 @@ + _11 = copy _7; + _0 = Enum1::B(copy _7); StorageDead(_11); -- StorageDead(_7); -- StorageDead(_6); -- StorageDead(_5); -- StorageDead(_4); -+ nop; -+ nop; -+ nop; -+ nop; + StorageDead(_7); + StorageDead(_6); + StorageDead(_5); + StorageDead(_4); StorageDead(_3); goto -> bb4; } diff --git a/tests/mir-opt/gvn_copy_aggregate.enum_identical_variant.GVN.diff b/tests/mir-opt/gvn_copy_aggregate.enum_identical_variant.GVN.diff index b740ba6411bd2..22ebaa5ca1932 100644 --- a/tests/mir-opt/gvn_copy_aggregate.enum_identical_variant.GVN.diff +++ b/tests/mir-opt/gvn_copy_aggregate.enum_identical_variant.GVN.diff @@ -66,20 +66,16 @@ bb2: { StorageLive(_12); _12 = &(((*_1) as B).0: AllCopy); -- StorageLive(_13); + StorageLive(_13); - _13 = copy ((*_12).0: i32); -- StorageLive(_14); -- _14 = copy ((*_12).1: u64); -- StorageLive(_15); -- _15 = copy ((*_12).2: [i8; 3]); -- StorageLive(_16); -+ nop; + _13 = copy ((((*_1) as B).0: AllCopy).0: i32); -+ nop; + StorageLive(_14); +- _14 = copy ((*_12).1: u64); + _14 = copy ((((*_1) as B).0: AllCopy).1: u64); -+ nop; + StorageLive(_15); +- _15 = copy ((*_12).2: [i8; 3]); + _15 = copy ((((*_1) as B).0: AllCopy).2: [i8; 3]); -+ nop; + StorageLive(_16); StorageLive(_17); _17 = copy _13; StorageLive(_18); @@ -97,14 +93,10 @@ + _20 = copy _16; + _0 = copy (*_1); StorageDead(_20); -- StorageDead(_16); -- StorageDead(_15); -- StorageDead(_14); -- StorageDead(_13); -+ nop; -+ nop; -+ nop; -+ nop; + StorageDead(_16); + StorageDead(_15); + StorageDead(_14); + StorageDead(_13); StorageDead(_12); goto -> bb4; } @@ -112,20 +104,16 @@ bb3: { StorageLive(_3); _3 = &(((*_1) as A).0: AllCopy); -- StorageLive(_4); + StorageLive(_4); - _4 = copy ((*_3).0: i32); -- StorageLive(_5); -- _5 = copy ((*_3).1: u64); -- StorageLive(_6); -- _6 = copy ((*_3).2: [i8; 3]); -- StorageLive(_7); -+ nop; + _4 = copy ((((*_1) as A).0: AllCopy).0: i32); -+ nop; + StorageLive(_5); +- _5 = copy ((*_3).1: u64); + _5 = copy ((((*_1) as A).0: AllCopy).1: u64); -+ nop; + StorageLive(_6); +- _6 = copy ((*_3).2: [i8; 3]); + _6 = copy ((((*_1) as A).0: AllCopy).2: [i8; 3]); -+ nop; + StorageLive(_7); StorageLive(_8); _8 = copy _4; StorageLive(_9); @@ -143,14 +131,10 @@ + _11 = copy _7; + _0 = copy (*_1); StorageDead(_11); -- StorageDead(_7); -- StorageDead(_6); -- StorageDead(_5); -- StorageDead(_4); -+ nop; -+ nop; -+ nop; -+ nop; + StorageDead(_7); + StorageDead(_6); + StorageDead(_5); + StorageDead(_4); StorageDead(_3); goto -> bb4; } diff --git a/tests/mir-opt/gvn_copy_aggregate.nest_copy.GVN.diff b/tests/mir-opt/gvn_copy_aggregate.nest_copy.GVN.diff index ee5906bab1161..f8515be75b8de 100644 --- a/tests/mir-opt/gvn_copy_aggregate.nest_copy.GVN.diff +++ b/tests/mir-opt/gvn_copy_aggregate.nest_copy.GVN.diff @@ -31,17 +31,13 @@ } bb0: { -- StorageLive(_2); -+ nop; + StorageLive(_2); _2 = copy (((*_1).1: AllCopy).0: i32); -- StorageLive(_3); -+ nop; + StorageLive(_3); _3 = copy (((*_1).1: AllCopy).1: u64); -- StorageLive(_4); -+ nop; + StorageLive(_4); _4 = copy (((*_1).1: AllCopy).2: [i8; 3]); -- StorageLive(_5); -+ nop; + StorageLive(_5); StorageLive(_6); _6 = copy _2; StorageLive(_7); @@ -53,8 +49,7 @@ StorageDead(_8); StorageDead(_7); StorageDead(_6); -- StorageLive(_9); -+ nop; + StorageLive(_9); _9 = copy ((*_1).0: i32); StorageLive(_10); _10 = copy _9; @@ -65,16 +60,11 @@ + _0 = copy (*_1); StorageDead(_11); StorageDead(_10); -- StorageDead(_9); -- StorageDead(_5); -- StorageDead(_4); -- StorageDead(_3); -- StorageDead(_2); -+ nop; -+ nop; -+ nop; -+ nop; -+ nop; + StorageDead(_9); + StorageDead(_5); + StorageDead(_4); + StorageDead(_3); + StorageDead(_2); return; } } diff --git a/tests/mir-opt/gvn_copy_aggregate.same_type_different_index.GVN.diff b/tests/mir-opt/gvn_copy_aggregate.same_type_different_index.GVN.diff index e3126b09a58e2..9c214330e352e 100644 --- a/tests/mir-opt/gvn_copy_aggregate.same_type_different_index.GVN.diff +++ b/tests/mir-opt/gvn_copy_aggregate.same_type_different_index.GVN.diff @@ -16,11 +16,9 @@ } bb0: { -- StorageLive(_2); -+ nop; + StorageLive(_2); _2 = copy ((*_1).1: i32); -- StorageLive(_3); -+ nop; + StorageLive(_3); _3 = copy ((*_1).0: i32); StorageLive(_4); _4 = copy _2; @@ -30,10 +28,8 @@ + _0 = SameType { a: copy _2, b: copy _3 }; StorageDead(_5); StorageDead(_4); -- StorageDead(_3); -- StorageDead(_2); -+ nop; -+ nop; + StorageDead(_3); + StorageDead(_2); return; } } diff --git a/tests/mir-opt/gvn_copy_constant_projection.compare_constant_index.GVN.panic-abort.diff b/tests/mir-opt/gvn_copy_constant_projection.compare_constant_index.GVN.panic-abort.diff index e2e55304921b2..c107eec9ee65b 100644 --- a/tests/mir-opt/gvn_copy_constant_projection.compare_constant_index.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn_copy_constant_projection.compare_constant_index.GVN.panic-abort.diff @@ -17,8 +17,7 @@ } bb0: { -- StorageLive(_4); -+ nop; + StorageLive(_4); _4 = const 0_usize; - _5 = Lt(copy _4, const 1_usize); - assert(move _5, "index out of bounds: the length is {} but the index is {}", const 1_usize, copy _4) -> [success: bb1, unwind unreachable]; @@ -50,8 +49,7 @@ StorageDead(_10); StorageDead(_9); StorageDead(_7); -- StorageDead(_4); -+ nop; + StorageDead(_4); return; } } diff --git a/tests/mir-opt/gvn_copy_constant_projection.compare_constant_index.GVN.panic-unwind.diff b/tests/mir-opt/gvn_copy_constant_projection.compare_constant_index.GVN.panic-unwind.diff index 60611146a0eec..498df5adc1ef7 100644 --- a/tests/mir-opt/gvn_copy_constant_projection.compare_constant_index.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn_copy_constant_projection.compare_constant_index.GVN.panic-unwind.diff @@ -17,8 +17,7 @@ } bb0: { -- StorageLive(_4); -+ nop; + StorageLive(_4); _4 = const 0_usize; - _5 = Lt(copy _4, const 1_usize); - assert(move _5, "index out of bounds: the length is {} but the index is {}", const 1_usize, copy _4) -> [success: bb1, unwind continue]; @@ -50,8 +49,7 @@ StorageDead(_10); StorageDead(_9); StorageDead(_7); -- StorageDead(_4); -+ nop; + StorageDead(_4); return; } } diff --git a/tests/mir-opt/gvn_on_unsafe_binder.propagate.GVN.diff b/tests/mir-opt/gvn_on_unsafe_binder.propagate.GVN.diff index e28d04f1d5885..cef44cb99d66c 100644 --- a/tests/mir-opt/gvn_on_unsafe_binder.propagate.GVN.diff +++ b/tests/mir-opt/gvn_on_unsafe_binder.propagate.GVN.diff @@ -14,8 +14,7 @@ } bb0: { -- StorageLive(_1); -+ nop; + StorageLive(_1); _1 = const 1_i32; StorageLive(_2); StorageLive(_3); @@ -27,8 +26,7 @@ - _0 = move _2; + _0 = const {transmute(0x00000001): unsafe<> i32}; StorageDead(_2); -- StorageDead(_1); -+ nop; + StorageDead(_1); return; } } diff --git a/tests/mir-opt/gvn_storage_twice.repeat_local.GVN.diff b/tests/mir-opt/gvn_storage_twice.repeat_local.GVN.diff new file mode 100644 index 0000000000000..1c399d42d6fc9 --- /dev/null +++ b/tests/mir-opt/gvn_storage_twice.repeat_local.GVN.diff @@ -0,0 +1,17 @@ +- // MIR for `repeat_local` before GVN ++ // MIR for `repeat_local` after GVN + + fn repeat_local(_1: usize, _2: usize, _3: i32) -> i32 { + let mut _0: i32; + let mut _4: [i32; 5]; + let mut _5: &i32; + + bb0: { + _4 = [copy _3; 5]; + _5 = &_4[_1]; +- _0 = copy (*_5); ++ _0 = copy _3; + return; + } + } + diff --git a/tests/mir-opt/gvn_storage_twice.repeat_local_dead.GVN.diff b/tests/mir-opt/gvn_storage_twice.repeat_local_dead.GVN.diff new file mode 100644 index 0000000000000..ee044aa5a0b18 --- /dev/null +++ b/tests/mir-opt/gvn_storage_twice.repeat_local_dead.GVN.diff @@ -0,0 +1,19 @@ +- // MIR for `repeat_local_dead` before GVN ++ // MIR for `repeat_local_dead` after GVN + + fn repeat_local_dead(_1: usize, _2: usize, _3: i32) -> i32 { + let mut _0: i32; + let mut _4: [i32; 5]; + let mut _5: &i32; + + bb0: { + _4 = [copy _3; 5]; + _5 = &_4[_1]; +- StorageDead(_3); +- _0 = copy (*_5); ++ nop; ++ _0 = copy _3; + return; + } + } + diff --git a/tests/mir-opt/gvn_storage_twice.repeat_local_dead_live.GVN.diff b/tests/mir-opt/gvn_storage_twice.repeat_local_dead_live.GVN.diff new file mode 100644 index 0000000000000..9448e91d33a3e --- /dev/null +++ b/tests/mir-opt/gvn_storage_twice.repeat_local_dead_live.GVN.diff @@ -0,0 +1,21 @@ +- // MIR for `repeat_local_dead_live` before GVN ++ // MIR for `repeat_local_dead_live` after GVN + + fn repeat_local_dead_live(_1: usize, _2: usize, _3: i32) -> i32 { + let mut _0: i32; + let mut _4: [i32; 5]; + let mut _5: &i32; + + bb0: { + _4 = [copy _3; 5]; + _5 = &_4[_1]; +- StorageDead(_3); +- StorageLive(_3); +- _0 = copy (*_5); ++ nop; ++ nop; ++ _0 = copy _3; + return; + } + } + diff --git a/tests/mir-opt/gvn_storage_twice.rs b/tests/mir-opt/gvn_storage_twice.rs new file mode 100644 index 0000000000000..d6aa0ed87befe --- /dev/null +++ b/tests/mir-opt/gvn_storage_twice.rs @@ -0,0 +1,65 @@ +// skip-filecheck +//@ test-mir-pass: GVN +//@ compile-flags: -Zlint-mir=false + +#![feature(custom_mir, core_intrinsics)] + +use std::intrinsics::mir::*; + +// EMIT_MIR gvn_storage_twice.repeat_local.GVN.diff +// EMIT_MIR gvn_storage_twice.repeat_local_dead.GVN.diff +// EMIT_MIR gvn_storage_twice.repeat_local_dead_live.GVN.diff + +// Check that we remove the storage statements if the local +// doesn't have valid storage when it is used. +// +// Based on `gvn_repeat.rs::repeat_local`, were GVN should replace +// `let RET = *_5;` with `let RET = _3;`. + +#[custom_mir(dialect = "runtime")] +pub fn repeat_local(_1: usize, _2: usize, _3: i32) -> i32 { + mir! { + { + let _4 = [_3; 5]; + let _5 = &_4[_1]; + RET = *_5; + Return() + } + } +} + +// Since _3 is dead when we access _5, GVN should remove the storage statements. + +#[custom_mir(dialect = "runtime")] +pub fn repeat_local_dead(_1: usize, _2: usize, _3: i32) -> i32 { + mir! { + { + let _4 = [_3; 5]; + let _5 = &_4[_1]; + StorageDead(_3); + RET = *_5; + Return() + } + } +} + +// Since _3 is uninit due to storage when we access _5, GVN should remove the storage statements. + +#[custom_mir(dialect = "runtime")] +pub fn repeat_local_dead_live(_1: usize, _2: usize, _3: i32) -> i32 { + mir! { + { + let _4 = [_3; 5]; + let _5 = &_4[_1]; + StorageDead(_3); + StorageLive(_3); + RET = *_5; + Return() + } + } +} + +#[inline(never)] +fn opaque(a: T) -> T { + a +} diff --git a/tests/mir-opt/inline/inline_diverging.h.Inline.panic-abort.diff b/tests/mir-opt/inline/inline_diverging.h.Inline.panic-abort.diff index f099d763c3d8d..a116086a0ce14 100644 --- a/tests/mir-opt/inline/inline_diverging.h.Inline.panic-abort.diff +++ b/tests/mir-opt/inline/inline_diverging.h.Inline.panic-abort.diff @@ -35,7 +35,6 @@ + StorageLive(_2); + _2 = sleep; + StorageLive(_4); -+ StorageLive(_6); + StorageLive(_3); + _3 = &_2; + StorageLive(_7); diff --git a/tests/mir-opt/inline/inline_diverging.h.Inline.panic-unwind.diff b/tests/mir-opt/inline/inline_diverging.h.Inline.panic-unwind.diff index c33e0810739f2..978de2884c081 100644 --- a/tests/mir-opt/inline/inline_diverging.h.Inline.panic-unwind.diff +++ b/tests/mir-opt/inline/inline_diverging.h.Inline.panic-unwind.diff @@ -35,7 +35,6 @@ - _1 = call_twice:: ! {sleep}>(sleep) -> unwind continue; + StorageLive(_2); + _2 = sleep; -+ StorageLive(_6); + StorageLive(_4); + StorageLive(_3); + _3 = &_2; diff --git a/tests/mir-opt/issue_141649_gvn_storage_remove.main.GVN.panic-abort.diff b/tests/mir-opt/issue_141649_gvn_storage_remove.main.GVN.panic-abort.diff index 5e19645ed5b7d..79230f8e354a5 100644 --- a/tests/mir-opt/issue_141649_gvn_storage_remove.main.GVN.panic-abort.diff +++ b/tests/mir-opt/issue_141649_gvn_storage_remove.main.GVN.panic-abort.diff @@ -33,9 +33,8 @@ bb0: { StorageLive(_1); -- StorageLive(_2); + StorageLive(_2); - _2 = S(const 1_u32, const 2_u32); -+ nop; + _2 = const S(1_u32, 2_u32); StorageLive(_3); StorageLive(_4); @@ -49,13 +48,11 @@ StorageDead(_4); StorageDead(_3); _1 = const (); -- StorageDead(_2); -+ nop; + StorageDead(_2); StorageDead(_1); StorageLive(_5); -- StorageLive(_6); + StorageLive(_6); - _6 = S(const 3_u32, const 4_u32); -+ nop; + _6 = const S(3_u32, 4_u32); StorageLive(_7); StorageLive(_8); @@ -69,13 +66,11 @@ StorageDead(_8); StorageDead(_7); _5 = const (); -- StorageDead(_6); -+ nop; + StorageDead(_6); StorageDead(_5); StorageLive(_9); -- StorageLive(_10); + StorageLive(_10); - _10 = C(const 1_u32, const 2_u32); -+ nop; + _10 = const C(1_u32, 2_u32); StorageLive(_11); StorageLive(_12); @@ -89,12 +84,10 @@ StorageDead(_12); StorageDead(_11); _9 = const (); -- StorageDead(_10); -+ nop; + StorageDead(_10); StorageDead(_9); -- StorageLive(_13); + StorageLive(_13); - _13 = C(const 3_u32, const 4_u32); -+ nop; + _13 = const C(3_u32, 4_u32); StorageLive(_14); StorageLive(_15); @@ -108,8 +101,7 @@ StorageDead(_15); StorageDead(_14); _0 = const (); -- StorageDead(_13); -+ nop; + StorageDead(_13); return; } + } diff --git a/tests/mir-opt/issue_141649_gvn_storage_remove.main.GVN.panic-unwind.diff b/tests/mir-opt/issue_141649_gvn_storage_remove.main.GVN.panic-unwind.diff index 8f60f2f63e0f6..a9c68d742f504 100644 --- a/tests/mir-opt/issue_141649_gvn_storage_remove.main.GVN.panic-unwind.diff +++ b/tests/mir-opt/issue_141649_gvn_storage_remove.main.GVN.panic-unwind.diff @@ -33,9 +33,8 @@ bb0: { StorageLive(_1); -- StorageLive(_2); + StorageLive(_2); - _2 = S(const 1_u32, const 2_u32); -+ nop; + _2 = const S(1_u32, 2_u32); StorageLive(_3); StorageLive(_4); @@ -49,13 +48,11 @@ StorageDead(_4); StorageDead(_3); _1 = const (); -- StorageDead(_2); -+ nop; + StorageDead(_2); StorageDead(_1); StorageLive(_5); -- StorageLive(_6); + StorageLive(_6); - _6 = S(const 3_u32, const 4_u32); -+ nop; + _6 = const S(3_u32, 4_u32); StorageLive(_7); StorageLive(_8); @@ -69,13 +66,11 @@ StorageDead(_8); StorageDead(_7); _5 = const (); -- StorageDead(_6); -+ nop; + StorageDead(_6); StorageDead(_5); StorageLive(_9); -- StorageLive(_10); + StorageLive(_10); - _10 = C(const 1_u32, const 2_u32); -+ nop; + _10 = const C(1_u32, 2_u32); StorageLive(_11); StorageLive(_12); @@ -89,12 +84,10 @@ StorageDead(_12); StorageDead(_11); _9 = const (); -- StorageDead(_10); -+ nop; + StorageDead(_10); StorageDead(_9); -- StorageLive(_13); + StorageLive(_13); - _13 = C(const 3_u32, const 4_u32); -+ nop; + _13 = const C(3_u32, 4_u32); StorageLive(_14); StorageLive(_15); @@ -108,8 +101,7 @@ StorageDead(_15); StorageDead(_14); _0 = const (); -- StorageDead(_13); -+ nop; + StorageDead(_13); return; } + } diff --git a/tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-abort.diff b/tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-abort.diff index 614d9ad440d20..a01b10364a01d 100644 --- a/tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-abort.diff +++ b/tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-abort.diff @@ -7,43 +7,49 @@ let _2: &[T]; let _3: &[T; 3]; let _4: [T; 3]; - let mut _8: !; + let mut _5: usize; + let mut _6: bool; + let mut _10: !; scope 1 { debug v => _2; - let _5: &T; - let _6: &T; let _7: &T; + let _8: &T; + let _9: &T; scope 2 { - debug v1 => _5; - debug v2 => _6; - debug v3 => _7; + debug v1 => _7; + debug v2 => _8; + debug v3 => _9; } } bb0: { + StorageLive(_3); StorageLive(_4); _4 = [copy _1, copy _1, copy _1]; _3 = &_4; _2 = copy _3 as &[T] (PointerCoercion(Unsize, Implicit)); + StorageDead(_3); + nop; + nop; goto -> bb2; } bb1: { - _8 = core::panicking::panic(const "internal error: entered unreachable code") -> unwind unreachable; + _10 = core::panicking::panic(const "internal error: entered unreachable code") -> unwind unreachable; } bb2: { - // DBG: _5 = &(*_2)[0 of 3]; - // DBG: _6 = &(*_2)[1 of 3]; - // DBG: _7 = &(*_2)[2 of 3]; + StorageLive(_7); + _7 = &(*_2)[0 of 3]; + StorageLive(_8); + _8 = &(*_2)[1 of 3]; + StorageLive(_9); + _9 = &(*_2)[2 of 3]; + StorageDead(_9); + StorageDead(_8); + StorageDead(_7); StorageDead(_4); return; } } - ALLOC0 (size: 40, align: 1) { - 0x00 │ 69 6e 74 65 72 6e 61 6c 20 65 72 72 6f 72 3a 20 │ internal error: - 0x10 │ 65 6e 74 65 72 65 64 20 75 6e 72 65 61 63 68 61 │ entered unreacha - 0x20 │ 62 6c 65 20 63 6f 64 65 │ ble code - } - diff --git a/tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-unwind.diff b/tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-unwind.diff index 57a88cf898412..dd5d700863646 100644 --- a/tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-unwind.diff +++ b/tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-unwind.diff @@ -7,43 +7,49 @@ let _2: &[T]; let _3: &[T; 3]; let _4: [T; 3]; - let mut _8: !; + let mut _5: usize; + let mut _6: bool; + let mut _10: !; scope 1 { debug v => _2; - let _5: &T; - let _6: &T; let _7: &T; + let _8: &T; + let _9: &T; scope 2 { - debug v1 => _5; - debug v2 => _6; - debug v3 => _7; + debug v1 => _7; + debug v2 => _8; + debug v3 => _9; } } bb0: { + StorageLive(_3); StorageLive(_4); _4 = [copy _1, copy _1, copy _1]; _3 = &_4; _2 = copy _3 as &[T] (PointerCoercion(Unsize, Implicit)); + StorageDead(_3); + nop; + nop; goto -> bb2; } bb1: { - _8 = core::panicking::panic(const "internal error: entered unreachable code") -> unwind continue; + _10 = core::panicking::panic(const "internal error: entered unreachable code") -> unwind continue; } bb2: { - // DBG: _5 = &(*_2)[0 of 3]; - // DBG: _6 = &(*_2)[1 of 3]; - // DBG: _7 = &(*_2)[2 of 3]; + StorageLive(_7); + _7 = &(*_2)[0 of 3]; + StorageLive(_8); + _8 = &(*_2)[1 of 3]; + StorageLive(_9); + _9 = &(*_2)[2 of 3]; + StorageDead(_9); + StorageDead(_8); + StorageDead(_7); StorageDead(_4); return; } } - ALLOC0 (size: 40, align: 1) { - 0x00 │ 69 6e 74 65 72 6e 61 6c 20 65 72 72 6f 72 3a 20 │ internal error: - 0x10 │ 65 6e 74 65 72 65 64 20 75 6e 72 65 61 63 68 61 │ entered unreacha - 0x20 │ 62 6c 65 20 63 6f 64 65 │ ble code - } - diff --git a/tests/mir-opt/issues/issue_75439.foo.MatchBranchSimplification.diff b/tests/mir-opt/issues/issue_75439.foo.MatchBranchSimplification.diff index d8eace98d556e..febcb0944c710 100644 --- a/tests/mir-opt/issues/issue_75439.foo.MatchBranchSimplification.diff +++ b/tests/mir-opt/issues/issue_75439.foo.MatchBranchSimplification.diff @@ -29,11 +29,13 @@ } bb3: { + StorageLive(_3); _3 = copy _2[3 of 4]; StorageLive(_4); _4 = copy _3 as [u8; 4] (Transmute); _0 = Option::<[u8; 4]>::Some(move _4); StorageDead(_4); + StorageDead(_3); goto -> bb5; } diff --git a/tests/mir-opt/lower_array_len.array_bound.GVN.panic-abort.diff b/tests/mir-opt/lower_array_len.array_bound.GVN.panic-abort.diff index 98c5e868046b5..c0500ca3bb835 100644 --- a/tests/mir-opt/lower_array_len.array_bound.GVN.panic-abort.diff +++ b/tests/mir-opt/lower_array_len.array_bound.GVN.panic-abort.diff @@ -14,8 +14,7 @@ let mut _9: bool; bb0: { -- StorageLive(_3); -+ nop; + StorageLive(_3); StorageLive(_4); _4 = copy _1; StorageLive(_5); @@ -63,8 +62,7 @@ } bb5: { -- StorageDead(_3); -+ nop; + StorageDead(_3); return; } } diff --git a/tests/mir-opt/lower_array_len.array_bound.GVN.panic-unwind.diff b/tests/mir-opt/lower_array_len.array_bound.GVN.panic-unwind.diff index 72c7313786996..9e6d01764ccd5 100644 --- a/tests/mir-opt/lower_array_len.array_bound.GVN.panic-unwind.diff +++ b/tests/mir-opt/lower_array_len.array_bound.GVN.panic-unwind.diff @@ -14,8 +14,7 @@ let mut _9: bool; bb0: { -- StorageLive(_3); -+ nop; + StorageLive(_3); StorageLive(_4); _4 = copy _1; StorageLive(_5); @@ -63,8 +62,7 @@ } bb5: { -- StorageDead(_3); -+ nop; + StorageDead(_3); return; } } diff --git a/tests/mir-opt/lower_array_len.array_bound_mut.GVN.panic-abort.diff b/tests/mir-opt/lower_array_len.array_bound_mut.GVN.panic-abort.diff index 9ffaf44c02bd2..b2d0efff8f30a 100644 --- a/tests/mir-opt/lower_array_len.array_bound_mut.GVN.panic-abort.diff +++ b/tests/mir-opt/lower_array_len.array_bound_mut.GVN.panic-abort.diff @@ -16,8 +16,7 @@ let mut _11: bool; bb0: { -- StorageLive(_3); -+ nop; + StorageLive(_3); StorageLive(_4); _4 = copy _1; StorageLive(_5); @@ -77,8 +76,7 @@ } bb6: { -- StorageDead(_3); -+ nop; + StorageDead(_3); return; } } diff --git a/tests/mir-opt/lower_array_len.array_bound_mut.GVN.panic-unwind.diff b/tests/mir-opt/lower_array_len.array_bound_mut.GVN.panic-unwind.diff index 08008e463357f..ab5209eca7592 100644 --- a/tests/mir-opt/lower_array_len.array_bound_mut.GVN.panic-unwind.diff +++ b/tests/mir-opt/lower_array_len.array_bound_mut.GVN.panic-unwind.diff @@ -16,8 +16,7 @@ let mut _11: bool; bb0: { -- StorageLive(_3); -+ nop; + StorageLive(_3); StorageLive(_4); _4 = copy _1; StorageLive(_5); @@ -77,8 +76,7 @@ } bb6: { -- StorageDead(_3); -+ nop; + StorageDead(_3); return; } } diff --git a/tests/mir-opt/pre-codegen/checked_ops.use_checked_sub.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/checked_ops.use_checked_sub.PreCodegen.after.panic-abort.mir index 3c475cd403091..426c114dfc2ab 100644 --- a/tests/mir-opt/pre-codegen/checked_ops.use_checked_sub.PreCodegen.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/checked_ops.use_checked_sub.PreCodegen.after.panic-abort.mir @@ -19,7 +19,7 @@ fn use_checked_sub(_1: u32, _2: u32) -> () { StorageLive(_5); StorageLive(_3); _3 = Lt(copy _1, copy _2); - switchInt(move _3) -> [0: bb1, otherwise: bb2]; + switchInt(move _3) -> [0: bb1, otherwise: bb3]; } bb1: { @@ -28,16 +28,22 @@ fn use_checked_sub(_1: u32, _2: u32) -> () { _5 = Option::::Some(move _4); StorageDead(_4); StorageDead(_3); + StorageLive(_6); _6 = copy ((_5 as Some).0: u32); - _7 = do_something(move _6) -> [return: bb3, unwind unreachable]; + _7 = do_something(move _6) -> [return: bb2, unwind unreachable]; } bb2: { - StorageDead(_3); - goto -> bb3; + StorageDead(_6); + goto -> bb4; } bb3: { + StorageDead(_3); + goto -> bb4; + } + + bb4: { StorageDead(_5); return; } diff --git a/tests/mir-opt/pre-codegen/checked_ops.use_checked_sub.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/checked_ops.use_checked_sub.PreCodegen.after.panic-unwind.mir index 3ef09764b1c5b..f73c64a9b0929 100644 --- a/tests/mir-opt/pre-codegen/checked_ops.use_checked_sub.PreCodegen.after.panic-unwind.mir +++ b/tests/mir-opt/pre-codegen/checked_ops.use_checked_sub.PreCodegen.after.panic-unwind.mir @@ -19,7 +19,7 @@ fn use_checked_sub(_1: u32, _2: u32) -> () { StorageLive(_5); StorageLive(_3); _3 = Lt(copy _1, copy _2); - switchInt(move _3) -> [0: bb1, otherwise: bb2]; + switchInt(move _3) -> [0: bb1, otherwise: bb3]; } bb1: { @@ -28,16 +28,22 @@ fn use_checked_sub(_1: u32, _2: u32) -> () { _5 = Option::::Some(move _4); StorageDead(_4); StorageDead(_3); + StorageLive(_6); _6 = copy ((_5 as Some).0: u32); - _7 = do_something(move _6) -> [return: bb3, unwind continue]; + _7 = do_something(move _6) -> [return: bb2, unwind continue]; } bb2: { - StorageDead(_3); - goto -> bb3; + StorageDead(_6); + goto -> bb4; } bb3: { + StorageDead(_3); + goto -> bb4; + } + + bb4: { StorageDead(_5); return; } diff --git a/tests/mir-opt/pre-codegen/deref_nested_borrows.src.GVN.panic-abort.diff b/tests/mir-opt/pre-codegen/deref_nested_borrows.src.GVN.panic-abort.diff index 269af438e37ef..f64efed6b3814 100644 --- a/tests/mir-opt/pre-codegen/deref_nested_borrows.src.GVN.panic-abort.diff +++ b/tests/mir-opt/pre-codegen/deref_nested_borrows.src.GVN.panic-abort.diff @@ -15,16 +15,17 @@ } bb0: { -- StorageLive(_2); -+ nop; - _6 = copy (*_1); + StorageLive(_2); +- _6 = deref_copy (*_1); ++ _6 = copy (*_1); _2 = copy (*_6); _3 = unknown() -> [return: bb1, unwind unreachable]; } bb1: { StorageLive(_4); - _7 = copy (*_1); +- _7 = deref_copy (*_1); ++ _7 = copy (*_1); _4 = copy (*_7); StorageLive(_5); _5 = copy _2; @@ -32,8 +33,7 @@ + _0 = Eq(move _4, copy _2); StorageDead(_5); StorageDead(_4); -- StorageDead(_2); -+ nop; + StorageDead(_2); return; } } diff --git a/tests/mir-opt/pre-codegen/deref_nested_borrows.src.GVN.panic-unwind.diff b/tests/mir-opt/pre-codegen/deref_nested_borrows.src.GVN.panic-unwind.diff index 9ce17342a445c..077bca2805d63 100644 --- a/tests/mir-opt/pre-codegen/deref_nested_borrows.src.GVN.panic-unwind.diff +++ b/tests/mir-opt/pre-codegen/deref_nested_borrows.src.GVN.panic-unwind.diff @@ -15,16 +15,17 @@ } bb0: { -- StorageLive(_2); -+ nop; - _6 = copy (*_1); + StorageLive(_2); +- _6 = deref_copy (*_1); ++ _6 = copy (*_1); _2 = copy (*_6); _3 = unknown() -> [return: bb1, unwind continue]; } bb1: { StorageLive(_4); - _7 = copy (*_1); +- _7 = deref_copy (*_1); ++ _7 = copy (*_1); _4 = copy (*_7); StorageLive(_5); _5 = copy _2; @@ -32,8 +33,7 @@ + _0 = Eq(move _4, copy _2); StorageDead(_5); StorageDead(_4); -- StorageDead(_2); -+ nop; + StorageDead(_2); return; } } diff --git a/tests/mir-opt/pre-codegen/deref_nested_borrows.src.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/deref_nested_borrows.src.PreCodegen.after.panic-abort.mir index 23b1c3f3f43ad..b3789dfab0cdc 100644 --- a/tests/mir-opt/pre-codegen/deref_nested_borrows.src.PreCodegen.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/deref_nested_borrows.src.PreCodegen.after.panic-abort.mir @@ -13,6 +13,7 @@ fn src(_1: &&u8) -> bool { } bb0: { + StorageLive(_3); _2 = copy (*_1); _3 = copy (*_2); _4 = unknown() -> [return: bb1, unwind unreachable]; @@ -24,6 +25,7 @@ fn src(_1: &&u8) -> bool { _6 = copy (*_5); _0 = Eq(move _6, copy _3); StorageDead(_6); + StorageDead(_3); return; } } diff --git a/tests/mir-opt/pre-codegen/deref_nested_borrows.src.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/deref_nested_borrows.src.PreCodegen.after.panic-unwind.mir index 4c01e9464bf49..a3cf4806010a6 100644 --- a/tests/mir-opt/pre-codegen/deref_nested_borrows.src.PreCodegen.after.panic-unwind.mir +++ b/tests/mir-opt/pre-codegen/deref_nested_borrows.src.PreCodegen.after.panic-unwind.mir @@ -13,6 +13,7 @@ fn src(_1: &&u8) -> bool { } bb0: { + StorageLive(_3); _2 = copy (*_1); _3 = copy (*_2); _4 = unknown() -> [return: bb1, unwind continue]; @@ -24,6 +25,7 @@ fn src(_1: &&u8) -> bool { _6 = copy (*_5); _0 = Eq(move _6, copy _3); StorageDead(_6); + StorageDead(_3); return; } } diff --git a/tests/mir-opt/pre-codegen/derived_ord.demo_le.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/derived_ord.demo_le.PreCodegen.after.mir index e235fa35c0238..f498f4326056d 100644 --- a/tests/mir-opt/pre-codegen/derived_ord.demo_le.PreCodegen.after.mir +++ b/tests/mir-opt/pre-codegen/derived_ord.demo_le.PreCodegen.after.mir @@ -5,9 +5,8 @@ fn demo_le(_1: &MultiField, _2: &MultiField) -> bool { debug b => _2; let mut _0: bool; scope 1 (inlined ::le) { - let mut _6: std::option::Option; + let mut _11: std::option::Option; scope 2 (inlined Option::::is_some_and:: bool {std::cmp::Ordering::is_le}>) { - let mut _11: isize; let _12: std::cmp::Ordering; scope 3 { scope 4 (inlined bool {std::cmp::Ordering::is_le} as FnOnce<(std::cmp::Ordering,)>>::call_once - shim(fn(std::cmp::Ordering) -> bool {std::cmp::Ordering::is_le})) { @@ -20,6 +19,7 @@ fn demo_le(_1: &MultiField, _2: &MultiField) -> bool { } } scope 7 (inlined ::partial_cmp) { + let mut _6: std::option::Option; let mut _7: i8; scope 8 { } @@ -38,9 +38,10 @@ fn demo_le(_1: &MultiField, _2: &MultiField) -> bool { bb0: { StorageLive(_12); - StorageLive(_6); + StorageLive(_11); StorageLive(_5); StorageLive(_7); + StorageLive(_6); StorageLive(_3); _3 = copy ((*_1).0: char); StorageLive(_4); @@ -62,44 +63,30 @@ fn demo_le(_1: &MultiField, _2: &MultiField) -> bool { _10 = Cmp(move _8, move _9); StorageDead(_9); StorageDead(_8); - _6 = Option::::Some(move _10); + _11 = Option::::Some(move _10); StorageDead(_10); + StorageDead(_6); StorageDead(_7); StorageDead(_5); - StorageLive(_11); - goto -> bb4; + goto -> bb3; } bb2: { + _11 = copy _6; + StorageDead(_6); StorageDead(_7); StorageDead(_5); - StorageLive(_11); - _11 = discriminant(_6); - switchInt(move _11) -> [0: bb3, 1: bb4, otherwise: bb6]; + goto -> bb3; } bb3: { - _0 = const false; - goto -> bb5; - } - - bb4: { - _12 = move ((_6 as Some).0: std::cmp::Ordering); + _12 = move ((_11 as Some).0: std::cmp::Ordering); StorageLive(_13); _13 = discriminant(_12); _0 = Le(move _13, const 0_i8); StorageDead(_13); - goto -> bb5; - } - - bb5: { StorageDead(_11); - StorageDead(_6); StorageDead(_12); return; } - - bb6: { - unreachable; - } } diff --git a/tests/mir-opt/pre-codegen/derived_ord.{impl#0}-partial_cmp.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/derived_ord.{impl#0}-partial_cmp.PreCodegen.after.mir index 5993bd79d274c..3dce01f1c2172 100644 --- a/tests/mir-opt/pre-codegen/derived_ord.{impl#0}-partial_cmp.PreCodegen.after.mir +++ b/tests/mir-opt/pre-codegen/derived_ord.{impl#0}-partial_cmp.PreCodegen.after.mir @@ -20,6 +20,7 @@ fn ::partial_cmp(_1: &MultiField, _2: &M } bb0: { + StorageLive(_6); StorageLive(_3); _3 = copy ((*_1).0: char); StorageLive(_4); @@ -51,6 +52,7 @@ fn ::partial_cmp(_1: &MultiField, _2: &M } bb3: { + StorageDead(_6); return; } } 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 3f854b6cbcfbd..556ee3a27cfe2 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 @@ -41,8 +41,7 @@ } bb0: { -- StorageLive(_1); -+ nop; + StorageLive(_1); StorageLive(_2); - _2 = Option::::None; + _2 = const Option::::None; @@ -106,8 +105,7 @@ _3 = copy _4 as *mut u8 (PtrToPtr); StorageDead(_4); StorageDead(_3); -- StorageDead(_1); -+ nop; + StorageDead(_1); return; } } diff --git a/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.32bit.panic-unwind.diff b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.32bit.panic-unwind.diff index 15a9d9e39c491..fb20da671be52 100644 --- a/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.32bit.panic-unwind.diff +++ b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.32bit.panic-unwind.diff @@ -30,8 +30,7 @@ } bb0: { -- StorageLive(_1); -+ nop; + StorageLive(_1); StorageLive(_2); - _2 = Option::::None; + _2 = const Option::::None; @@ -49,8 +48,7 @@ _3 = copy _4 as *mut u8 (PtrToPtr); StorageDead(_4); StorageDead(_3); -- StorageDead(_1); -+ nop; + StorageDead(_1); return; } 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 1dbe9394e7094..9c28c1f867864 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 @@ -41,8 +41,7 @@ } bb0: { -- StorageLive(_1); -+ nop; + StorageLive(_1); StorageLive(_2); - _2 = Option::::None; + _2 = const Option::::None; @@ -106,8 +105,7 @@ _3 = copy _4 as *mut u8 (PtrToPtr); StorageDead(_4); StorageDead(_3); -- StorageDead(_1); -+ nop; + StorageDead(_1); return; } } diff --git a/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-unwind.diff b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-unwind.diff index df008ececae30..df4302b594294 100644 --- a/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-unwind.diff +++ b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-unwind.diff @@ -30,8 +30,7 @@ } bb0: { -- StorageLive(_1); -+ nop; + StorageLive(_1); StorageLive(_2); - _2 = Option::::None; + _2 = const Option::::None; @@ -49,8 +48,7 @@ _3 = copy _4 as *mut u8 (PtrToPtr); StorageDead(_4); StorageDead(_3); -- StorageDead(_1); -+ nop; + StorageDead(_1); return; } diff --git a/tests/mir-opt/pre-codegen/loops.filter_mapped.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/loops.filter_mapped.PreCodegen.after.mir index 8f30ad30fccdf..48948acfad973 100644 --- a/tests/mir-opt/pre-codegen/loops.filter_mapped.PreCodegen.after.mir +++ b/tests/mir-opt/pre-codegen/loops.filter_mapped.PreCodegen.after.mir @@ -6,20 +6,20 @@ fn filter_mapped(_1: impl Iterator, _2: impl Fn(T) -> Option) -> () let mut _0: (); let mut _3: std::iter::FilterMap, impl Fn(T) -> Option>; let mut _4: std::iter::FilterMap, impl Fn(T) -> Option>; - let mut _7: std::option::Option; - let mut _8: isize; - let _10: (); - let mut _11: &mut std::iter::FilterMap, impl Fn(T) -> Option>; + let mut _5: &mut std::iter::FilterMap, impl Fn(T) -> Option>; + let mut _8: std::option::Option; + let mut _9: isize; + let _11: (); scope 1 { debug iter => _4; - let _9: U; + let _10: U; scope 2 { - debug x => _9; + debug x => _10; } scope 4 (inlined , impl Fn(T) -> Option> as Iterator>::next) { - debug self => _11; - let mut _5: &mut impl Iterator; - let mut _6: &mut impl Fn(T) -> Option; + debug self => _5; + let mut _6: &mut impl Iterator; + let mut _7: &mut impl Fn(T) -> Option; } } scope 3 (inlined , impl Fn(T) -> Option> as IntoIterator>::into_iter) { @@ -37,24 +37,24 @@ fn filter_mapped(_1: impl Iterator, _2: impl Fn(T) -> Option) -> () } bb2: { - StorageLive(_7); - // DBG: _11 = &_4; - StorageLive(_5); - _5 = &mut (_4.0: impl Iterator); + StorageLive(_8); + _5 = &mut _4; StorageLive(_6); - _6 = &mut (_4.1: impl Fn(T) -> Option); - _7 = as Iterator>::find_map:: Option>(move _5, move _6) -> [return: bb3, unwind: bb9]; + _6 = &mut (_4.0: impl Iterator); + StorageLive(_7); + _7 = &mut (_4.1: impl Fn(T) -> Option); + _8 = as Iterator>::find_map:: Option>(move _6, move _7) -> [return: bb3, unwind: bb9]; } bb3: { + StorageDead(_7); StorageDead(_6); - StorageDead(_5); - _8 = discriminant(_7); - switchInt(move _8) -> [0: bb4, 1: bb6, otherwise: bb8]; + _9 = discriminant(_8); + switchInt(move _9) -> [0: bb4, 1: bb6, otherwise: bb8]; } bb4: { - StorageDead(_7); + StorageDead(_8); drop(_4) -> [return: bb5, unwind continue]; } @@ -64,12 +64,14 @@ fn filter_mapped(_1: impl Iterator, _2: impl Fn(T) -> Option) -> () } bb6: { - _9 = move ((_7 as Some).0: U); - _10 = opaque::(move _9) -> [return: bb7, unwind: bb9]; + StorageLive(_10); + _10 = move ((_8 as Some).0: U); + _11 = opaque::(move _10) -> [return: bb7, unwind: bb9]; } bb7: { - StorageDead(_7); + StorageDead(_10); + StorageDead(_8); goto -> bb2; } diff --git a/tests/mir-opt/pre-codegen/loops.int_range.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/loops.int_range.PreCodegen.after.mir index beb7b936ccf74..a4050a261dcf6 100644 --- a/tests/mir-opt/pre-codegen/loops.int_range.PreCodegen.after.mir +++ b/tests/mir-opt/pre-codegen/loops.int_range.PreCodegen.after.mir @@ -5,31 +5,32 @@ fn int_range(_1: usize, _2: usize) -> () { debug end => _2; let mut _0: (); let mut _3: std::ops::Range; - let mut _9: std::option::Option; - let _11: (); - let mut _12: &mut std::ops::Range; + let mut _4: std::ops::Range; + let mut _5: &mut std::ops::Range; + let mut _13: std::option::Option; + let _15: (); scope 1 { - debug iter => _3; - let _10: usize; + debug iter => _4; + let _14: usize; scope 2 { - debug i => _10; + debug i => _14; } scope 4 (inlined iter::range::>::next) { - debug self => _12; + debug self => _5; scope 5 (inlined as iter::range::RangeIteratorImpl>::spec_next) { - debug self => _12; - let mut _6: bool; - let _7: usize; - let mut _8: usize; - let mut _13: &usize; - let mut _14: &usize; + debug self => _5; + let mut _6: &usize; + let mut _7: &usize; + let mut _10: bool; + let _11: usize; + let mut _12: usize; scope 6 { - debug old => _7; + debug old => _11; scope 8 (inlined ::forward_unchecked) { - debug start => _7; + debug start => _11; debug n => const 1_usize; scope 9 (inlined #[track_caller] core::num::::unchecked_add) { - debug self => _7; + debug self => _11; debug rhs => const 1_usize; scope 10 (inlined core::ub_checks::check_language_ub) { scope 11 (inlined core::ub_checks::check_language_ub::runtime) { @@ -39,10 +40,10 @@ fn int_range(_1: usize, _2: usize) -> () { } } scope 7 (inlined std::cmp::impls::::lt) { - debug self => _13; - debug other => _14; - let mut _4: usize; - let mut _5: usize; + debug self => _6; + debug other => _7; + let mut _8: usize; + let mut _9: usize; } } } @@ -53,45 +54,59 @@ fn int_range(_1: usize, _2: usize) -> () { bb0: { _3 = std::ops::Range:: { start: copy _1, end: copy _2 }; + StorageLive(_4); + _4 = copy _3; goto -> bb1; } bb1: { - StorageLive(_9); - // DBG: _12 = &_3; + StorageLive(_13); + _5 = &mut _4; + StorageLive(_11); + StorageLive(_10); StorageLive(_6); - // DBG: _13 = &(_3.0: usize); - // DBG: _14 = &(_3.1: usize); - StorageLive(_4); - _4 = copy (_3.0: usize); - StorageLive(_5); - _5 = copy (_3.1: usize); - _6 = Lt(move _4, move _5); - StorageDead(_5); - StorageDead(_4); - switchInt(move _6) -> [0: bb2, otherwise: bb3]; + _6 = &(_4.0: usize); + StorageLive(_7); + _7 = &(_4.1: usize); + StorageLive(_8); + _8 = copy (_4.0: usize); + StorageLive(_9); + _9 = copy (_4.1: usize); + _10 = Lt(move _8, move _9); + StorageDead(_9); + StorageDead(_8); + switchInt(move _10) -> [0: bb2, otherwise: bb3]; } bb2: { + StorageDead(_7); StorageDead(_6); - StorageDead(_9); + StorageDead(_10); + StorageDead(_11); + StorageDead(_13); + StorageDead(_4); return; } bb3: { - _7 = copy (_3.0: usize); - StorageLive(_8); - _8 = AddUnchecked(copy _7, const 1_usize); - (_3.0: usize) = move _8; - StorageDead(_8); - _9 = Option::::Some(copy _7); + StorageDead(_7); StorageDead(_6); - _10 = copy ((_9 as Some).0: usize); - _11 = opaque::(move _10) -> [return: bb4, unwind continue]; + _11 = copy (_4.0: usize); + StorageLive(_12); + _12 = AddUnchecked(copy _11, const 1_usize); + (_4.0: usize) = move _12; + StorageDead(_12); + _13 = Option::::Some(copy _11); + StorageDead(_10); + StorageDead(_11); + StorageLive(_14); + _14 = copy ((_13 as Some).0: usize); + _15 = opaque::(move _14) -> [return: bb4, unwind continue]; } bb4: { - StorageDead(_9); + StorageDead(_14); + StorageDead(_13); goto -> bb1; } } diff --git a/tests/mir-opt/pre-codegen/loops.mapped.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/loops.mapped.PreCodegen.after.mir index 406c96fc32f48..e1bb56ef66eb5 100644 --- a/tests/mir-opt/pre-codegen/loops.mapped.PreCodegen.after.mir +++ b/tests/mir-opt/pre-codegen/loops.mapped.PreCodegen.after.mir @@ -6,32 +6,32 @@ fn mapped(_1: impl Iterator, _2: impl Fn(T) -> U) -> () { let mut _0: (); let mut _3: std::iter::Map, impl Fn(T) -> U>; let mut _4: std::iter::Map, impl Fn(T) -> U>; - let mut _12: std::option::Option; - let _14: (); - let mut _15: &mut std::iter::Map, impl Fn(T) -> U>; + let mut _5: &mut std::iter::Map, impl Fn(T) -> U>; + let mut _13: std::option::Option; + let _15: (); scope 1 { debug iter => _4; - let _13: U; + let _14: U; scope 2 { - debug x => _13; + debug x => _14; } scope 4 (inlined , impl Fn(T) -> U> as Iterator>::next) { - debug self => _15; - let mut _5: &mut impl Iterator; - let mut _6: std::option::Option; - let mut _7: &mut impl Fn(T) -> U; + debug self => _5; + let mut _6: &mut impl Iterator; + let mut _7: std::option::Option; + let mut _8: &mut impl Fn(T) -> U; scope 5 (inlined Option::::map:: U>) { - debug self => _6; - debug f => _7; - let mut _8: isize; - let _9: T; - let mut _10: (T,); - let mut _11: U; + debug self => _7; + debug f => _8; + let mut _9: isize; + let _10: T; + let mut _11: (T,); + let mut _12: U; scope 6 { - debug x => _9; + debug x => _10; scope 7 (inlined ops::function::impls:: for &mut impl Fn(T) -> U>::call_once) { - debug self => _7; - debug args => _10; + debug self => _8; + debug args => _11; } } } @@ -52,30 +52,30 @@ fn mapped(_1: impl Iterator, _2: impl Fn(T) -> U) -> () { } bb2: { - StorageLive(_12); - // DBG: _15 = &_4; + StorageLive(_13); + _5 = &mut _4; + StorageLive(_8); StorageLive(_7); StorageLive(_6); - StorageLive(_5); - _5 = &mut (_4.0: impl Iterator); - _6 = as Iterator>::next(move _5) -> [return: bb3, unwind: bb10]; + _6 = &mut (_4.0: impl Iterator); + _7 = as Iterator>::next(move _6) -> [return: bb3, unwind: bb10]; } bb3: { - StorageDead(_5); - _7 = &mut (_4.1: impl Fn(T) -> U); - StorageLive(_8); + StorageDead(_6); + _8 = &mut (_4.1: impl Fn(T) -> U); StorageLive(_9); - _8 = discriminant(_6); - switchInt(move _8) -> [0: bb4, 1: bb6, otherwise: bb9]; + StorageLive(_10); + _9 = discriminant(_7); + switchInt(move _9) -> [0: bb4, 1: bb6, otherwise: bb9]; } bb4: { + StorageDead(_10); StorageDead(_9); - StorageDead(_8); - StorageDead(_6); StorageDead(_7); - StorageDead(_12); + StorageDead(_8); + StorageDead(_13); drop(_4) -> [return: bb5, unwind continue]; } @@ -85,27 +85,29 @@ fn mapped(_1: impl Iterator, _2: impl Fn(T) -> U) -> () { } bb6: { - _9 = move ((_6 as Some).0: T); + _10 = move ((_7 as Some).0: T); + StorageLive(_12); StorageLive(_11); - StorageLive(_10); - _10 = (copy _9,); - _11 = U as FnMut<(T,)>>::call_mut(move _7, move _10) -> [return: bb7, unwind: bb10]; + _11 = (copy _10,); + _12 = U as FnMut<(T,)>>::call_mut(move _8, move _11) -> [return: bb7, unwind: bb10]; } bb7: { - StorageDead(_10); - _12 = Option::::Some(move _11); StorageDead(_11); + _13 = Option::::Some(move _12); + StorageDead(_12); + StorageDead(_10); StorageDead(_9); - StorageDead(_8); - StorageDead(_6); StorageDead(_7); - _13 = move ((_12 as Some).0: U); - _14 = opaque::(move _13) -> [return: bb8, unwind: bb10]; + StorageDead(_8); + StorageLive(_14); + _14 = move ((_13 as Some).0: U); + _15 = opaque::(move _14) -> [return: bb8, unwind: bb10]; } bb8: { - StorageDead(_12); + StorageDead(_14); + StorageDead(_13); goto -> bb2; } diff --git a/tests/mir-opt/pre-codegen/loops.vec_move.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/loops.vec_move.PreCodegen.after.mir index 4260ec3eaedf1..9e6043919b5da 100644 --- a/tests/mir-opt/pre-codegen/loops.vec_move.PreCodegen.after.mir +++ b/tests/mir-opt/pre-codegen/loops.vec_move.PreCodegen.after.mir @@ -3,316 +3,77 @@ fn vec_move(_1: Vec) -> () { debug v => _1; let mut _0: (); - let mut _21: std::vec::IntoIter; - let mut _22: std::vec::IntoIter; - let mut _23: &mut std::vec::IntoIter; - let mut _24: std::option::Option; - let mut _25: isize; - let _27: (); + let mut _2: std::vec::IntoIter; + let mut _3: std::vec::IntoIter; + let mut _4: &mut std::vec::IntoIter; + let mut _5: std::option::Option; + let mut _6: isize; + let _8: (); scope 1 { - debug iter => _22; - let _26: impl Sized; + debug iter => _3; + let _7: impl Sized; scope 2 { - debug x => _26; - } - } - scope 3 (inlined as IntoIterator>::into_iter) { - debug self => _1; - let _2: std::mem::ManuallyDrop>; - let mut _3: *const std::alloc::Global; - let mut _8: usize; - let mut _10: *mut impl Sized; - let mut _11: *const impl Sized; - let mut _12: usize; - let _28: &std::vec::Vec; - let mut _29: &std::mem::ManuallyDrop>; - let mut _30: &alloc::raw_vec::RawVec; - let mut _31: &std::mem::ManuallyDrop>; - let _32: &std::vec::Vec; - let mut _33: &std::mem::ManuallyDrop>; - let _34: &std::vec::Vec; - let mut _35: &std::mem::ManuallyDrop>; - let mut _36: &alloc::raw_vec::RawVec; - let mut _37: &std::mem::ManuallyDrop>; - scope 4 { - debug me => _2; - scope 5 { - debug alloc => const ManuallyDrop:: {{ value: std::alloc::Global }}; - let _6: std::ptr::NonNull; - scope 6 { - debug buf => _6; - let _7: *mut impl Sized; - scope 7 { - debug begin => _7; - scope 8 { - debug end => _11; - let _19: usize; - scope 9 { - debug cap => _19; - } - scope 39 (inlined > as Deref>::deref) { - debug self => _37; - } - scope 40 (inlined alloc::raw_vec::RawVec::::capacity) { - debug self => _36; - let mut _38: &alloc::raw_vec::RawVecInner; - scope 41 (inlined std::mem::size_of::) { - } - scope 42 (inlined alloc::raw_vec::RawVecInner::capacity) { - debug self => _38; - debug elem_size => const ::SIZE; - let mut _20: core::num::niche_types::UsizeNoHighBit; - scope 43 (inlined core::num::niche_types::UsizeNoHighBit::as_inner) { - debug self => _20; - } - } - } - } - scope 25 (inlined > as Deref>::deref) { - debug self => _33; - } - scope 26 (inlined Vec::::len) { - debug self => _32; - let mut _13: bool; - scope 27 { - } - } - scope 28 (inlined std::ptr::mut_ptr::::wrapping_byte_add) { - debug self => _7; - debug count => _12; - let mut _14: *mut u8; - let mut _18: *mut u8; - scope 29 (inlined std::ptr::mut_ptr::::cast::) { - debug self => _7; - } - scope 30 (inlined std::ptr::mut_ptr::::wrapping_add) { - debug self => _14; - debug count => _12; - let mut _15: isize; - scope 31 (inlined std::ptr::mut_ptr::::wrapping_offset) { - debug self => _14; - debug count => _15; - let mut _16: *const u8; - let mut _17: *const u8; - } - } - scope 32 (inlined std::ptr::mut_ptr::::with_metadata_of::) { - debug self => _18; - debug meta => _5; - scope 33 (inlined std::ptr::metadata::) { - debug ptr => _5; - } - scope 34 (inlined std::ptr::from_raw_parts_mut::) { - } - } - } - scope 35 (inlined > as Deref>::deref) { - debug self => _35; - } - scope 36 (inlined Vec::::len) { - debug self => _34; - let mut _9: bool; - scope 37 { - } - } - scope 38 (inlined #[track_caller] std::ptr::mut_ptr::::add) { - debug self => _7; - debug count => _8; - } - } - scope 24 (inlined NonNull::::as_ptr) { - debug self => _6; - } - } - scope 17 (inlined > as Deref>::deref) { - debug self => _31; - } - scope 18 (inlined alloc::raw_vec::RawVec::::non_null) { - debug self => _30; - scope 19 (inlined alloc::raw_vec::RawVecInner::non_null::) { - let mut _4: std::ptr::NonNull; - scope 20 (inlined Unique::::cast::) { - scope 21 (inlined NonNull::::cast::) { - let mut _5: *const impl Sized; - scope 22 (inlined NonNull::::as_ptr) { - } - } - } - scope 23 (inlined Unique::::as_non_null_ptr) { - } - } - } - } - scope 11 (inlined > as Deref>::deref) { - debug self => _29; - } - scope 12 (inlined Vec::::allocator) { - debug self => _28; - scope 13 (inlined alloc::raw_vec::RawVec::::allocator) { - scope 14 (inlined alloc::raw_vec::RawVecInner::allocator) { - } - } - } - scope 15 (inlined #[track_caller] std::ptr::read::) { - debug src => _3; - } - scope 16 (inlined ManuallyDrop::::new) { - debug value => const std::alloc::Global; - } - } - scope 10 (inlined ManuallyDrop::>::new) { - debug value => _1; + debug x => _7; } } bb0: { - StorageLive(_21); - StorageLive(_6); - StorageLive(_7); - StorageLive(_11); - StorageLive(_19); - StorageLive(_5); - StorageLive(_4); - StorageLive(_17); StorageLive(_2); - _2 = ManuallyDrop::> { value: copy _1 }; - StorageLive(_3); - // DBG: _29 = &_2; - // DBG: _28 = &(_2.0: std::vec::Vec); - _3 = &raw const ((((_2.0: std::vec::Vec).0: alloc::raw_vec::RawVec).0: alloc::raw_vec::RawVecInner).2: std::alloc::Global); - StorageDead(_3); - // DBG: _31 = &_2; - // DBG: _30 = &((_2.0: std::vec::Vec).0: alloc::raw_vec::RawVec); - _4 = copy (((((_2.0: std::vec::Vec).0: alloc::raw_vec::RawVec).0: alloc::raw_vec::RawVecInner).0: std::ptr::Unique).0: std::ptr::NonNull); - _5 = copy _4 as *const impl Sized (Transmute); - _6 = NonNull:: { pointer: copy _5 }; - _7 = copy _4 as *mut impl Sized (Transmute); - switchInt(const ::IS_ZST) -> [0: bb1, otherwise: bb2]; + _2 = as IntoIterator>::into_iter(move _1) -> [return: bb1, unwind continue]; } bb1: { - StorageLive(_10); - StorageLive(_8); - // DBG: _35 = &_2; - // DBG: _34 = &(_2.0: std::vec::Vec); - _8 = copy ((_2.0: std::vec::Vec).1: usize); - StorageLive(_9); - _9 = Le(copy _8, const ::MAX_SLICE_LEN); - assume(move _9); - StorageDead(_9); - _10 = Offset(copy _7, copy _8); - _11 = copy _10 as *const impl Sized (PtrToPtr); - StorageDead(_8); - StorageDead(_10); - goto -> bb4; + StorageLive(_3); + _3 = move _2; + goto -> bb2; } bb2: { - StorageLive(_12); - // DBG: _33 = &_2; - // DBG: _32 = &(_2.0: std::vec::Vec); - _12 = copy ((_2.0: std::vec::Vec).1: usize); - StorageLive(_13); - _13 = Le(copy _12, const ::MAX_SLICE_LEN); - assume(move _13); - StorageDead(_13); - StorageLive(_18); - StorageLive(_14); - _14 = copy _4 as *mut u8 (Transmute); - StorageLive(_15); - _15 = copy _12 as isize (IntToInt); - StorageLive(_16); - _16 = copy _4 as *const u8 (Transmute); - _17 = arith_offset::(move _16, move _15) -> [return: bb3, unwind unreachable]; + StorageLive(_5); + StorageLive(_4); + _4 = &mut _3; + _5 = as Iterator>::next(move _4) -> [return: bb3, unwind: bb9]; } bb3: { - StorageDead(_16); - _18 = copy _17 as *mut u8 (PtrToPtr); - StorageDead(_15); - StorageDead(_14); - StorageDead(_18); - StorageDead(_12); - _11 = copy _17 as *const impl Sized (PtrToPtr); - goto -> bb4; + _6 = discriminant(_5); + switchInt(move _6) -> [0: bb4, 1: bb6, otherwise: bb8]; } bb4: { - // DBG: _37 = &_2; - // DBG: _36 = &((_2.0: std::vec::Vec).0: alloc::raw_vec::RawVec); - // DBG: _38 = &(((_2.0: std::vec::Vec).0: alloc::raw_vec::RawVec).0: alloc::raw_vec::RawVecInner); - switchInt(const ::SIZE) -> [0: bb5, otherwise: bb6]; + StorageDead(_4); + StorageDead(_5); + drop(_3) -> [return: bb5, unwind continue]; } bb5: { - _19 = const usize::MAX; - goto -> bb7; + StorageDead(_3); + StorageDead(_2); + return; } bb6: { - StorageLive(_20); - _20 = copy ((((_2.0: std::vec::Vec).0: alloc::raw_vec::RawVec).0: alloc::raw_vec::RawVecInner).1: core::num::niche_types::UsizeNoHighBit); - _19 = copy _20 as usize (Transmute); - StorageDead(_20); - goto -> bb7; + StorageLive(_7); + _7 = move ((_5 as Some).0: impl Sized); + _8 = opaque::(move _7) -> [return: bb7, unwind: bb9]; } bb7: { - _21 = std::vec::IntoIter:: { buf: copy _6, phantom: const ZeroSized: PhantomData, cap: move _19, alloc: const ManuallyDrop:: {{ value: std::alloc::Global }}, ptr: copy _6, end: copy _11 }; - StorageDead(_2); - StorageDead(_17); + StorageDead(_7); StorageDead(_4); StorageDead(_5); - StorageDead(_19); - StorageDead(_11); - StorageDead(_7); - StorageDead(_6); - StorageLive(_22); - _22 = move _21; - goto -> bb8; + goto -> bb2; } bb8: { - StorageLive(_24); - _23 = &mut _22; - _24 = as Iterator>::next(move _23) -> [return: bb9, unwind: bb15]; - } - - bb9: { - _25 = discriminant(_24); - switchInt(move _25) -> [0: bb10, 1: bb12, otherwise: bb14]; - } - - bb10: { - StorageDead(_24); - drop(_22) -> [return: bb11, unwind continue]; - } - - bb11: { - StorageDead(_22); - StorageDead(_21); - return; - } - - bb12: { - _26 = move ((_24 as Some).0: impl Sized); - _27 = opaque::(move _26) -> [return: bb13, unwind: bb15]; - } - - bb13: { - StorageDead(_24); - goto -> bb8; - } - - bb14: { unreachable; } - bb15 (cleanup): { - drop(_22) -> [return: bb16, unwind terminate(cleanup)]; + bb9 (cleanup): { + drop(_3) -> [return: bb10, unwind terminate(cleanup)]; } - bb16 (cleanup): { + bb10 (cleanup): { resume; } } diff --git a/tests/mir-opt/pre-codegen/range_iter.forward_loop.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/range_iter.forward_loop.PreCodegen.after.panic-abort.mir index 03a52b82b49b1..3d44fd6807f19 100644 --- a/tests/mir-opt/pre-codegen/range_iter.forward_loop.PreCodegen.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/range_iter.forward_loop.PreCodegen.after.panic-abort.mir @@ -5,21 +5,23 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { debug end => _2; debug f => _3; let mut _0: (); - let mut _7: std::option::Option; - let mut _9: &impl Fn(u32); - let mut _10: (u32,); - let _11: (); + let mut _4: u32; + let mut _9: std::option::Option; + let mut _11: &impl Fn(u32); + let mut _12: (u32,); + let _13: (); scope 1 { - debug ((iter: std::ops::Range).0: u32) => _1; + debug ((iter: std::ops::Range).0: u32) => _4; debug ((iter: std::ops::Range).1: u32) => _2; - let _8: u32; + let _10: u32; scope 2 { - debug x => _8; + debug x => _10; } scope 4 (inlined iter::range::>::next) { scope 5 (inlined as iter::range::RangeIteratorImpl>::spec_next) { - let mut _5: bool; - let _6: u32; + let mut _6: bool; + let _7: u32; + let mut _8: u32; scope 6 { scope 8 (inlined ::forward_unchecked) { scope 9 (inlined #[track_caller] core::num::::unchecked_add) { @@ -31,7 +33,7 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { } } scope 7 (inlined std::cmp::impls::::lt) { - let mut _4: u32; + let mut _5: u32; } } } @@ -40,22 +42,25 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { } bb0: { + StorageLive(_4); + _4 = copy _1; goto -> bb1; } bb1: { - StorageLive(_7); + StorageLive(_9); + StorageLive(_6); StorageLive(_5); - StorageLive(_4); - _4 = copy _1; - _5 = Lt(move _4, copy _2); - StorageDead(_4); - switchInt(move _5) -> [0: bb2, otherwise: bb4]; + _5 = copy _4; + _6 = Lt(move _5, copy _2); + StorageDead(_5); + switchInt(move _6) -> [0: bb2, otherwise: bb4]; } bb2: { - StorageDead(_5); - StorageDead(_7); + StorageDead(_6); + StorageDead(_9); + StorageDead(_4); drop(_3) -> [return: bb3, unwind unreachable]; } @@ -64,22 +69,29 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { } bb4: { - _6 = copy _1; - _1 = AddUnchecked(copy _6, const 1_u32); - _7 = Option::::Some(copy _6); - StorageDead(_5); - _8 = copy ((_7 as Some).0: u32); - StorageLive(_9); - _9 = &_3; + StorageLive(_7); + _7 = copy _4; + StorageLive(_8); + _8 = AddUnchecked(copy _7, const 1_u32); + _4 = move _8; + StorageDead(_8); + _9 = Option::::Some(copy _7); + StorageDead(_7); + StorageDead(_6); StorageLive(_10); - _10 = (copy _8,); - _11 = >::call(move _9, move _10) -> [return: bb5, unwind unreachable]; + _10 = copy ((_9 as Some).0: u32); + StorageLive(_11); + _11 = &_3; + StorageLive(_12); + _12 = (copy _10,); + _13 = >::call(move _11, move _12) -> [return: bb5, unwind unreachable]; } bb5: { + StorageDead(_12); + StorageDead(_11); StorageDead(_10); StorageDead(_9); - StorageDead(_7); goto -> bb1; } } diff --git a/tests/mir-opt/pre-codegen/range_iter.forward_loop.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/range_iter.forward_loop.PreCodegen.after.panic-unwind.mir index 3b09f33e73338..b955501316549 100644 --- a/tests/mir-opt/pre-codegen/range_iter.forward_loop.PreCodegen.after.panic-unwind.mir +++ b/tests/mir-opt/pre-codegen/range_iter.forward_loop.PreCodegen.after.panic-unwind.mir @@ -5,21 +5,23 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { debug end => _2; debug f => _3; let mut _0: (); - let mut _7: std::option::Option; - let mut _9: &impl Fn(u32); - let mut _10: (u32,); - let _11: (); + let mut _4: u32; + let mut _9: std::option::Option; + let mut _11: &impl Fn(u32); + let mut _12: (u32,); + let _13: (); scope 1 { - debug ((iter: std::ops::Range).0: u32) => _1; + debug ((iter: std::ops::Range).0: u32) => _4; debug ((iter: std::ops::Range).1: u32) => _2; - let _8: u32; + let _10: u32; scope 2 { - debug x => _8; + debug x => _10; } scope 4 (inlined iter::range::>::next) { scope 5 (inlined as iter::range::RangeIteratorImpl>::spec_next) { - let mut _5: bool; - let _6: u32; + let mut _6: bool; + let _7: u32; + let mut _8: u32; scope 6 { scope 8 (inlined ::forward_unchecked) { scope 9 (inlined #[track_caller] core::num::::unchecked_add) { @@ -31,7 +33,7 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { } } scope 7 (inlined std::cmp::impls::::lt) { - let mut _4: u32; + let mut _5: u32; } } } @@ -40,22 +42,25 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { } bb0: { + StorageLive(_4); + _4 = copy _1; goto -> bb1; } bb1: { - StorageLive(_7); + StorageLive(_9); + StorageLive(_6); StorageLive(_5); - StorageLive(_4); - _4 = copy _1; - _5 = Lt(move _4, copy _2); - StorageDead(_4); - switchInt(move _5) -> [0: bb2, otherwise: bb4]; + _5 = copy _4; + _6 = Lt(move _5, copy _2); + StorageDead(_5); + switchInt(move _6) -> [0: bb2, otherwise: bb4]; } bb2: { - StorageDead(_5); - StorageDead(_7); + StorageDead(_6); + StorageDead(_9); + StorageDead(_4); drop(_3) -> [return: bb3, unwind continue]; } @@ -64,22 +69,29 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { } bb4: { - _6 = copy _1; - _1 = AddUnchecked(copy _6, const 1_u32); - _7 = Option::::Some(copy _6); - StorageDead(_5); - _8 = copy ((_7 as Some).0: u32); - StorageLive(_9); - _9 = &_3; + StorageLive(_7); + _7 = copy _4; + StorageLive(_8); + _8 = AddUnchecked(copy _7, const 1_u32); + _4 = move _8; + StorageDead(_8); + _9 = Option::::Some(copy _7); + StorageDead(_7); + StorageDead(_6); StorageLive(_10); - _10 = (copy _8,); - _11 = >::call(move _9, move _10) -> [return: bb5, unwind: bb6]; + _10 = copy ((_9 as Some).0: u32); + StorageLive(_11); + _11 = &_3; + StorageLive(_12); + _12 = (copy _10,); + _13 = >::call(move _11, move _12) -> [return: bb5, unwind: bb6]; } bb5: { + StorageDead(_12); + StorageDead(_11); StorageDead(_10); StorageDead(_9); - StorageDead(_7); goto -> bb1; } diff --git a/tests/mir-opt/pre-codegen/range_iter.inclusive_loop.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/range_iter.inclusive_loop.PreCodegen.after.panic-abort.mir index 3f000dcafb035..63d9b1d1d0038 100644 --- a/tests/mir-opt/pre-codegen/range_iter.inclusive_loop.PreCodegen.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/range_iter.inclusive_loop.PreCodegen.after.panic-abort.mir @@ -36,6 +36,7 @@ fn inclusive_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { bb1: { StorageLive(_7); + StorageLive(_6); _6 = &mut _5; _7 = as iter::range::RangeInclusiveIteratorImpl>::spec_next(move _6) -> [return: bb2, unwind unreachable]; } @@ -46,6 +47,7 @@ fn inclusive_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { } bb3: { + StorageDead(_6); StorageDead(_7); StorageDead(_5); drop(_3) -> [return: bb4, unwind unreachable]; @@ -56,6 +58,7 @@ fn inclusive_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { } bb5: { + StorageLive(_9); _9 = copy ((_7 as Some).0: u32); StorageLive(_10); _10 = &_3; @@ -67,6 +70,8 @@ fn inclusive_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { bb6: { StorageDead(_11); StorageDead(_10); + StorageDead(_9); + StorageDead(_6); StorageDead(_7); goto -> bb1; } diff --git a/tests/mir-opt/pre-codegen/range_iter.inclusive_loop.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/range_iter.inclusive_loop.PreCodegen.after.panic-unwind.mir index 2353717362711..33c9b492c5f1a 100644 --- a/tests/mir-opt/pre-codegen/range_iter.inclusive_loop.PreCodegen.after.panic-unwind.mir +++ b/tests/mir-opt/pre-codegen/range_iter.inclusive_loop.PreCodegen.after.panic-unwind.mir @@ -36,6 +36,7 @@ fn inclusive_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { bb1: { StorageLive(_7); + StorageLive(_6); _6 = &mut _5; _7 = as iter::range::RangeInclusiveIteratorImpl>::spec_next(move _6) -> [return: bb2, unwind: bb8]; } @@ -46,6 +47,7 @@ fn inclusive_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { } bb3: { + StorageDead(_6); StorageDead(_7); StorageDead(_5); drop(_3) -> [return: bb4, unwind continue]; @@ -56,6 +58,7 @@ fn inclusive_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { } bb5: { + StorageLive(_9); _9 = copy ((_7 as Some).0: u32); StorageLive(_10); _10 = &_3; @@ -67,6 +70,8 @@ fn inclusive_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { bb6: { StorageDead(_11); StorageDead(_10); + StorageDead(_9); + StorageDead(_6); StorageDead(_7); goto -> bb1; } diff --git a/tests/mir-opt/pre-codegen/range_iter.range_iter_next.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/range_iter.range_iter_next.PreCodegen.after.panic-abort.mir index 1f82fc59ac2c1..55caea9d8f96d 100644 --- a/tests/mir-opt/pre-codegen/range_iter.range_iter_next.PreCodegen.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/range_iter.range_iter_next.PreCodegen.after.panic-abort.mir @@ -43,12 +43,14 @@ fn range_iter_next(_1: &mut std::ops::Range) -> Option { } bb2: { + StorageLive(_5); _5 = copy ((*_1).0: u32); StorageLive(_6); _6 = AddUnchecked(copy _5, const 1_u32); ((*_1).0: u32) = move _6; StorageDead(_6); _0 = Option::::Some(copy _5); + StorageDead(_5); goto -> bb3; } diff --git a/tests/mir-opt/pre-codegen/range_iter.range_iter_next.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/range_iter.range_iter_next.PreCodegen.after.panic-unwind.mir index 1f82fc59ac2c1..55caea9d8f96d 100644 --- a/tests/mir-opt/pre-codegen/range_iter.range_iter_next.PreCodegen.after.panic-unwind.mir +++ b/tests/mir-opt/pre-codegen/range_iter.range_iter_next.PreCodegen.after.panic-unwind.mir @@ -43,12 +43,14 @@ fn range_iter_next(_1: &mut std::ops::Range) -> Option { } bb2: { + StorageLive(_5); _5 = copy ((*_1).0: u32); StorageLive(_6); _6 = AddUnchecked(copy _5, const 1_u32); ((*_1).0: u32) = move _6; StorageDead(_6); _0 = Option::::Some(copy _5); + StorageDead(_5); goto -> bb3; } diff --git a/tests/mir-opt/pre-codegen/simple_option_map.ezmap.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/simple_option_map.ezmap.PreCodegen.after.mir index 7595ad88d9df4..876fa96dfb6fe 100644 --- a/tests/mir-opt/pre-codegen/simple_option_map.ezmap.PreCodegen.after.mir +++ b/tests/mir-opt/pre-codegen/simple_option_map.ezmap.PreCodegen.after.mir @@ -25,11 +25,13 @@ fn ezmap(_1: Option) -> Option { } bb2: { + StorageLive(_3); _3 = copy ((_1 as Some).0: i32); StorageLive(_4); _4 = Add(copy _3, const 1_i32); _0 = Option::::Some(move _4); StorageDead(_4); + StorageDead(_3); goto -> bb3; } diff --git a/tests/mir-opt/pre-codegen/slice_filter.variant_b-{closure#0}.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/slice_filter.variant_b-{closure#0}.PreCodegen.after.mir index bc7a31d52199b..1d0ebfc3bcd70 100644 --- a/tests/mir-opt/pre-codegen/slice_filter.variant_b-{closure#0}.PreCodegen.after.mir +++ b/tests/mir-opt/pre-codegen/slice_filter.variant_b-{closure#0}.PreCodegen.after.mir @@ -18,10 +18,14 @@ fn variant_b::{closure#0}(_1: &mut {closure@$DIR/slice_filter.rs:11:25: 11:41}, } bb0: { + StorageLive(_4); _3 = copy (*_2); _4 = copy ((*_3).0: usize); + StorageLive(_5); _5 = copy ((*_3).1: usize); + StorageLive(_6); _6 = copy ((*_3).2: usize); + StorageLive(_7); _7 = copy ((*_3).3: usize); StorageLive(_8); _8 = Le(copy _4, copy _6); @@ -63,6 +67,10 @@ fn variant_b::{closure#0}(_1: &mut {closure@$DIR/slice_filter.rs:11:25: 11:41}, bb7: { StorageDead(_9); StorageDead(_8); + StorageDead(_7); + StorageDead(_6); + StorageDead(_5); + StorageDead(_4); return; } } diff --git a/tests/mir-opt/pre-codegen/slice_index.slice_get_unchecked_mut_range.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/slice_index.slice_get_unchecked_mut_range.PreCodegen.after.panic-abort.mir index 6fb1637a6e02f..b03344c848d80 100644 --- a/tests/mir-opt/pre-codegen/slice_index.slice_get_unchecked_mut_range.PreCodegen.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/slice_index.slice_get_unchecked_mut_range.PreCodegen.after.panic-abort.mir @@ -31,6 +31,8 @@ fn slice_get_unchecked_mut_range(_1: &mut [u32], _2: std::ops::Range) -> } bb0: { + StorageLive(_3); + StorageLive(_4); _3 = move (_2.0: usize); _4 = move (_2.1: usize); StorageLive(_11); @@ -56,6 +58,8 @@ fn slice_get_unchecked_mut_range(_1: &mut [u32], _2: std::ops::Range) -> StorageDead(_5); _0 = &mut (*_11); StorageDead(_11); + StorageDead(_3); + StorageDead(_4); return; } } diff --git a/tests/mir-opt/pre-codegen/slice_index.slice_get_unchecked_mut_range.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/slice_index.slice_get_unchecked_mut_range.PreCodegen.after.panic-unwind.mir index 6fb1637a6e02f..b03344c848d80 100644 --- a/tests/mir-opt/pre-codegen/slice_index.slice_get_unchecked_mut_range.PreCodegen.after.panic-unwind.mir +++ b/tests/mir-opt/pre-codegen/slice_index.slice_get_unchecked_mut_range.PreCodegen.after.panic-unwind.mir @@ -31,6 +31,8 @@ fn slice_get_unchecked_mut_range(_1: &mut [u32], _2: std::ops::Range) -> } bb0: { + StorageLive(_3); + StorageLive(_4); _3 = move (_2.0: usize); _4 = move (_2.1: usize); StorageLive(_11); @@ -56,6 +58,8 @@ fn slice_get_unchecked_mut_range(_1: &mut [u32], _2: std::ops::Range) -> StorageDead(_5); _0 = &mut (*_11); StorageDead(_11); + StorageDead(_3); + StorageDead(_4); return; } } diff --git a/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.PreCodegen.after.panic-abort.mir index ad1ca5dff43a9..9e5c652c11d1a 100644 --- a/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.PreCodegen.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.PreCodegen.after.panic-abort.mir @@ -29,6 +29,8 @@ fn slice_ptr_get_unchecked_range(_1: *const [u32], _2: std::ops::Range) - } bb0: { + StorageLive(_3); + StorageLive(_4); _3 = move (_2.0: usize); _4 = move (_2.1: usize); StorageLive(_7); @@ -48,6 +50,8 @@ fn slice_ptr_get_unchecked_range(_1: *const [u32], _2: std::ops::Range) - StorageDead(_9); StorageDead(_8); StorageDead(_7); + StorageDead(_3); + StorageDead(_4); return; } } diff --git a/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.PreCodegen.after.panic-unwind.mir index ad1ca5dff43a9..9e5c652c11d1a 100644 --- a/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.PreCodegen.after.panic-unwind.mir +++ b/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.PreCodegen.after.panic-unwind.mir @@ -29,6 +29,8 @@ fn slice_ptr_get_unchecked_range(_1: *const [u32], _2: std::ops::Range) - } bb0: { + StorageLive(_3); + StorageLive(_4); _3 = move (_2.0: usize); _4 = move (_2.1: usize); StorageLive(_7); @@ -48,6 +50,8 @@ fn slice_ptr_get_unchecked_range(_1: *const [u32], _2: std::ops::Range) - StorageDead(_9); StorageDead(_8); StorageDead(_7); + StorageDead(_3); + StorageDead(_4); return; } } diff --git a/tests/mir-opt/pre-codegen/try_identity.new.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/try_identity.new.PreCodegen.after.mir index baa01e28a9410..6035f245c4977 100644 --- a/tests/mir-opt/pre-codegen/try_identity.new.PreCodegen.after.mir +++ b/tests/mir-opt/pre-codegen/try_identity.new.PreCodegen.after.mir @@ -29,8 +29,10 @@ fn new(_1: Result) -> Result { } bb1: { + StorageLive(_3); _3 = move ((_1 as Ok).0: T); _4 = ControlFlow::::Continue(copy _3); + StorageDead(_3); _5 = move ((_4 as Continue).0: T); _0 = Result::::Ok(copy _5); StorageDead(_4); @@ -38,10 +40,14 @@ fn new(_1: Result) -> Result { } bb2: { + StorageLive(_6); _6 = move ((_1 as Err).0: E); _4 = ControlFlow::::Break(copy _6); + StorageDead(_6); + StorageLive(_7); _7 = move ((_4 as Break).0: E); _0 = Result::::Err(copy _7); + StorageDead(_7); StorageDead(_4); goto -> bb3; } diff --git a/tests/mir-opt/pre-codegen/try_identity.old.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/try_identity.old.PreCodegen.after.mir index 889e80d26e1cc..aec51bfd8d745 100644 --- a/tests/mir-opt/pre-codegen/try_identity.old.PreCodegen.after.mir +++ b/tests/mir-opt/pre-codegen/try_identity.old.PreCodegen.after.mir @@ -19,14 +19,18 @@ fn old(_1: Result) -> Result { } bb1: { + StorageLive(_3); _3 = copy ((_1 as Ok).0: T); + StorageDead(_3); _0 = copy _1; goto -> bb3; } bb2: { + StorageLive(_4); _4 = copy ((_1 as Err).0: E); _0 = copy _1; + StorageDead(_4); goto -> bb3; } diff --git a/tests/mir-opt/separate_const_switch.identity.JumpThreading.diff b/tests/mir-opt/separate_const_switch.identity.JumpThreading.diff index ce9d812701a8f..516edfbeb9c7e 100644 --- a/tests/mir-opt/separate_const_switch.identity.JumpThreading.diff +++ b/tests/mir-opt/separate_const_switch.identity.JumpThreading.diff @@ -57,9 +57,13 @@ } bb3: { + StorageLive(_4); _4 = copy ((_2 as Break).0: std::result::Result); + StorageLive(_10); _10 = copy ((_4 as Err).0: i32); _0 = Result::::Err(copy _10); + StorageDead(_10); + StorageDead(_4); StorageDead(_2); return; } diff --git a/tests/mir-opt/separate_const_switch.too_complex.JumpThreading.diff b/tests/mir-opt/separate_const_switch.too_complex.JumpThreading.diff index c88c63e0c1334..97be532254528 100644 --- a/tests/mir-opt/separate_const_switch.too_complex.JumpThreading.diff +++ b/tests/mir-opt/separate_const_switch.too_complex.JumpThreading.diff @@ -35,15 +35,19 @@ } bb2: { + StorageLive(_5); _5 = copy ((_1 as Err).0: usize); _2 = ControlFlow::::Break(copy _5); + StorageDead(_5); - goto -> bb4; + goto -> bb8; } bb3: { + StorageLive(_4); _4 = copy ((_1 as Ok).0: i32); _2 = ControlFlow::::Continue(copy _4); + StorageDead(_4); goto -> bb4; } @@ -62,8 +66,10 @@ } bb6: { + StorageLive(_7); _7 = copy ((_2 as Continue).0: i32); _0 = Option::::Some(copy _7); + StorageDead(_7); goto -> bb7; } diff --git a/tests/mir-opt/simplify_aggregate_to_copy_miscompile.foo.GVN.diff b/tests/mir-opt/simplify_aggregate_to_copy_miscompile.foo.GVN.diff index 54c11679f0c69..9d1c9079a2465 100644 --- a/tests/mir-opt/simplify_aggregate_to_copy_miscompile.foo.GVN.diff +++ b/tests/mir-opt/simplify_aggregate_to_copy_miscompile.foo.GVN.diff @@ -30,8 +30,7 @@ } bb2: { -- StorageLive(_5); -+ nop; + StorageLive(_5); _5 = copy (((*_2) as Some).0: i32); StorageLive(_7); - _7 = Option::::None; @@ -44,8 +43,7 @@ - _0 = Option::::Some(move _8); + _0 = Option::::Some(copy _5); StorageDead(_8); -- StorageDead(_5); -+ nop; + StorageDead(_5); StorageDead(_2); return; } diff --git a/tests/mir-opt/simplify_match.main.GVN.panic-abort.diff b/tests/mir-opt/simplify_match.main.GVN.panic-abort.diff index 9e798cbcac0c1..30c3b0bcfa1d7 100644 --- a/tests/mir-opt/simplify_match.main.GVN.panic-abort.diff +++ b/tests/mir-opt/simplify_match.main.GVN.panic-abort.diff @@ -11,14 +11,12 @@ bb0: { StorageLive(_1); -- StorageLive(_2); -+ nop; + StorageLive(_2); _2 = const false; - _1 = copy _2; -- StorageDead(_2); -- switchInt(copy _1) -> [0: bb2, otherwise: bb1]; + _1 = const false; -+ nop; + StorageDead(_2); +- switchInt(copy _1) -> [0: bb2, otherwise: bb1]; + switchInt(const false) -> [0: bb2, otherwise: bb1]; } diff --git a/tests/mir-opt/simplify_match.main.GVN.panic-unwind.diff b/tests/mir-opt/simplify_match.main.GVN.panic-unwind.diff index e243ff45ab0b2..7923d3210d83f 100644 --- a/tests/mir-opt/simplify_match.main.GVN.panic-unwind.diff +++ b/tests/mir-opt/simplify_match.main.GVN.panic-unwind.diff @@ -11,14 +11,12 @@ bb0: { StorageLive(_1); -- StorageLive(_2); -+ nop; + StorageLive(_2); _2 = const false; - _1 = copy _2; -- StorageDead(_2); -- switchInt(copy _1) -> [0: bb2, otherwise: bb1]; + _1 = const false; -+ nop; + StorageDead(_2); +- switchInt(copy _1) -> [0: bb2, otherwise: bb1]; + switchInt(const false) -> [0: bb2, otherwise: bb1]; } From f9d471607b899e5d4b960d2cb8e576b2384ab157 Mon Sep 17 00:00:00 2001 From: Ohad Ravid Date: Sun, 29 Jun 2025 08:07:37 +0300 Subject: [PATCH 05/25] Use a single bitset to check the storage in copy_prop, only check reachable blocks --- compiler/rustc_mir_transform/src/copy_prop.rs | 71 ++++++++++--------- ...y_prop_storage_unreachable.f.CopyProp.diff | 27 +++++++ .../copy_prop_storage_unreachable.rs | 35 +++++++++ ...ward_loop.PreCodegen.after.panic-abort.mir | 5 +- ...ard_loop.PreCodegen.after.panic-unwind.mir | 5 +- ...iter_next.PreCodegen.after.panic-abort.mir | 4 +- ...ter_next.PreCodegen.after.panic-unwind.mir | 4 +- 7 files changed, 108 insertions(+), 43 deletions(-) create mode 100644 tests/mir-opt/copy-prop/copy_prop_storage_unreachable.f.CopyProp.diff create mode 100644 tests/mir-opt/copy-prop/copy_prop_storage_unreachable.rs diff --git a/compiler/rustc_mir_transform/src/copy_prop.rs b/compiler/rustc_mir_transform/src/copy_prop.rs index bff7d7746bd01..6e5695d2d5b51 100644 --- a/compiler/rustc_mir_transform/src/copy_prop.rs +++ b/compiler/rustc_mir_transform/src/copy_prop.rs @@ -32,30 +32,20 @@ impl<'tcx> crate::MirPass<'tcx> for CopyProp { let typing_env = body.typing_env(tcx); let ssa = SsaLocals::new(tcx, body, typing_env); - let borrowed_locals = ssa.borrowed_locals().clone(); - debug!(?borrowed_locals); + debug!(borrowed_locals = ?ssa.borrowed_locals()); debug!(copy_classes = ?ssa.copy_classes()); let mut any_replacement = false; let fully_moved = fully_moved_locals(&ssa, body); debug!(?fully_moved); - let mut head_storage_to_check = DenseBitSet::new_empty(fully_moved.domain_size()); let mut storage_to_remove = DenseBitSet::new_empty(fully_moved.domain_size()); for (local, &head) in ssa.copy_classes().iter_enumerated() { if local != head { any_replacement = true; - // We need to determine if we can keep the head's storage statements (which enables better optimizations). - // For every local's usage location, if the head is maybe-uninitialized, we'll need to remove it's storage statements. - head_storage_to_check.insert(head); - - if borrowed_locals.contains(local) { - // To keep the storage of a head, we require that none of the locals in it's copy class are borrowed, - // since otherwise we cannot easily identify when it is used. - storage_to_remove.insert(head); - } + storage_to_remove.insert(head); } } @@ -66,8 +56,12 @@ impl<'tcx> crate::MirPass<'tcx> for CopyProp { let fully_moved = fully_moved_locals(&ssa, body); debug!(?fully_moved); - // Debug builds have no use for the storage statements, so avoid extra work. - let storage_to_remove = if any_replacement && tcx.sess.emit_lifetime_markers() { + // We can determine if we can keep the head's storage statements (which enables better optimizations). + // For every local's usage location, we'll to remove it's storage statements only if the head is maybe-uninitialized, + // or if the local is borrowed (since we cannot easily identify when it is used). + let storage_to_remove = if tcx.sess.emit_lifetime_markers() { + storage_to_remove.clear(); + let maybe_uninit = MaybeUninitializedLocals::new() .iterate_to_fixpoint(tcx, body, Some("mir_opt::copy_prop")) .into_results_cursor(body); @@ -75,16 +69,18 @@ impl<'tcx> crate::MirPass<'tcx> for CopyProp { let mut storage_checker = StorageChecker { maybe_uninit, copy_classes: ssa.copy_classes(), - head_storage_to_check, + borrowed_locals: ssa.borrowed_locals(), storage_to_remove, }; - storage_checker.visit_body(body); + for (bb, data) in traversal::reachable(body) { + storage_checker.visit_basic_block_data(bb, data); + } storage_checker.storage_to_remove } else { // Conservatively remove all storage statements for the head locals. - head_storage_to_check + storage_to_remove }; debug!(?storage_to_remove); @@ -197,7 +193,7 @@ impl<'tcx> MutVisitor<'tcx> for Replacer<'_, 'tcx> { struct StorageChecker<'a, 'tcx> { maybe_uninit: ResultsCursor<'a, 'tcx, MaybeUninitializedLocals>, copy_classes: &'a IndexSlice, - head_storage_to_check: DenseBitSet, + borrowed_locals: &'a DenseBitSet, storage_to_remove: DenseBitSet, } @@ -219,23 +215,28 @@ impl<'a, 'tcx> Visitor<'tcx> for StorageChecker<'a, 'tcx> { let head = self.copy_classes[local]; - // The head must be initialized at the location of the local, otherwise we must remove it's storage statements. - if self.head_storage_to_check.contains(head) { - self.maybe_uninit.seek_before_primary_effect(loc); - - if self.maybe_uninit.get().contains(head) { - debug!( - ?loc, - ?context, - ?local, - ?head, - "found a head at a location in which it is maybe uninit, marking head for storage statement removal" - ); - self.storage_to_remove.insert(head); - - // Once we found a use of the head that is maybe uninit, we do not need to check it again. - self.head_storage_to_check.remove(head); - } + // If the local is the head, or if we already marked it for deletion, we do not need to check it. + if head == local || self.storage_to_remove.contains(head) { + return; + } + + // If the local is borrowed, we cannot easily determine if it is used, so we have to remove the storage statements. + if self.borrowed_locals.contains(local) { + self.storage_to_remove.insert(head); + return; + } + + self.maybe_uninit.seek_before_primary_effect(loc); + + if self.maybe_uninit.get().contains(head) { + debug!( + ?loc, + ?context, + ?local, + ?head, + "found a head at a location in which it is maybe uninit, marking head for storage statement removal" + ); + self.storage_to_remove.insert(head); } } } diff --git a/tests/mir-opt/copy-prop/copy_prop_storage_unreachable.f.CopyProp.diff b/tests/mir-opt/copy-prop/copy_prop_storage_unreachable.f.CopyProp.diff new file mode 100644 index 0000000000000..93c186846908e --- /dev/null +++ b/tests/mir-opt/copy-prop/copy_prop_storage_unreachable.f.CopyProp.diff @@ -0,0 +1,27 @@ +- // MIR for `f` before CopyProp ++ // MIR for `f` after CopyProp + + fn f(_1: &mut usize) -> () { + let mut _0: (); + let mut _2: usize; + let mut _3: usize; + + bb0: { + StorageLive(_2); + _2 = const 42_usize; +- _3 = copy _2; +- (*_1) = copy _3; ++ (*_1) = copy _2; + StorageDead(_2); + return; + } + + bb1: { + StorageLive(_2); +- (*_1) = copy _3; ++ (*_1) = copy _2; + StorageDead(_2); + return; + } + } + diff --git a/tests/mir-opt/copy-prop/copy_prop_storage_unreachable.rs b/tests/mir-opt/copy-prop/copy_prop_storage_unreachable.rs new file mode 100644 index 0000000000000..65295acc8a226 --- /dev/null +++ b/tests/mir-opt/copy-prop/copy_prop_storage_unreachable.rs @@ -0,0 +1,35 @@ +// skip-filecheck +//@ test-mir-pass: CopyProp + +#![feature(custom_mir, core_intrinsics)] + +// Check that we do not remove the storage statements if the head +// is uninitialized in an unreachable block. + +use std::intrinsics::mir::*; + +// EMIT_MIR copy_prop_storage_unreachable.f.CopyProp.diff + +#[custom_mir(dialect = "runtime", phase = "post-cleanup")] +pub fn f(_1: &mut usize) { + mir! { + let _2: usize; + let _3: usize; + { + StorageLive(_2); + _2 = 42; + _3 = _2; + (*_1) = _3; + StorageDead(_2); + Return() + } + bb1 = { + // Ensure that _2 is considered uninitialized by `MaybeUninitializedLocals`. + StorageLive(_2); + // Use of _3 (in an unreachable block) when definition of _2 is unavailable. + (*_1) = _3; + StorageDead(_2); + Return() + } + } +} diff --git a/tests/mir-opt/pre-codegen/range_iter.forward_loop.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/range_iter.forward_loop.PreCodegen.after.panic-abort.mir index 3d44fd6807f19..ef73dd8150f63 100644 --- a/tests/mir-opt/pre-codegen/range_iter.forward_loop.PreCodegen.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/range_iter.forward_loop.PreCodegen.after.panic-abort.mir @@ -49,6 +49,7 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { bb1: { StorageLive(_9); + StorageLive(_7); StorageLive(_6); StorageLive(_5); _5 = copy _4; @@ -59,6 +60,7 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { bb2: { StorageDead(_6); + StorageDead(_7); StorageDead(_9); StorageDead(_4); drop(_3) -> [return: bb3, unwind unreachable]; @@ -69,15 +71,14 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { } bb4: { - StorageLive(_7); _7 = copy _4; StorageLive(_8); _8 = AddUnchecked(copy _7, const 1_u32); _4 = move _8; StorageDead(_8); _9 = Option::::Some(copy _7); - StorageDead(_7); StorageDead(_6); + StorageDead(_7); StorageLive(_10); _10 = copy ((_9 as Some).0: u32); StorageLive(_11); diff --git a/tests/mir-opt/pre-codegen/range_iter.forward_loop.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/range_iter.forward_loop.PreCodegen.after.panic-unwind.mir index b955501316549..a3b6cda831833 100644 --- a/tests/mir-opt/pre-codegen/range_iter.forward_loop.PreCodegen.after.panic-unwind.mir +++ b/tests/mir-opt/pre-codegen/range_iter.forward_loop.PreCodegen.after.panic-unwind.mir @@ -49,6 +49,7 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { bb1: { StorageLive(_9); + StorageLive(_7); StorageLive(_6); StorageLive(_5); _5 = copy _4; @@ -59,6 +60,7 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { bb2: { StorageDead(_6); + StorageDead(_7); StorageDead(_9); StorageDead(_4); drop(_3) -> [return: bb3, unwind continue]; @@ -69,15 +71,14 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { } bb4: { - StorageLive(_7); _7 = copy _4; StorageLive(_8); _8 = AddUnchecked(copy _7, const 1_u32); _4 = move _8; StorageDead(_8); _9 = Option::::Some(copy _7); - StorageDead(_7); StorageDead(_6); + StorageDead(_7); StorageLive(_10); _10 = copy ((_9 as Some).0: u32); StorageLive(_11); diff --git a/tests/mir-opt/pre-codegen/range_iter.range_iter_next.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/range_iter.range_iter_next.PreCodegen.after.panic-abort.mir index 55caea9d8f96d..335e0bcb6b1f2 100644 --- a/tests/mir-opt/pre-codegen/range_iter.range_iter_next.PreCodegen.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/range_iter.range_iter_next.PreCodegen.after.panic-abort.mir @@ -26,6 +26,7 @@ fn range_iter_next(_1: &mut std::ops::Range) -> Option { } bb0: { + StorageLive(_5); StorageLive(_4); StorageLive(_2); _2 = copy ((*_1).0: u32); @@ -43,19 +44,18 @@ fn range_iter_next(_1: &mut std::ops::Range) -> Option { } bb2: { - StorageLive(_5); _5 = copy ((*_1).0: u32); StorageLive(_6); _6 = AddUnchecked(copy _5, const 1_u32); ((*_1).0: u32) = move _6; StorageDead(_6); _0 = Option::::Some(copy _5); - StorageDead(_5); goto -> bb3; } bb3: { StorageDead(_4); + StorageDead(_5); return; } } diff --git a/tests/mir-opt/pre-codegen/range_iter.range_iter_next.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/range_iter.range_iter_next.PreCodegen.after.panic-unwind.mir index 55caea9d8f96d..335e0bcb6b1f2 100644 --- a/tests/mir-opt/pre-codegen/range_iter.range_iter_next.PreCodegen.after.panic-unwind.mir +++ b/tests/mir-opt/pre-codegen/range_iter.range_iter_next.PreCodegen.after.panic-unwind.mir @@ -26,6 +26,7 @@ fn range_iter_next(_1: &mut std::ops::Range) -> Option { } bb0: { + StorageLive(_5); StorageLive(_4); StorageLive(_2); _2 = copy ((*_1).0: u32); @@ -43,19 +44,18 @@ fn range_iter_next(_1: &mut std::ops::Range) -> Option { } bb2: { - StorageLive(_5); _5 = copy ((*_1).0: u32); StorageLive(_6); _6 = AddUnchecked(copy _5, const 1_u32); ((*_1).0: u32) = move _6; StorageDead(_6); _0 = Option::::Some(copy _5); - StorageDead(_5); goto -> bb3; } bb3: { StorageDead(_4); + StorageDead(_5); return; } } From 59e3caffff05325ab53bc1ae4df33c8ccab58405 Mon Sep 17 00:00:00 2001 From: Ohad Ravid Date: Sun, 29 Jun 2025 08:23:31 +0300 Subject: [PATCH 06/25] Added test for preserving head storage --- ...prop_storage_preserve_head.f.CopyProp.diff | 20 +++++++++++++++ .../copy_prop_storage_preserve_head.rs | 25 +++++++++++++++++++ 2 files changed, 45 insertions(+) create mode 100644 tests/mir-opt/copy-prop/copy_prop_storage_preserve_head.f.CopyProp.diff create mode 100644 tests/mir-opt/copy-prop/copy_prop_storage_preserve_head.rs diff --git a/tests/mir-opt/copy-prop/copy_prop_storage_preserve_head.f.CopyProp.diff b/tests/mir-opt/copy-prop/copy_prop_storage_preserve_head.f.CopyProp.diff new file mode 100644 index 0000000000000..3eebfdd6303a1 --- /dev/null +++ b/tests/mir-opt/copy-prop/copy_prop_storage_preserve_head.f.CopyProp.diff @@ -0,0 +1,20 @@ +- // MIR for `f` before CopyProp ++ // MIR for `f` after CopyProp + + fn f(_1: &mut usize) -> () { + let mut _0: (); + let mut _2: usize; + let mut _3: usize; + + bb0: { + StorageLive(_2); + _2 = const 0_usize; +- _3 = copy _2; +- (*_1) = copy _3; ++ (*_1) = copy _2; + StorageDead(_2); + (*_1) = copy _2; + return; + } + } + diff --git a/tests/mir-opt/copy-prop/copy_prop_storage_preserve_head.rs b/tests/mir-opt/copy-prop/copy_prop_storage_preserve_head.rs new file mode 100644 index 0000000000000..c66da3aecb022 --- /dev/null +++ b/tests/mir-opt/copy-prop/copy_prop_storage_preserve_head.rs @@ -0,0 +1,25 @@ +// skip-filecheck +//@ test-mir-pass: CopyProp +//@ compile-flags: -Zlint-mir=false + +#![feature(custom_mir, core_intrinsics)] +use std::intrinsics::mir::*; + +// EMIT_MIR copy_prop_storage_preserve_head.f.CopyProp.diff + +#[custom_mir(dialect = "runtime", phase = "post-cleanup")] +pub fn f(_1: &mut usize) { + mir! { + let _2: usize; + let _3: usize; + { + StorageLive(_2); + _2 = 0; + _3 = _2; + (*_1) = _3; + StorageDead(_2); + (*_1) = _2; + Return() + } + } +} From 86ba3550d588944c6d735f81fbe6fd98da6d0c0a Mon Sep 17 00:00:00 2001 From: Ohad Ravid Date: Sun, 29 Jun 2025 08:39:42 +0300 Subject: [PATCH 07/25] Move `MaybeUninitializedLocals` to the ssa module --- .../src/impls/initialized.rs | 74 ------------------ compiler/rustc_mir_dataflow/src/impls/mod.rs | 2 +- compiler/rustc_mir_transform/src/copy_prop.rs | 8 +- compiler/rustc_mir_transform/src/gvn.rs | 3 +- compiler/rustc_mir_transform/src/ssa.rs | 75 +++++++++++++++++++ 5 files changed, 79 insertions(+), 83 deletions(-) diff --git a/compiler/rustc_mir_dataflow/src/impls/initialized.rs b/compiler/rustc_mir_dataflow/src/impls/initialized.rs index 81c0abae262cb..9216106b6eddc 100644 --- a/compiler/rustc_mir_dataflow/src/impls/initialized.rs +++ b/compiler/rustc_mir_dataflow/src/impls/initialized.rs @@ -605,80 +605,6 @@ impl<'tcx> Analysis<'tcx> for MaybeUninitializedPlaces<'_, 'tcx> { } } -/// A dataflow analysis that tracks locals that are maybe uninitialized. -/// -/// This is a simpler analysis than `MaybeUninitializedPlaces`, because it does not track -/// individual fields. -pub struct MaybeUninitializedLocals; - -impl MaybeUninitializedLocals { - pub fn new() -> Self { - Self {} - } -} - -impl<'tcx> Analysis<'tcx> for MaybeUninitializedLocals { - type Domain = DenseBitSet; - - const NAME: &'static str = "maybe_uninit_locals"; - - fn bottom_value(&self, body: &Body<'tcx>) -> Self::Domain { - // bottom = all locals are initialized. - DenseBitSet::new_empty(body.local_decls.len()) - } - - fn initialize_start_block(&self, body: &Body<'tcx>, state: &mut Self::Domain) { - // All locals start as uninitialized... - state.insert_all(); - // ...except for arguments, which are definitely initialized. - for arg in body.args_iter() { - state.remove(arg); - } - } - - fn apply_primary_statement_effect( - &mut self, - state: &mut Self::Domain, - statement: &mir::Statement<'tcx>, - _location: Location, - ) { - match statement.kind { - // An assignment makes a local initialized. - mir::StatementKind::Assign(box (place, _)) => { - if let Some(local) = place.as_local() { - state.remove(local); - } - } - // Deinit makes the local uninitialized. - mir::StatementKind::Deinit(box place) => { - // A deinit makes a local uninitialized. - if let Some(local) = place.as_local() { - state.insert(local); - } - } - // Storage{Live,Dead} makes a local uninitialized. - mir::StatementKind::StorageLive(local) | mir::StatementKind::StorageDead(local) => { - state.insert(local); - } - _ => {} - } - } - - fn apply_call_return_effect( - &mut self, - state: &mut Self::Domain, - _block: mir::BasicBlock, - return_places: CallReturnPlaces<'_, 'tcx>, - ) { - // The return place of a call is initialized. - return_places.for_each(|place| { - if let Some(local) = place.as_local() { - state.remove(local); - } - }); - } -} - /// There can be many more `InitIndex` than there are locals in a MIR body. /// We use a mixed bitset to avoid paying too high a memory footprint. pub type EverInitializedPlacesDomain = MixedBitSet; diff --git a/compiler/rustc_mir_dataflow/src/impls/mod.rs b/compiler/rustc_mir_dataflow/src/impls/mod.rs index 0f93e5ef15a82..6d573e1c00e1c 100644 --- a/compiler/rustc_mir_dataflow/src/impls/mod.rs +++ b/compiler/rustc_mir_dataflow/src/impls/mod.rs @@ -6,7 +6,7 @@ mod storage_liveness; pub use self::borrowed_locals::{MaybeBorrowedLocals, borrowed_locals}; pub use self::initialized::{ EverInitializedPlaces, EverInitializedPlacesDomain, MaybeInitializedPlaces, - MaybeUninitializedLocals, MaybeUninitializedPlaces, MaybeUninitializedPlacesDomain, + MaybeUninitializedPlaces, MaybeUninitializedPlacesDomain, }; pub use self::liveness::{ DefUse, MaybeLiveLocals, MaybeTransitiveLiveLocals, diff --git a/compiler/rustc_mir_transform/src/copy_prop.rs b/compiler/rustc_mir_transform/src/copy_prop.rs index 6e5695d2d5b51..4febf0c0125d4 100644 --- a/compiler/rustc_mir_transform/src/copy_prop.rs +++ b/compiler/rustc_mir_transform/src/copy_prop.rs @@ -3,11 +3,10 @@ use rustc_index::bit_set::DenseBitSet; use rustc_middle::mir::visit::*; use rustc_middle::mir::*; use rustc_middle::ty::TyCtxt; -use rustc_mir_dataflow::impls::MaybeUninitializedLocals; use rustc_mir_dataflow::{Analysis, ResultsCursor}; use tracing::{debug, instrument}; -use crate::ssa::SsaLocals; +use crate::ssa::{MaybeUninitializedLocals, SsaLocals}; /// Unify locals that copy each other. /// @@ -37,10 +36,7 @@ impl<'tcx> crate::MirPass<'tcx> for CopyProp { debug!(copy_classes = ?ssa.copy_classes()); let mut any_replacement = false; - let fully_moved = fully_moved_locals(&ssa, body); - debug!(?fully_moved); - - let mut storage_to_remove = DenseBitSet::new_empty(fully_moved.domain_size()); + let mut storage_to_remove = DenseBitSet::new_empty(body.local_decls.len()); for (local, &head) in ssa.copy_classes().iter_enumerated() { if local != head { diff --git a/compiler/rustc_mir_transform/src/gvn.rs b/compiler/rustc_mir_transform/src/gvn.rs index 5cb35610477dd..c9589e1b46e9c 100644 --- a/compiler/rustc_mir_transform/src/gvn.rs +++ b/compiler/rustc_mir_transform/src/gvn.rs @@ -108,13 +108,12 @@ use rustc_middle::mir::visit::*; use rustc_middle::mir::*; use rustc_middle::ty::layout::HasTypingEnv; use rustc_middle::ty::{self, Ty, TyCtxt}; -use rustc_mir_dataflow::impls::MaybeUninitializedLocals; use rustc_mir_dataflow::{Analysis, ResultsCursor}; use rustc_span::DUMMY_SP; use smallvec::SmallVec; use tracing::{debug, instrument, trace}; -use crate::ssa::SsaLocals; +use crate::ssa::{MaybeUninitializedLocals, SsaLocals}; pub(super) struct GVN; diff --git a/compiler/rustc_mir_transform/src/ssa.rs b/compiler/rustc_mir_transform/src/ssa.rs index a56f04cf48422..00249255044a1 100644 --- a/compiler/rustc_mir_transform/src/ssa.rs +++ b/compiler/rustc_mir_transform/src/ssa.rs @@ -14,6 +14,7 @@ use rustc_middle::middle::resolve_bound_vars::Set1; use rustc_middle::mir::visit::*; use rustc_middle::mir::*; use rustc_middle::ty::{self, TyCtxt}; +use rustc_mir_dataflow::Analysis; use tracing::{debug, instrument, trace}; pub(super) struct SsaLocals { @@ -391,3 +392,77 @@ impl StorageLiveLocals { matches!(self.storage_live[local], Set1::One(_)) } } + +/// A dataflow analysis that tracks locals that are maybe uninitialized. +/// +/// This is a simpler analysis than `MaybeUninitializedPlaces`, because it does not track +/// individual fields. +pub(crate) struct MaybeUninitializedLocals; + +impl MaybeUninitializedLocals { + pub(crate) fn new() -> Self { + Self {} + } +} + +impl<'tcx> Analysis<'tcx> for MaybeUninitializedLocals { + type Domain = DenseBitSet; + + const NAME: &'static str = "maybe_uninit_locals"; + + fn bottom_value(&self, body: &Body<'tcx>) -> Self::Domain { + // bottom = all locals are initialized. + DenseBitSet::new_empty(body.local_decls.len()) + } + + fn initialize_start_block(&self, body: &Body<'tcx>, state: &mut Self::Domain) { + // All locals start as uninitialized... + state.insert_all(); + // ...except for arguments, which are definitely initialized. + for arg in body.args_iter() { + state.remove(arg); + } + } + + fn apply_primary_statement_effect( + &mut self, + state: &mut Self::Domain, + statement: &Statement<'tcx>, + _location: Location, + ) { + match statement.kind { + // An assignment makes a local initialized. + StatementKind::Assign(box (place, _)) => { + if let Some(local) = place.as_local() { + state.remove(local); + } + } + // Deinit makes the local uninitialized. + StatementKind::Deinit(box place) => { + // A deinit makes a local uninitialized. + if let Some(local) = place.as_local() { + state.insert(local); + } + } + // Storage{Live,Dead} makes a local uninitialized. + StatementKind::StorageLive(local) | StatementKind::StorageDead(local) => { + state.insert(local); + } + _ => {} + } + } + + fn apply_call_return_effect( + &mut self, + state: &mut Self::Domain, + _block: BasicBlock, + return_places: CallReturnPlaces<'_, 'tcx>, + ) { + // The return place of a call is initialized. + return_places.for_each(|place| { + if let Some(local) = place.as_local() { + state.remove(local); + } + }); + } +} From 02ddf2f1b831fc18521a3197e839e2929670d8c2 Mon Sep 17 00:00:00 2001 From: Ohad Ravid Date: Sun, 29 Jun 2025 09:12:20 +0300 Subject: [PATCH 08/25] Added FileCheck to copy prop storage tests --- .../copy_prop_storage_preserve_head.rs | 6 +- ...moved_when_local_borrowed.f.CopyProp.diff} | 0 ...op_storage_removed_when_local_borrowed.rs} | 13 +- .../copy-prop/copy_prop_storage_twice.rs | 15 +- .../copy_prop_storage_unreachable.rs | 10 +- ...issue_141649.f_head_borrowed.CopyProp.diff | 32 ++++ .../issue_141649.f_move.CopyProp.diff | 25 +++ ...ssue_141649.main.CopyProp.panic-abort.diff | 142 ------------------ ...sue_141649.main.CopyProp.panic-unwind.diff | 142 ------------------ tests/mir-opt/copy-prop/issue_141649.rs | 91 +++++++---- .../issue_141649_debug.f_move.CopyProp.diff | 25 +++ ...41649_debug.main.CopyProp.panic-abort.diff | 100 ------------ ...1649_debug.main.CopyProp.panic-unwind.diff | 100 ------------ tests/mir-opt/copy-prop/issue_141649_debug.rs | 59 +++++--- 14 files changed, 213 insertions(+), 547 deletions(-) rename tests/mir-opt/copy-prop/{copy_prop_borrowed_storage_not_removed.f.CopyProp.diff => copy_prop_storage_removed_when_local_borrowed.f.CopyProp.diff} (100%) rename tests/mir-opt/copy-prop/{copy_prop_borrowed_storage_not_removed.rs => copy_prop_storage_removed_when_local_borrowed.rs} (57%) create mode 100644 tests/mir-opt/copy-prop/issue_141649.f_head_borrowed.CopyProp.diff create mode 100644 tests/mir-opt/copy-prop/issue_141649.f_move.CopyProp.diff delete mode 100644 tests/mir-opt/copy-prop/issue_141649.main.CopyProp.panic-abort.diff delete mode 100644 tests/mir-opt/copy-prop/issue_141649.main.CopyProp.panic-unwind.diff create mode 100644 tests/mir-opt/copy-prop/issue_141649_debug.f_move.CopyProp.diff delete mode 100644 tests/mir-opt/copy-prop/issue_141649_debug.main.CopyProp.panic-abort.diff delete mode 100644 tests/mir-opt/copy-prop/issue_141649_debug.main.CopyProp.panic-unwind.diff diff --git a/tests/mir-opt/copy-prop/copy_prop_storage_preserve_head.rs b/tests/mir-opt/copy-prop/copy_prop_storage_preserve_head.rs index c66da3aecb022..7a0fa273bbec9 100644 --- a/tests/mir-opt/copy-prop/copy_prop_storage_preserve_head.rs +++ b/tests/mir-opt/copy-prop/copy_prop_storage_preserve_head.rs @@ -1,4 +1,3 @@ -// skip-filecheck //@ test-mir-pass: CopyProp //@ compile-flags: -Zlint-mir=false @@ -9,10 +8,15 @@ use std::intrinsics::mir::*; #[custom_mir(dialect = "runtime", phase = "post-cleanup")] pub fn f(_1: &mut usize) { + // CHECK-LABEL: fn f( mir! { let _2: usize; let _3: usize; + // CHECK: bb0: { { + // CHECK: StorageLive(_2); + // CHECK: (*_1) = copy _2; + // CHECK: StorageDead(_2); StorageLive(_2); _2 = 0; _3 = _2; diff --git a/tests/mir-opt/copy-prop/copy_prop_borrowed_storage_not_removed.f.CopyProp.diff b/tests/mir-opt/copy-prop/copy_prop_storage_removed_when_local_borrowed.f.CopyProp.diff similarity index 100% rename from tests/mir-opt/copy-prop/copy_prop_borrowed_storage_not_removed.f.CopyProp.diff rename to tests/mir-opt/copy-prop/copy_prop_storage_removed_when_local_borrowed.f.CopyProp.diff diff --git a/tests/mir-opt/copy-prop/copy_prop_borrowed_storage_not_removed.rs b/tests/mir-opt/copy-prop/copy_prop_storage_removed_when_local_borrowed.rs similarity index 57% rename from tests/mir-opt/copy-prop/copy_prop_borrowed_storage_not_removed.rs rename to tests/mir-opt/copy-prop/copy_prop_storage_removed_when_local_borrowed.rs index 39a3fda47a8e5..0aef621a24d34 100644 --- a/tests/mir-opt/copy-prop/copy_prop_borrowed_storage_not_removed.rs +++ b/tests/mir-opt/copy-prop/copy_prop_storage_removed_when_local_borrowed.rs @@ -1,23 +1,26 @@ -// skip-filecheck +//! Check that we remove the storage statements if one of the locals is borrowed, +//! and the head isn't borrowed. //@ test-mir-pass: CopyProp #![feature(custom_mir, core_intrinsics, freeze)] -// Check that we remove the storage statements if one of the locals is borrowed, -// and the head isn't borrowed. - use std::intrinsics::mir::*; use std::marker::Freeze; -// EMIT_MIR copy_prop_borrowed_storage_not_removed.f.CopyProp.diff +// EMIT_MIR copy_prop_storage_removed_when_local_borrowed.f.CopyProp.diff #[custom_mir(dialect = "runtime")] pub fn f(_1: (T, T)) -> T { + // CHECK-LABEL: fn f( mir! { let _2: T; let _3: T; let _4: &T; + // CHECK: bb0: { { + // CHECK-NOT: StorageLive(_2); + // CHECK: _4 = &_2; + // CHECK-NOT: StorageDead(_2); StorageLive(_2); _2 = _1.0; _3 = _2; diff --git a/tests/mir-opt/copy-prop/copy_prop_storage_twice.rs b/tests/mir-opt/copy-prop/copy_prop_storage_twice.rs index 421bb55d62ecc..4f9a561197526 100644 --- a/tests/mir-opt/copy-prop/copy_prop_storage_twice.rs +++ b/tests/mir-opt/copy-prop/copy_prop_storage_twice.rs @@ -1,4 +1,3 @@ -// skip-filecheck //@ test-mir-pass: CopyProp //@ compile-flags: -Zlint-mir=false @@ -10,45 +9,55 @@ use std::intrinsics::mir::*; // EMIT_MIR copy_prop_storage_twice.dead_twice.CopyProp.diff -// EMIT_MIR copy_prop_storage_twice.live_twice.CopyProp.diff - #[custom_mir(dialect = "runtime")] pub fn dead_twice(_1: T) -> T { + // CHECK-LABEL: fn dead_twice( mir! { let _2: T; let _3: T; { + // CHECK-NOT: StorageLive(_2); StorageLive(_2); Call(_2 = opaque(Move(_1)), ReturnTo(bb1), UnwindUnreachable()) } bb1 = { + // CHECK-NOT: StorageDead(_2); + // CHECK-NOT: StorageLive(_2); + // CHECK: _0 = opaque::(move _2) -> [return: bb2, unwind unreachable]; let _3 = Move(_2); StorageDead(_2); StorageLive(_2); Call(RET = opaque(Move(_3)), ReturnTo(bb2), UnwindUnreachable()) } bb2 = { + // CHECK-NOT: StorageDead(_2); StorageDead(_2); Return() } } } +// EMIT_MIR copy_prop_storage_twice.live_twice.CopyProp.diff #[custom_mir(dialect = "runtime")] pub fn live_twice(_1: T) -> T { + // CHECK-LABEL: fn live_twice( mir! { let _2: T; let _3: T; { + // CHECK-NOT: StorageLive(_2); StorageLive(_2); Call(_2 = opaque(Move(_1)), ReturnTo(bb1), UnwindUnreachable()) } bb1 = { + // CHECK-NOT: StorageLive(_2); + // CHECK: _0 = opaque::(copy _2) -> [return: bb2, unwind unreachable]; let _3 = Move(_2); StorageLive(_2); Call(RET = opaque(_3), ReturnTo(bb2), UnwindUnreachable()) } bb2 = { + // CHECK-NOT: StorageDead(_2); StorageDead(_2); Return() } diff --git a/tests/mir-opt/copy-prop/copy_prop_storage_unreachable.rs b/tests/mir-opt/copy-prop/copy_prop_storage_unreachable.rs index 65295acc8a226..2d28913ff8476 100644 --- a/tests/mir-opt/copy-prop/copy_prop_storage_unreachable.rs +++ b/tests/mir-opt/copy-prop/copy_prop_storage_unreachable.rs @@ -1,21 +1,23 @@ -// skip-filecheck +//! Check that we do not remove the storage statements if the head +//! is uninitialized in an unreachable block. //@ test-mir-pass: CopyProp #![feature(custom_mir, core_intrinsics)] -// Check that we do not remove the storage statements if the head -// is uninitialized in an unreachable block. - use std::intrinsics::mir::*; // EMIT_MIR copy_prop_storage_unreachable.f.CopyProp.diff #[custom_mir(dialect = "runtime", phase = "post-cleanup")] pub fn f(_1: &mut usize) { + // CHECK-LABEL: fn f( mir! { let _2: usize; let _3: usize; { + // CHECK: StorageLive(_2); + // CHECK: (*_1) = copy _2; + // CHECK: StorageDead(_2); StorageLive(_2); _2 = 42; _3 = _2; diff --git a/tests/mir-opt/copy-prop/issue_141649.f_head_borrowed.CopyProp.diff b/tests/mir-opt/copy-prop/issue_141649.f_head_borrowed.CopyProp.diff new file mode 100644 index 0000000000000..f8c23f28ff1a9 --- /dev/null +++ b/tests/mir-opt/copy-prop/issue_141649.f_head_borrowed.CopyProp.diff @@ -0,0 +1,32 @@ +- // MIR for `f_head_borrowed` before CopyProp ++ // MIR for `f_head_borrowed` after CopyProp + + fn f_head_borrowed() -> () { + let mut _0: (); + let mut _1: S; + let mut _2: S; + let mut _3: S; + let mut _4: &S; + let mut _5: &S; + + bb0: { + StorageLive(_1); + _1 = S(const 1_u32, const 2_u32); +- StorageLive(_2); + _4 = &_1; +- _2 = copy _1; +- _3 = opaque::(move _1) -> [return: bb1, unwind unreachable]; ++ _3 = opaque::(copy _1) -> [return: bb1, unwind unreachable]; + } + + bb1: { +- StorageDead(_2); + StorageDead(_1); + _5 = opaque::<&S>(move _4) -> [return: bb2, unwind unreachable]; + } + + bb2: { + return; + } + } + diff --git a/tests/mir-opt/copy-prop/issue_141649.f_move.CopyProp.diff b/tests/mir-opt/copy-prop/issue_141649.f_move.CopyProp.diff new file mode 100644 index 0000000000000..89af99210124a --- /dev/null +++ b/tests/mir-opt/copy-prop/issue_141649.f_move.CopyProp.diff @@ -0,0 +1,25 @@ +- // MIR for `f_move` before CopyProp ++ // MIR for `f_move` after CopyProp + + fn f_move() -> () { + let mut _0: (); + let mut _1: S; + let mut _2: S; + let mut _3: S; + + bb0: { + StorageLive(_1); + _1 = S(const 1_u32, const 2_u32); +- StorageLive(_2); +- _2 = copy _1; +- _3 = opaque::(move _1) -> [return: bb1, unwind unreachable]; ++ _3 = opaque::(copy _1) -> [return: bb1, unwind unreachable]; + } + + bb1: { +- StorageDead(_2); + StorageDead(_1); + return; + } + } + diff --git a/tests/mir-opt/copy-prop/issue_141649.main.CopyProp.panic-abort.diff b/tests/mir-opt/copy-prop/issue_141649.main.CopyProp.panic-abort.diff deleted file mode 100644 index c68bfb1b8e94a..0000000000000 --- a/tests/mir-opt/copy-prop/issue_141649.main.CopyProp.panic-abort.diff +++ /dev/null @@ -1,142 +0,0 @@ -- // MIR for `main` before CopyProp -+ // MIR for `main` after CopyProp - - fn main() -> () { - let mut _0: (); - let _1: (); - let _2: main::S; - let _3: (); - let mut _4: main::S; - let _5: (); - let _6: main::S; - let _7: (); - let mut _8: main::S; - let _9: (); - let _10: main::S; - let _12: &main::S; - let mut _13: &main::S; - let _14: (); - let mut _15: main::S; - let _16: (); - let _17: main::C; - let _18: (); - let mut _19: main::C; - let _20: main::C; - let _21: (); - let mut _22: main::C; - scope 1 { - debug s1 => _2; - } - scope 2 { - debug s2 => _6; - } - scope 3 { - debug s3 => _10; - let _11: &main::S; - scope 4 { - debug borrowed_s3 => _11; - } - } - scope 5 { - debug c1 => _17; - } - scope 6 { - debug c2 => _20; - } - - bb0: { -- StorageLive(_1); - StorageLive(_2); - _2 = S(const 1_usize, const 2_usize); - StorageLive(_3); -- StorageLive(_4); -- _4 = move _2; -- _3 = std::mem::drop::(move _4) -> [return: bb1, unwind unreachable]; -+ _3 = std::mem::drop::(move _2) -> [return: bb1, unwind unreachable]; - } - - bb1: { -- StorageDead(_4); - StorageDead(_3); -- _1 = const (); - StorageDead(_2); -- StorageDead(_1); -- StorageLive(_5); - StorageLive(_6); - _6 = S(const 3_usize, const 4_usize); - StorageLive(_7); -- StorageLive(_8); -- _8 = move _6; -- _7 = std::mem::drop::(move _8) -> [return: bb2, unwind unreachable]; -+ _7 = std::mem::drop::(move _6) -> [return: bb2, unwind unreachable]; - } - - bb2: { -- StorageDead(_8); - StorageDead(_7); -- _5 = const (); - StorageDead(_6); -- StorageDead(_5); -- StorageLive(_9); - StorageLive(_10); - _10 = S(const 5_usize, const 6_usize); - StorageLive(_11); - _11 = &_10; - StorageLive(_12); -- StorageLive(_13); -- _13 = copy _11; -- _12 = opaque::<&S>(move _13) -> [return: bb3, unwind unreachable]; -+ _12 = opaque::<&S>(copy _11) -> [return: bb3, unwind unreachable]; - } - - bb3: { -- StorageDead(_13); - StorageDead(_12); - StorageLive(_14); -- StorageLive(_15); -- _15 = move _10; -- _14 = std::mem::drop::(move _15) -> [return: bb4, unwind unreachable]; -+ _14 = std::mem::drop::(move _10) -> [return: bb4, unwind unreachable]; - } - - bb4: { -- StorageDead(_15); - StorageDead(_14); -- _9 = const (); - StorageDead(_11); - StorageDead(_10); -- StorageDead(_9); -- StorageLive(_16); - StorageLive(_17); - _17 = C(const 1_usize, const 2_usize); - StorageLive(_18); -- StorageLive(_19); -- _19 = copy _17; -- _18 = std::mem::drop::(move _19) -> [return: bb5, unwind unreachable]; -+ _18 = std::mem::drop::(copy _17) -> [return: bb5, unwind unreachable]; - } - - bb5: { -- StorageDead(_19); - StorageDead(_18); -- _16 = const (); - StorageDead(_17); -- StorageDead(_16); - StorageLive(_20); - _20 = C(const 3_usize, const 4_usize); - StorageLive(_21); -- StorageLive(_22); -- _22 = copy _20; -- _21 = std::mem::drop::(move _22) -> [return: bb6, unwind unreachable]; -+ _21 = std::mem::drop::(copy _20) -> [return: bb6, unwind unreachable]; - } - - bb6: { -- StorageDead(_22); - StorageDead(_21); - _0 = const (); - StorageDead(_20); - return; - } - } - diff --git a/tests/mir-opt/copy-prop/issue_141649.main.CopyProp.panic-unwind.diff b/tests/mir-opt/copy-prop/issue_141649.main.CopyProp.panic-unwind.diff deleted file mode 100644 index 3535a9840f685..0000000000000 --- a/tests/mir-opt/copy-prop/issue_141649.main.CopyProp.panic-unwind.diff +++ /dev/null @@ -1,142 +0,0 @@ -- // MIR for `main` before CopyProp -+ // MIR for `main` after CopyProp - - fn main() -> () { - let mut _0: (); - let _1: (); - let _2: main::S; - let _3: (); - let mut _4: main::S; - let _5: (); - let _6: main::S; - let _7: (); - let mut _8: main::S; - let _9: (); - let _10: main::S; - let _12: &main::S; - let mut _13: &main::S; - let _14: (); - let mut _15: main::S; - let _16: (); - let _17: main::C; - let _18: (); - let mut _19: main::C; - let _20: main::C; - let _21: (); - let mut _22: main::C; - scope 1 { - debug s1 => _2; - } - scope 2 { - debug s2 => _6; - } - scope 3 { - debug s3 => _10; - let _11: &main::S; - scope 4 { - debug borrowed_s3 => _11; - } - } - scope 5 { - debug c1 => _17; - } - scope 6 { - debug c2 => _20; - } - - bb0: { -- StorageLive(_1); - StorageLive(_2); - _2 = S(const 1_usize, const 2_usize); - StorageLive(_3); -- StorageLive(_4); -- _4 = move _2; -- _3 = std::mem::drop::(move _4) -> [return: bb1, unwind continue]; -+ _3 = std::mem::drop::(move _2) -> [return: bb1, unwind continue]; - } - - bb1: { -- StorageDead(_4); - StorageDead(_3); -- _1 = const (); - StorageDead(_2); -- StorageDead(_1); -- StorageLive(_5); - StorageLive(_6); - _6 = S(const 3_usize, const 4_usize); - StorageLive(_7); -- StorageLive(_8); -- _8 = move _6; -- _7 = std::mem::drop::(move _8) -> [return: bb2, unwind continue]; -+ _7 = std::mem::drop::(move _6) -> [return: bb2, unwind continue]; - } - - bb2: { -- StorageDead(_8); - StorageDead(_7); -- _5 = const (); - StorageDead(_6); -- StorageDead(_5); -- StorageLive(_9); - StorageLive(_10); - _10 = S(const 5_usize, const 6_usize); - StorageLive(_11); - _11 = &_10; - StorageLive(_12); -- StorageLive(_13); -- _13 = copy _11; -- _12 = opaque::<&S>(move _13) -> [return: bb3, unwind continue]; -+ _12 = opaque::<&S>(copy _11) -> [return: bb3, unwind continue]; - } - - bb3: { -- StorageDead(_13); - StorageDead(_12); - StorageLive(_14); -- StorageLive(_15); -- _15 = move _10; -- _14 = std::mem::drop::(move _15) -> [return: bb4, unwind continue]; -+ _14 = std::mem::drop::(move _10) -> [return: bb4, unwind continue]; - } - - bb4: { -- StorageDead(_15); - StorageDead(_14); -- _9 = const (); - StorageDead(_11); - StorageDead(_10); -- StorageDead(_9); -- StorageLive(_16); - StorageLive(_17); - _17 = C(const 1_usize, const 2_usize); - StorageLive(_18); -- StorageLive(_19); -- _19 = copy _17; -- _18 = std::mem::drop::(move _19) -> [return: bb5, unwind continue]; -+ _18 = std::mem::drop::(copy _17) -> [return: bb5, unwind continue]; - } - - bb5: { -- StorageDead(_19); - StorageDead(_18); -- _16 = const (); - StorageDead(_17); -- StorageDead(_16); - StorageLive(_20); - _20 = C(const 3_usize, const 4_usize); - StorageLive(_21); -- StorageLive(_22); -- _22 = copy _20; -- _21 = std::mem::drop::(move _22) -> [return: bb6, unwind continue]; -+ _21 = std::mem::drop::(copy _20) -> [return: bb6, unwind continue]; - } - - bb6: { -- StorageDead(_22); - StorageDead(_21); - _0 = const (); - StorageDead(_20); - return; - } - } - diff --git a/tests/mir-opt/copy-prop/issue_141649.rs b/tests/mir-opt/copy-prop/issue_141649.rs index e3b9062d65101..25884a9808db9 100644 --- a/tests/mir-opt/copy-prop/issue_141649.rs +++ b/tests/mir-opt/copy-prop/issue_141649.rs @@ -1,34 +1,71 @@ -// skip-filecheck -// EMIT_MIR_FOR_EACH_PANIC_STRATEGY +//! Check that we do not remove storage statements when the head is alive for all usages. //@ test-mir-pass: CopyProp +// EMIT_MIR issue_141649.f_move.CopyProp.diff +// EMIT_MIR issue_141649.f_head_borrowed.CopyProp.diff -// EMIT_MIR issue_141649.main.CopyProp.diff -fn main() { - struct S(usize, usize); - { - let s1 = S(1, 2); - drop(s1); - } - { - let s2 = S(3, 4); - drop(s2); - } - { - let s3 = S(5, 6); - let borrowed_s3 = &s3; - opaque(borrowed_s3); - drop(s3); - } +#![feature(custom_mir, core_intrinsics)] + +use std::intrinsics::mir::*; - #[derive(Clone, Copy)] - struct C(usize, usize); - { - let c1 = C(1, 2); - drop(c1); +struct S(u32, u32); + +#[custom_mir(dialect = "runtime")] +pub fn f_move() { + // CHECK-LABEL: fn f_move( + mir! { + let _1: S; + let _2: S; + let _3: S; + { + // CHECK: StorageLive(_1); + // CHECK-NOT: StorageLive(_2); + // CHECK: _3 = opaque::(copy _1) -> [return: bb1, unwind unreachable]; + StorageLive(_1); + _1 = S(1, 2); + StorageLive(_2); + _2 = _1; + Call(_3 = opaque(Move(_1)), ReturnTo(bb1), UnwindUnreachable()) + } + bb1 = { + // CHECK-NOT: StorageDead(_2); + // CHECK: StorageDead(_1); + StorageDead(_2); + StorageDead(_1); + Return() + } } - { - let c2 = C(3, 4); - drop(c2); +} + +#[custom_mir(dialect = "runtime")] +fn f_head_borrowed() { + // CHECK-LABEL: fn f_head_borrowed( + mir! { + let _1: S; + let _2: S; + let _3: S; + let _4: &S; + let _5: &S; + { + // CHECK: StorageLive(_1); + // CHECK-NOT: StorageLive(_2); + // CHECK: _3 = opaque::(copy _1) -> [return: bb1, unwind unreachable]; + StorageLive(_1); + _1 = S(1, 2); + StorageLive(_2); + _4 = &_1; + _2 = _1; + Call(_3 = opaque(Move(_1)), ReturnTo(bb1), UnwindUnreachable()) + } + bb1 = { + // CHECK-NOT: StorageDead(_2); + // CHECK: StorageDead(_1); + StorageDead(_2); + StorageDead(_1); + Call(_5 = opaque(Move(_4)), ReturnTo(bb2), UnwindUnreachable()) + } + bb2 = { + Return() + } } } diff --git a/tests/mir-opt/copy-prop/issue_141649_debug.f_move.CopyProp.diff b/tests/mir-opt/copy-prop/issue_141649_debug.f_move.CopyProp.diff new file mode 100644 index 0000000000000..5cb3753399d59 --- /dev/null +++ b/tests/mir-opt/copy-prop/issue_141649_debug.f_move.CopyProp.diff @@ -0,0 +1,25 @@ +- // MIR for `f_move` before CopyProp ++ // MIR for `f_move` after CopyProp + + fn f_move() -> () { + let mut _0: (); + let mut _1: S; + let mut _2: S; + let mut _3: S; + + bb0: { +- StorageLive(_1); + _1 = S(const 1_u32, const 2_u32); +- StorageLive(_2); +- _2 = copy _1; +- _3 = opaque::(move _1) -> [return: bb1, unwind unreachable]; ++ _3 = opaque::(copy _1) -> [return: bb1, unwind unreachable]; + } + + bb1: { +- StorageDead(_2); +- StorageDead(_1); + return; + } + } + diff --git a/tests/mir-opt/copy-prop/issue_141649_debug.main.CopyProp.panic-abort.diff b/tests/mir-opt/copy-prop/issue_141649_debug.main.CopyProp.panic-abort.diff deleted file mode 100644 index 93629b0f9f3f9..0000000000000 --- a/tests/mir-opt/copy-prop/issue_141649_debug.main.CopyProp.panic-abort.diff +++ /dev/null @@ -1,100 +0,0 @@ -- // MIR for `main` before CopyProp -+ // MIR for `main` after CopyProp - - fn main() -> () { - let mut _0: (); - let _1: (); - let _2: main::S; - let _3: (); - let mut _4: main::S; - let _5: (); - let _6: main::S; - let _7: (); - let mut _8: main::S; - let _9: (); - let _10: main::C; - let _11: (); - let mut _12: main::C; - let _13: main::C; - let _14: (); - let mut _15: main::C; - scope 1 { - debug s1 => _2; - } - scope 2 { - debug s2 => _6; - } - scope 3 { - debug c1 => _10; - } - scope 4 { - debug c2 => _13; - } - - bb0: { -- StorageLive(_1); -- StorageLive(_2); - _2 = S(const 1_usize, const 2_usize); - StorageLive(_3); -- StorageLive(_4); -- _4 = move _2; -- _3 = std::mem::drop::(move _4) -> [return: bb1, unwind unreachable]; -+ _3 = std::mem::drop::(move _2) -> [return: bb1, unwind unreachable]; - } - - bb1: { -- StorageDead(_4); - StorageDead(_3); -- _1 = const (); -- StorageDead(_2); -- StorageDead(_1); -- StorageLive(_5); -- StorageLive(_6); - _6 = S(const 3_usize, const 4_usize); - StorageLive(_7); -- StorageLive(_8); -- _8 = move _6; -- _7 = std::mem::drop::(move _8) -> [return: bb2, unwind unreachable]; -+ _7 = std::mem::drop::(move _6) -> [return: bb2, unwind unreachable]; - } - - bb2: { -- StorageDead(_8); - StorageDead(_7); -- _5 = const (); -- StorageDead(_6); -- StorageDead(_5); -- StorageLive(_9); -- StorageLive(_10); - _10 = C(const 1_usize, const 2_usize); - StorageLive(_11); -- StorageLive(_12); -- _12 = copy _10; -- _11 = std::mem::drop::(move _12) -> [return: bb3, unwind unreachable]; -+ _11 = std::mem::drop::(copy _10) -> [return: bb3, unwind unreachable]; - } - - bb3: { -- StorageDead(_12); - StorageDead(_11); -- _9 = const (); -- StorageDead(_10); -- StorageDead(_9); -- StorageLive(_13); - _13 = C(const 3_usize, const 4_usize); - StorageLive(_14); -- StorageLive(_15); -- _15 = copy _13; -- _14 = std::mem::drop::(move _15) -> [return: bb4, unwind unreachable]; -+ _14 = std::mem::drop::(copy _13) -> [return: bb4, unwind unreachable]; - } - - bb4: { -- StorageDead(_15); - StorageDead(_14); - _0 = const (); -- StorageDead(_13); - return; - } - } - diff --git a/tests/mir-opt/copy-prop/issue_141649_debug.main.CopyProp.panic-unwind.diff b/tests/mir-opt/copy-prop/issue_141649_debug.main.CopyProp.panic-unwind.diff deleted file mode 100644 index e02fe72a47a7b..0000000000000 --- a/tests/mir-opt/copy-prop/issue_141649_debug.main.CopyProp.panic-unwind.diff +++ /dev/null @@ -1,100 +0,0 @@ -- // MIR for `main` before CopyProp -+ // MIR for `main` after CopyProp - - fn main() -> () { - let mut _0: (); - let _1: (); - let _2: main::S; - let _3: (); - let mut _4: main::S; - let _5: (); - let _6: main::S; - let _7: (); - let mut _8: main::S; - let _9: (); - let _10: main::C; - let _11: (); - let mut _12: main::C; - let _13: main::C; - let _14: (); - let mut _15: main::C; - scope 1 { - debug s1 => _2; - } - scope 2 { - debug s2 => _6; - } - scope 3 { - debug c1 => _10; - } - scope 4 { - debug c2 => _13; - } - - bb0: { -- StorageLive(_1); -- StorageLive(_2); - _2 = S(const 1_usize, const 2_usize); - StorageLive(_3); -- StorageLive(_4); -- _4 = move _2; -- _3 = std::mem::drop::(move _4) -> [return: bb1, unwind continue]; -+ _3 = std::mem::drop::(move _2) -> [return: bb1, unwind continue]; - } - - bb1: { -- StorageDead(_4); - StorageDead(_3); -- _1 = const (); -- StorageDead(_2); -- StorageDead(_1); -- StorageLive(_5); -- StorageLive(_6); - _6 = S(const 3_usize, const 4_usize); - StorageLive(_7); -- StorageLive(_8); -- _8 = move _6; -- _7 = std::mem::drop::(move _8) -> [return: bb2, unwind continue]; -+ _7 = std::mem::drop::(move _6) -> [return: bb2, unwind continue]; - } - - bb2: { -- StorageDead(_8); - StorageDead(_7); -- _5 = const (); -- StorageDead(_6); -- StorageDead(_5); -- StorageLive(_9); -- StorageLive(_10); - _10 = C(const 1_usize, const 2_usize); - StorageLive(_11); -- StorageLive(_12); -- _12 = copy _10; -- _11 = std::mem::drop::(move _12) -> [return: bb3, unwind continue]; -+ _11 = std::mem::drop::(copy _10) -> [return: bb3, unwind continue]; - } - - bb3: { -- StorageDead(_12); - StorageDead(_11); -- _9 = const (); -- StorageDead(_10); -- StorageDead(_9); -- StorageLive(_13); - _13 = C(const 3_usize, const 4_usize); - StorageLive(_14); -- StorageLive(_15); -- _15 = copy _13; -- _14 = std::mem::drop::(move _15) -> [return: bb4, unwind continue]; -+ _14 = std::mem::drop::(copy _13) -> [return: bb4, unwind continue]; - } - - bb4: { -- StorageDead(_15); - StorageDead(_14); - _0 = const (); -- StorageDead(_13); - return; - } - } - diff --git a/tests/mir-opt/copy-prop/issue_141649_debug.rs b/tests/mir-opt/copy-prop/issue_141649_debug.rs index 5769118700ca1..554228000b670 100644 --- a/tests/mir-opt/copy-prop/issue_141649_debug.rs +++ b/tests/mir-opt/copy-prop/issue_141649_debug.rs @@ -1,29 +1,42 @@ -// skip-filecheck -// EMIT_MIR_FOR_EACH_PANIC_STRATEGY -//! Tests that in lower opt levels we remove (more) storage statements using a simpler strategy. +//! In lower opt levels, we remove (more) storage statements using a simpler strategy. //@ test-mir-pass: CopyProp //@ compile-flags: -Copt-level=0 +// EMIT_MIR issue_141649_debug.f_move.CopyProp.diff -// EMIT_MIR issue_141649_debug.main.CopyProp.diff -fn main() { - struct S(usize, usize); - { - let s1 = S(1, 2); - drop(s1); - } - { - let s2 = S(3, 4); - drop(s2); - } +#![feature(custom_mir, core_intrinsics)] - #[derive(Clone, Copy)] - struct C(usize, usize); - { - let c1 = C(1, 2); - drop(c1); - } - { - let c2 = C(3, 4); - drop(c2); +use std::intrinsics::mir::*; + +struct S(u32, u32); + +#[custom_mir(dialect = "runtime")] +pub fn f_move() { + // CHECK-LABEL: fn f_move( + mir! { + let _1: S; + let _2: S; + let _3: S; + { + // CHECK-NOT: StorageLive(_1); + // CHECK-NOT: StorageLive(_2); + // CHECK: _3 = opaque::(copy _1) -> [return: bb1, unwind unreachable]; + StorageLive(_1); + _1 = S(1, 2); + StorageLive(_2); + _2 = _1; + Call(_3 = opaque(Move(_1)), ReturnTo(bb1), UnwindUnreachable()) + } + bb1 = { + // CHECK-NOT: StorageDead(_2); + // CHECK-NOT: StorageDead(_1); + StorageDead(_2); + StorageDead(_1); + Return() + } } } + +#[inline(never)] +fn opaque(a: T) -> T { + a +} From c56f2f1ac6b67d0cfccfebd8dbc65627cfa76b6e Mon Sep 17 00:00:00 2001 From: Ohad Ravid Date: Sun, 29 Jun 2025 10:32:54 +0300 Subject: [PATCH 09/25] Simplify GVN storage checker to use a single bitset --- compiler/rustc_mir_transform/src/gvn.rs | 26 ++++++++++++------------- 1 file changed, 12 insertions(+), 14 deletions(-) diff --git a/compiler/rustc_mir_transform/src/gvn.rs b/compiler/rustc_mir_transform/src/gvn.rs index c9589e1b46e9c..e0be36a6fd9e8 100644 --- a/compiler/rustc_mir_transform/src/gvn.rs +++ b/compiler/rustc_mir_transform/src/gvn.rs @@ -160,7 +160,7 @@ impl<'tcx> crate::MirPass<'tcx> for GVN { .into_results_cursor(body); let mut storage_checker = StorageChecker { - storage_to_check: state.reused_locals.clone(), + reused_locals: &state.reused_locals, storage_to_remove: DenseBitSet::new_empty(body.local_decls.len()), maybe_uninit, }; @@ -1984,7 +1984,7 @@ impl<'tcx> MutVisitor<'tcx> for StorageRemover<'tcx> { } struct StorageChecker<'a, 'tcx> { - storage_to_check: DenseBitSet, + reused_locals: &'a DenseBitSet, storage_to_remove: DenseBitSet, maybe_uninit: ResultsCursor<'a, 'tcx, MaybeUninitializedLocals>, } @@ -2004,18 +2004,16 @@ impl<'a, 'tcx> Visitor<'tcx> for StorageChecker<'a, 'tcx> { PlaceContext::MutatingUse(_) | PlaceContext::NonMutatingUse(_) => {} } - if self.storage_to_check.contains(local) { - self.maybe_uninit.seek_before_primary_effect(location); - - if self.maybe_uninit.get().contains(local) { - debug!( - ?location, - ?local, - "local is maybe uninit in this location, removing storage" - ); - self.storage_to_remove.insert(local); - self.storage_to_check.remove(local); - } + // We only need to check reused locals which we haven't already removed storage for. + if !self.reused_locals.contains(local) || self.storage_to_remove.contains(local) { + return; + } + + self.maybe_uninit.seek_before_primary_effect(location); + + if self.maybe_uninit.get().contains(local) { + debug!(?location, ?local, "local is maybe uninit in this location, removing storage"); + self.storage_to_remove.insert(local); } } } From da3f7aa993bb219053d1da8b30f4764710358d6e Mon Sep 17 00:00:00 2001 From: Ohad Ravid Date: Sun, 29 Jun 2025 11:13:35 +0300 Subject: [PATCH 10/25] Improve GVN storage tests --- .../gvn_storage_issue_141649.f.GVN.diff | 20 +++ tests/mir-opt/gvn_storage_issue_141649.rs | 32 +++++ .../gvn_storage_issue_141649_debug.f.GVN.diff | 22 ++++ .../mir-opt/gvn_storage_issue_141649_debug.rs | 31 +++++ tests/mir-opt/gvn_storage_twice.rs | 7 +- ...n_storage_remove.main.GVN.panic-abort.diff | 124 ------------------ ..._storage_remove.main.GVN.panic-unwind.diff | 124 ------------------ .../issue_141649_gvn_storage_remove.rs | 27 ---- 8 files changed, 111 insertions(+), 276 deletions(-) create mode 100644 tests/mir-opt/gvn_storage_issue_141649.f.GVN.diff create mode 100644 tests/mir-opt/gvn_storage_issue_141649.rs create mode 100644 tests/mir-opt/gvn_storage_issue_141649_debug.f.GVN.diff create mode 100644 tests/mir-opt/gvn_storage_issue_141649_debug.rs delete mode 100644 tests/mir-opt/issue_141649_gvn_storage_remove.main.GVN.panic-abort.diff delete mode 100644 tests/mir-opt/issue_141649_gvn_storage_remove.main.GVN.panic-unwind.diff delete mode 100644 tests/mir-opt/issue_141649_gvn_storage_remove.rs diff --git a/tests/mir-opt/gvn_storage_issue_141649.f.GVN.diff b/tests/mir-opt/gvn_storage_issue_141649.f.GVN.diff new file mode 100644 index 0000000000000..664839e792456 --- /dev/null +++ b/tests/mir-opt/gvn_storage_issue_141649.f.GVN.diff @@ -0,0 +1,20 @@ +- // MIR for `f` before GVN ++ // MIR for `f` after GVN + + fn f(_1: u32) -> () { + let mut _0: (); + let mut _2: S; + let mut _3: S; + + bb0: { + StorageLive(_2); + _2 = S(copy _1, const 2_u32); + StorageLive(_3); +- _3 = S(copy _1, const 2_u32); ++ _3 = copy _2; + StorageDead(_3); + StorageDead(_2); + return; + } + } + diff --git a/tests/mir-opt/gvn_storage_issue_141649.rs b/tests/mir-opt/gvn_storage_issue_141649.rs new file mode 100644 index 0000000000000..70323da03dea4 --- /dev/null +++ b/tests/mir-opt/gvn_storage_issue_141649.rs @@ -0,0 +1,32 @@ +//! Check that we do not remove storage statements when possible. +//@ test-mir-pass: GVN +// EMIT_MIR gvn_storage_issue_141649.f.GVN.diff + +#![feature(custom_mir, core_intrinsics)] + +use std::intrinsics::mir::*; + +struct S(u32, u32); + +#[custom_mir(dialect = "runtime")] +pub fn f(_1: u32) { + // CHECK-LABEL: fn f( + mir! { + let _2: S; + let _3: S; + { + // CHECK: StorageLive(_2); + // CHECK: StorageLive(_3); + // CHECK: _3 = copy _2; + // CHECK: StorageDead(_3); + // CHECK: StorageDead(_2); + StorageLive(_2); + _2 = S(_1, 2); + StorageLive(_3); + _3 = S(_1, 2); + StorageDead(_3); + StorageDead(_2); + Return() + } + } +} diff --git a/tests/mir-opt/gvn_storage_issue_141649_debug.f.GVN.diff b/tests/mir-opt/gvn_storage_issue_141649_debug.f.GVN.diff new file mode 100644 index 0000000000000..ee43324b2fe89 --- /dev/null +++ b/tests/mir-opt/gvn_storage_issue_141649_debug.f.GVN.diff @@ -0,0 +1,22 @@ +- // MIR for `f` before GVN ++ // MIR for `f` after GVN + + fn f(_1: u32) -> () { + let mut _0: (); + let mut _2: S; + let mut _3: S; + + bb0: { +- StorageLive(_2); ++ nop; + _2 = S(copy _1, const 2_u32); + StorageLive(_3); +- _3 = S(copy _1, const 2_u32); ++ _3 = copy _2; + StorageDead(_3); +- StorageDead(_2); ++ nop; + return; + } + } + diff --git a/tests/mir-opt/gvn_storage_issue_141649_debug.rs b/tests/mir-opt/gvn_storage_issue_141649_debug.rs new file mode 100644 index 0000000000000..2c397f58fe934 --- /dev/null +++ b/tests/mir-opt/gvn_storage_issue_141649_debug.rs @@ -0,0 +1,31 @@ +//! In lower opt levels, we remove any storage statements of reused locals. +//@ test-mir-pass: GVN +//@ compile-flags: -Copt-level=0 +// EMIT_MIR gvn_storage_issue_141649_debug.f.GVN.diff + +#![feature(custom_mir, core_intrinsics)] + +use std::intrinsics::mir::*; + +struct S(u32, u32); + +#[custom_mir(dialect = "runtime")] +pub fn f(_1: u32) { + // CHECK-LABEL: fn f( + mir! { + let _2: S; + let _3: S; + { + // CHECK-NOT: StorageLive(_2); + // CHECK: _3 = copy _2; + // CHECK-NOT: StorageDead(_2); + StorageLive(_2); + _2 = S(_1, 2); + StorageLive(_3); + _3 = S(_1, 2); + StorageDead(_3); + StorageDead(_2); + Return() + } + } +} diff --git a/tests/mir-opt/gvn_storage_twice.rs b/tests/mir-opt/gvn_storage_twice.rs index d6aa0ed87befe..624d8ef4efa8d 100644 --- a/tests/mir-opt/gvn_storage_twice.rs +++ b/tests/mir-opt/gvn_storage_twice.rs @@ -1,4 +1,3 @@ -// skip-filecheck //@ test-mir-pass: GVN //@ compile-flags: -Zlint-mir=false @@ -18,10 +17,12 @@ use std::intrinsics::mir::*; #[custom_mir(dialect = "runtime")] pub fn repeat_local(_1: usize, _2: usize, _3: i32) -> i32 { + // CHECK-LABEL: fn repeat_local( mir! { { let _4 = [_3; 5]; let _5 = &_4[_1]; + // CHECK: _0 = copy _3; RET = *_5; Return() } @@ -32,11 +33,13 @@ pub fn repeat_local(_1: usize, _2: usize, _3: i32) -> i32 { #[custom_mir(dialect = "runtime")] pub fn repeat_local_dead(_1: usize, _2: usize, _3: i32) -> i32 { + // CHECK-LABEL: fn repeat_local_dead( mir! { { let _4 = [_3; 5]; let _5 = &_4[_1]; StorageDead(_3); + // CHECK: _0 = copy _3; RET = *_5; Return() } @@ -47,12 +50,14 @@ pub fn repeat_local_dead(_1: usize, _2: usize, _3: i32) -> i32 { #[custom_mir(dialect = "runtime")] pub fn repeat_local_dead_live(_1: usize, _2: usize, _3: i32) -> i32 { + // CHECK-LABEL: fn repeat_local_dead_live( mir! { { let _4 = [_3; 5]; let _5 = &_4[_1]; StorageDead(_3); StorageLive(_3); + // CHECK: _0 = copy _3; RET = *_5; Return() } diff --git a/tests/mir-opt/issue_141649_gvn_storage_remove.main.GVN.panic-abort.diff b/tests/mir-opt/issue_141649_gvn_storage_remove.main.GVN.panic-abort.diff deleted file mode 100644 index 79230f8e354a5..0000000000000 --- a/tests/mir-opt/issue_141649_gvn_storage_remove.main.GVN.panic-abort.diff +++ /dev/null @@ -1,124 +0,0 @@ -- // MIR for `main` before GVN -+ // MIR for `main` after GVN - - fn main() -> () { - let mut _0: (); - let _1: (); - let _2: main::S; - let _3: (); - let mut _4: main::S; - let _5: (); - let _6: main::S; - let _7: (); - let mut _8: main::S; - let _9: (); - let _10: main::C; - let _11: (); - let mut _12: main::C; - let _13: main::C; - let _14: (); - let mut _15: main::C; - scope 1 { - debug s1 => _2; - } - scope 2 { - debug s2 => _6; - } - scope 3 { - debug c1 => _10; - } - scope 4 { - debug c2 => _13; - } - - bb0: { - StorageLive(_1); - StorageLive(_2); -- _2 = S(const 1_u32, const 2_u32); -+ _2 = const S(1_u32, 2_u32); - StorageLive(_3); - StorageLive(_4); -- _4 = move _2; -- _3 = std::mem::drop::(move _4) -> [return: bb1, unwind unreachable]; -+ _4 = const S(1_u32, 2_u32); -+ _3 = std::mem::drop::(const S(1_u32, 2_u32)) -> [return: bb1, unwind unreachable]; - } - - bb1: { - StorageDead(_4); - StorageDead(_3); - _1 = const (); - StorageDead(_2); - StorageDead(_1); - StorageLive(_5); - StorageLive(_6); -- _6 = S(const 3_u32, const 4_u32); -+ _6 = const S(3_u32, 4_u32); - StorageLive(_7); - StorageLive(_8); -- _8 = move _6; -- _7 = std::mem::drop::(move _8) -> [return: bb2, unwind unreachable]; -+ _8 = const S(3_u32, 4_u32); -+ _7 = std::mem::drop::(const S(3_u32, 4_u32)) -> [return: bb2, unwind unreachable]; - } - - bb2: { - StorageDead(_8); - StorageDead(_7); - _5 = const (); - StorageDead(_6); - StorageDead(_5); - StorageLive(_9); - StorageLive(_10); -- _10 = C(const 1_u32, const 2_u32); -+ _10 = const C(1_u32, 2_u32); - StorageLive(_11); - StorageLive(_12); -- _12 = copy _10; -- _11 = std::mem::drop::(move _12) -> [return: bb3, unwind unreachable]; -+ _12 = const C(1_u32, 2_u32); -+ _11 = std::mem::drop::(const C(1_u32, 2_u32)) -> [return: bb3, unwind unreachable]; - } - - bb3: { - StorageDead(_12); - StorageDead(_11); - _9 = const (); - StorageDead(_10); - StorageDead(_9); - StorageLive(_13); -- _13 = C(const 3_u32, const 4_u32); -+ _13 = const C(3_u32, 4_u32); - StorageLive(_14); - StorageLive(_15); -- _15 = copy _13; -- _14 = std::mem::drop::(move _15) -> [return: bb4, unwind unreachable]; -+ _15 = const C(3_u32, 4_u32); -+ _14 = std::mem::drop::(const C(3_u32, 4_u32)) -> [return: bb4, unwind unreachable]; - } - - bb4: { - StorageDead(_15); - StorageDead(_14); - _0 = const (); - StorageDead(_13); - return; - } -+ } -+ -+ ALLOC0 (size: 8, align: 4) { -+ 03 00 00 00 04 00 00 00 │ ........ -+ } -+ -+ ALLOC1 (size: 8, align: 4) { -+ 01 00 00 00 02 00 00 00 │ ........ -+ } -+ -+ ALLOC2 (size: 8, align: 4) { -+ 03 00 00 00 04 00 00 00 │ ........ -+ } -+ -+ ALLOC3 (size: 8, align: 4) { -+ 01 00 00 00 02 00 00 00 │ ........ - } - diff --git a/tests/mir-opt/issue_141649_gvn_storage_remove.main.GVN.panic-unwind.diff b/tests/mir-opt/issue_141649_gvn_storage_remove.main.GVN.panic-unwind.diff deleted file mode 100644 index a9c68d742f504..0000000000000 --- a/tests/mir-opt/issue_141649_gvn_storage_remove.main.GVN.panic-unwind.diff +++ /dev/null @@ -1,124 +0,0 @@ -- // MIR for `main` before GVN -+ // MIR for `main` after GVN - - fn main() -> () { - let mut _0: (); - let _1: (); - let _2: main::S; - let _3: (); - let mut _4: main::S; - let _5: (); - let _6: main::S; - let _7: (); - let mut _8: main::S; - let _9: (); - let _10: main::C; - let _11: (); - let mut _12: main::C; - let _13: main::C; - let _14: (); - let mut _15: main::C; - scope 1 { - debug s1 => _2; - } - scope 2 { - debug s2 => _6; - } - scope 3 { - debug c1 => _10; - } - scope 4 { - debug c2 => _13; - } - - bb0: { - StorageLive(_1); - StorageLive(_2); -- _2 = S(const 1_u32, const 2_u32); -+ _2 = const S(1_u32, 2_u32); - StorageLive(_3); - StorageLive(_4); -- _4 = move _2; -- _3 = std::mem::drop::(move _4) -> [return: bb1, unwind continue]; -+ _4 = const S(1_u32, 2_u32); -+ _3 = std::mem::drop::(const S(1_u32, 2_u32)) -> [return: bb1, unwind continue]; - } - - bb1: { - StorageDead(_4); - StorageDead(_3); - _1 = const (); - StorageDead(_2); - StorageDead(_1); - StorageLive(_5); - StorageLive(_6); -- _6 = S(const 3_u32, const 4_u32); -+ _6 = const S(3_u32, 4_u32); - StorageLive(_7); - StorageLive(_8); -- _8 = move _6; -- _7 = std::mem::drop::(move _8) -> [return: bb2, unwind continue]; -+ _8 = const S(3_u32, 4_u32); -+ _7 = std::mem::drop::(const S(3_u32, 4_u32)) -> [return: bb2, unwind continue]; - } - - bb2: { - StorageDead(_8); - StorageDead(_7); - _5 = const (); - StorageDead(_6); - StorageDead(_5); - StorageLive(_9); - StorageLive(_10); -- _10 = C(const 1_u32, const 2_u32); -+ _10 = const C(1_u32, 2_u32); - StorageLive(_11); - StorageLive(_12); -- _12 = copy _10; -- _11 = std::mem::drop::(move _12) -> [return: bb3, unwind continue]; -+ _12 = const C(1_u32, 2_u32); -+ _11 = std::mem::drop::(const C(1_u32, 2_u32)) -> [return: bb3, unwind continue]; - } - - bb3: { - StorageDead(_12); - StorageDead(_11); - _9 = const (); - StorageDead(_10); - StorageDead(_9); - StorageLive(_13); -- _13 = C(const 3_u32, const 4_u32); -+ _13 = const C(3_u32, 4_u32); - StorageLive(_14); - StorageLive(_15); -- _15 = copy _13; -- _14 = std::mem::drop::(move _15) -> [return: bb4, unwind continue]; -+ _15 = const C(3_u32, 4_u32); -+ _14 = std::mem::drop::(const C(3_u32, 4_u32)) -> [return: bb4, unwind continue]; - } - - bb4: { - StorageDead(_15); - StorageDead(_14); - _0 = const (); - StorageDead(_13); - return; - } -+ } -+ -+ ALLOC0 (size: 8, align: 4) { -+ 03 00 00 00 04 00 00 00 │ ........ -+ } -+ -+ ALLOC1 (size: 8, align: 4) { -+ 01 00 00 00 02 00 00 00 │ ........ -+ } -+ -+ ALLOC2 (size: 8, align: 4) { -+ 03 00 00 00 04 00 00 00 │ ........ -+ } -+ -+ ALLOC3 (size: 8, align: 4) { -+ 01 00 00 00 02 00 00 00 │ ........ - } - diff --git a/tests/mir-opt/issue_141649_gvn_storage_remove.rs b/tests/mir-opt/issue_141649_gvn_storage_remove.rs deleted file mode 100644 index eb2b5337d0c41..0000000000000 --- a/tests/mir-opt/issue_141649_gvn_storage_remove.rs +++ /dev/null @@ -1,27 +0,0 @@ -// skip-filecheck -// EMIT_MIR_FOR_EACH_PANIC_STRATEGY -//@ test-mir-pass: GVN - -// EMIT_MIR issue_141649_gvn_storage_remove.main.GVN.diff -fn main() { - struct S(u32, u32); - { - let s1 = S(1, 2); - drop(s1); - } - { - let s2 = S(3, 4); - drop(s2); - } - - #[derive(Clone, Copy)] - struct C(u32, u32); - { - let c1 = C(1, 2); - drop(c1); - } - { - let c2 = C(3, 4); - drop(c2); - } -} From 5ade5083a08900f8cfe805b00c8ffa1c2063e801 Mon Sep 17 00:00:00 2001 From: Ohad Ravid Date: Sun, 29 Jun 2025 11:23:35 +0300 Subject: [PATCH 11/25] GVN unnit analysis shouldn't check unreachable blocks --- compiler/rustc_mir_transform/src/gvn.rs | 4 +- .../gvn_storage_unreachable.f.GVN.diff | 28 +++++++++++++ tests/mir-opt/gvn_storage_unreachable.rs | 41 +++++++++++++++++++ 3 files changed, 72 insertions(+), 1 deletion(-) create mode 100644 tests/mir-opt/gvn_storage_unreachable.f.GVN.diff create mode 100644 tests/mir-opt/gvn_storage_unreachable.rs diff --git a/compiler/rustc_mir_transform/src/gvn.rs b/compiler/rustc_mir_transform/src/gvn.rs index e0be36a6fd9e8..0f95f54cbd9b5 100644 --- a/compiler/rustc_mir_transform/src/gvn.rs +++ b/compiler/rustc_mir_transform/src/gvn.rs @@ -165,7 +165,9 @@ impl<'tcx> crate::MirPass<'tcx> for GVN { maybe_uninit, }; - storage_checker.visit_body(body); + for (bb, data) in traversal::reachable(body) { + storage_checker.visit_basic_block_data(bb, data); + } storage_checker.storage_to_remove } else { diff --git a/tests/mir-opt/gvn_storage_unreachable.f.GVN.diff b/tests/mir-opt/gvn_storage_unreachable.f.GVN.diff new file mode 100644 index 0000000000000..e29cbe0e2b00d --- /dev/null +++ b/tests/mir-opt/gvn_storage_unreachable.f.GVN.diff @@ -0,0 +1,28 @@ +- // MIR for `f` before GVN ++ // MIR for `f` after GVN + + fn f(_1: u32) -> () { + let mut _0: (); + let mut _2: S; + let mut _3: S; + let mut _4: S; + + bb0: { + StorageLive(_2); + _2 = S(copy _1, const 2_u32); + StorageLive(_3); +- _3 = S(copy _1, const 2_u32); ++ _3 = copy _2; + StorageDead(_3); + StorageDead(_2); + return; + } + + bb1: { + StorageLive(_2); + _4 = copy _2; + StorageDead(_2); + return; + } + } + diff --git a/tests/mir-opt/gvn_storage_unreachable.rs b/tests/mir-opt/gvn_storage_unreachable.rs new file mode 100644 index 0000000000000..20e362d1a71de --- /dev/null +++ b/tests/mir-opt/gvn_storage_unreachable.rs @@ -0,0 +1,41 @@ +//! Check that we do not remove the storage statements if a reused local +//! is uninitialized in an unreachable block. +//@ test-mir-pass: GVN +// EMIT_MIR gvn_storage_unreachable.f.GVN.diff + +#![feature(custom_mir, core_intrinsics)] + +use std::intrinsics::mir::*; + +struct S(u32, u32); + +#[custom_mir(dialect = "runtime", phase = "post-cleanup")] +pub fn f(_1: u32) { + // CHECK-LABEL: fn f( + mir! { + let _2: S; + let _3: S; + let _4: S; + { + // CHECK: StorageLive(_2); + // CHECK: StorageLive(_3); + // CHECK: _3 = copy _2; + // CHECK: StorageDead(_3); + // CHECK: StorageDead(_2); + StorageLive(_2); + _2 = S(_1, 2); + StorageLive(_3); + _3 = S(_1, 2); + StorageDead(_3); + StorageDead(_2); + Return() + } + bb1 = { + StorageLive(_2); + // CHECK: _4 = copy _2; + _4 = _2; + StorageDead(_2); + Return() + } + } +} From ce628ecf8b938e2589e5ad18e69b348c8c3ac5c2 Mon Sep 17 00:00:00 2001 From: Ohad Ravid Date: Sun, 29 Jun 2025 11:25:29 +0300 Subject: [PATCH 12/25] Add more FileCheck statements in gvn storage tests --- tests/mir-opt/gvn_storage_twice.rs | 3 +++ 1 file changed, 3 insertions(+) diff --git a/tests/mir-opt/gvn_storage_twice.rs b/tests/mir-opt/gvn_storage_twice.rs index 624d8ef4efa8d..ca040f7efd5d7 100644 --- a/tests/mir-opt/gvn_storage_twice.rs +++ b/tests/mir-opt/gvn_storage_twice.rs @@ -38,6 +38,7 @@ pub fn repeat_local_dead(_1: usize, _2: usize, _3: i32) -> i32 { { let _4 = [_3; 5]; let _5 = &_4[_1]; + // CHECK-NOT: StorageDead(_3); StorageDead(_3); // CHECK: _0 = copy _3; RET = *_5; @@ -55,6 +56,8 @@ pub fn repeat_local_dead_live(_1: usize, _2: usize, _3: i32) -> i32 { { let _4 = [_3; 5]; let _5 = &_4[_1]; + // CHECK-NOT: StorageLive(_3); + // CHECK-NOT: StorageDead(_3); StorageDead(_3); StorageLive(_3); // CHECK: _0 = copy _3; From 3f4ae04889d804c11ed29d61f552cef443e43ef1 Mon Sep 17 00:00:00 2001 From: Ohad Ravid Date: Sun, 29 Jun 2025 11:31:33 +0300 Subject: [PATCH 13/25] Added a GVN storage test for borrowed value --- ...n_storage_issue_141649.f_borrowed.GVN.diff | 25 +++++++++++++++++ tests/mir-opt/gvn_storage_issue_141649.rs | 27 +++++++++++++++++++ 2 files changed, 52 insertions(+) create mode 100644 tests/mir-opt/gvn_storage_issue_141649.f_borrowed.GVN.diff diff --git a/tests/mir-opt/gvn_storage_issue_141649.f_borrowed.GVN.diff b/tests/mir-opt/gvn_storage_issue_141649.f_borrowed.GVN.diff new file mode 100644 index 0000000000000..4e9d355be6083 --- /dev/null +++ b/tests/mir-opt/gvn_storage_issue_141649.f_borrowed.GVN.diff @@ -0,0 +1,25 @@ +- // MIR for `f_borrowed` before GVN ++ // MIR for `f_borrowed` after GVN + + fn f_borrowed(_1: u32) -> () { + let mut _0: (); + let mut _2: S; + let mut _3: S; + let mut _4: &S; + let mut _5: S; + + bb0: { +- StorageLive(_2); ++ nop; + _2 = S(copy _1, const 2_u32); +- _3 = S(copy _1, const 2_u32); ++ _3 = copy _2; + _4 = &_3; +- StorageDead(_2); +- _5 = copy (*_4); ++ nop; ++ _5 = copy _2; + return; + } + } + diff --git a/tests/mir-opt/gvn_storage_issue_141649.rs b/tests/mir-opt/gvn_storage_issue_141649.rs index 70323da03dea4..f6375119080c0 100644 --- a/tests/mir-opt/gvn_storage_issue_141649.rs +++ b/tests/mir-opt/gvn_storage_issue_141649.rs @@ -1,6 +1,7 @@ //! Check that we do not remove storage statements when possible. //@ test-mir-pass: GVN // EMIT_MIR gvn_storage_issue_141649.f.GVN.diff +// EMIT_MIR gvn_storage_issue_141649.f_borrowed.GVN.diff #![feature(custom_mir, core_intrinsics)] @@ -30,3 +31,29 @@ pub fn f(_1: u32) { } } } + +#[custom_mir(dialect = "runtime")] +pub fn f_borrowed(_1: u32) { + // CHECK-LABEL: fn f_borrowed( + mir! { + let _2: S; + let _3: S; + let _4: &S; + let _5: S; + { + // CHECK-NOT: StorageLive(_2); + // CHECK: _3 = copy _2; + // CHECK-NOT: StorageDead(_2); + // CHECK: _5 = copy _2; + StorageLive(_2); + _2 = S(_1, 2); + _3 = S(_1, 2); + _4 = &_3; + StorageDead(_2); + // Because `*_4` will be replaced with `_2`, + // we have to remove the storage statements of `_2`. + _5 = *_4; + Return() + } + } +} From 550a3a97949db9b81b1424547ad3872b065febb2 Mon Sep 17 00:00:00 2001 From: Ohad Ravid Date: Sun, 29 Jun 2025 12:09:04 +0300 Subject: [PATCH 14/25] Improved wording in comments and logs --- compiler/rustc_mir_transform/src/copy_prop.rs | 11 ++++++----- compiler/rustc_mir_transform/src/gvn.rs | 13 +++++++++---- 2 files changed, 15 insertions(+), 9 deletions(-) diff --git a/compiler/rustc_mir_transform/src/copy_prop.rs b/compiler/rustc_mir_transform/src/copy_prop.rs index 4febf0c0125d4..90410a7dc52d9 100644 --- a/compiler/rustc_mir_transform/src/copy_prop.rs +++ b/compiler/rustc_mir_transform/src/copy_prop.rs @@ -52,9 +52,10 @@ impl<'tcx> crate::MirPass<'tcx> for CopyProp { let fully_moved = fully_moved_locals(&ssa, body); debug!(?fully_moved); - // We can determine if we can keep the head's storage statements (which enables better optimizations). - // For every local's usage location, we'll to remove it's storage statements only if the head is maybe-uninitialized, - // or if the local is borrowed (since we cannot easily identify when it is used). + // When emitting storage statements, we want to retain the head locals' storage statements, + // as this enables better optimizations. For each local use location, we mark the head for storage removal + // only if the head might be uninitialized at that point, or if the local is borrowed + // (since we cannot easily determine when it's used). let storage_to_remove = if tcx.sess.emit_lifetime_markers() { storage_to_remove.clear(); @@ -75,7 +76,7 @@ impl<'tcx> crate::MirPass<'tcx> for CopyProp { storage_checker.storage_to_remove } else { - // Conservatively remove all storage statements for the head locals. + // Remove the storage statements of all the head locals. storage_to_remove }; @@ -230,7 +231,7 @@ impl<'a, 'tcx> Visitor<'tcx> for StorageChecker<'a, 'tcx> { ?context, ?local, ?head, - "found a head at a location in which it is maybe uninit, marking head for storage statement removal" + "local's head is maybe uninit at this location, marking head for storage statement removal" ); self.storage_to_remove.insert(head); } diff --git a/compiler/rustc_mir_transform/src/gvn.rs b/compiler/rustc_mir_transform/src/gvn.rs index 0f95f54cbd9b5..09a668de5ac89 100644 --- a/compiler/rustc_mir_transform/src/gvn.rs +++ b/compiler/rustc_mir_transform/src/gvn.rs @@ -152,8 +152,9 @@ impl<'tcx> crate::MirPass<'tcx> for GVN { state.visit_basic_block_data(bb, data); } - // If we emit storage annotations, use `MaybeStorageDead` to check which reused locals - // require storage removal (making them alive for the duration of the function). + // When emitting storage statements, we want to retain the reused locals' storage statements, + // as this enables better optimizations. For each local use location, we mark it for storage removal + // only if it might be uninitialized at that point. let storage_to_remove = if tcx.sess.emit_lifetime_markers() { let maybe_uninit = MaybeUninitializedLocals::new() .iterate_to_fixpoint(tcx, body, Some("mir_opt::gvn")) @@ -171,7 +172,7 @@ impl<'tcx> crate::MirPass<'tcx> for GVN { storage_checker.storage_to_remove } else { - // Conservatively remove all storage statements for reused locals. + // Remove the storage statements of all the reused locals. state.reused_locals.clone() }; @@ -2014,7 +2015,11 @@ impl<'a, 'tcx> Visitor<'tcx> for StorageChecker<'a, 'tcx> { self.maybe_uninit.seek_before_primary_effect(location); if self.maybe_uninit.get().contains(local) { - debug!(?location, ?local, "local is maybe uninit in this location, removing storage"); + debug!( + ?location, + ?local, + "local is reused and is maybe uninit at this location, marking it for storage statement removal" + ); self.storage_to_remove.insert(local); } } From 2d8df03972a8b56836bbde2a25ed0d0cbf769f43 Mon Sep 17 00:00:00 2001 From: Ohad Ravid Date: Fri, 4 Jul 2025 15:10:03 +0300 Subject: [PATCH 15/25] Added a storage usage inverse order test --- ...prop_storage_preserve_head.g.CopyProp.diff | 23 ++++++++++++++++ .../copy_prop_storage_preserve_head.rs | 27 +++++++++++++++++++ 2 files changed, 50 insertions(+) create mode 100644 tests/mir-opt/copy-prop/copy_prop_storage_preserve_head.g.CopyProp.diff diff --git a/tests/mir-opt/copy-prop/copy_prop_storage_preserve_head.g.CopyProp.diff b/tests/mir-opt/copy-prop/copy_prop_storage_preserve_head.g.CopyProp.diff new file mode 100644 index 0000000000000..d90cc6e8b41e5 --- /dev/null +++ b/tests/mir-opt/copy-prop/copy_prop_storage_preserve_head.g.CopyProp.diff @@ -0,0 +1,23 @@ +- // MIR for `g` before CopyProp ++ // MIR for `g` after CopyProp + + fn g() -> usize { + let mut _0: usize; + let mut _1: usize; + let mut _2: usize; + let mut _3: usize; + + bb0: { +- StorageLive(_2); + StorageLive(_1); + _1 = const 0_usize; +- _2 = copy _1; +- _3 = copy _2; +- _0 = Add(copy _3, copy _3); ++ _0 = Add(copy _1, copy _1); + StorageDead(_1); +- StorageDead(_2); + return; + } + } + diff --git a/tests/mir-opt/copy-prop/copy_prop_storage_preserve_head.rs b/tests/mir-opt/copy-prop/copy_prop_storage_preserve_head.rs index 7a0fa273bbec9..a54847915b969 100644 --- a/tests/mir-opt/copy-prop/copy_prop_storage_preserve_head.rs +++ b/tests/mir-opt/copy-prop/copy_prop_storage_preserve_head.rs @@ -5,6 +5,7 @@ use std::intrinsics::mir::*; // EMIT_MIR copy_prop_storage_preserve_head.f.CopyProp.diff +// EMIT_MIR copy_prop_storage_preserve_head.g.CopyProp.diff #[custom_mir(dialect = "runtime", phase = "post-cleanup")] pub fn f(_1: &mut usize) { @@ -27,3 +28,29 @@ pub fn f(_1: &mut usize) { } } } + +#[custom_mir(dialect = "runtime")] +pub fn g() -> usize { + // CHECK-LABEL: fn g( + mir! { + let _1: usize; + let _2: usize; + let _3: usize; + // CHECK: bb0: { + { + // CHECK: StorageLive(_1); + // CHECK: _0 = Add(copy _1, copy _1); + // CHECK: StorageDead(_1); + StorageLive(_2); + StorageLive(_1); + _1 = 0; + _2 = _1; + _3 = _2; + RET = _3 + _3; + // Even though the storage statements are in reverse order, we should be able to keep the ones for _1. + StorageDead(_1); + StorageDead(_2); + Return() + } + } +} \ No newline at end of file From f01bda91c43952327696b4e1c87ef12ff4a41b98 Mon Sep 17 00:00:00 2001 From: Ohad Ravid Date: Fri, 4 Jul 2025 15:16:02 +0300 Subject: [PATCH 16/25] Move borrowed_locals filtering out of StorageChecker --- compiler/rustc_mir_transform/src/copy_prop.rs | 17 +++++++++-------- 1 file changed, 9 insertions(+), 8 deletions(-) diff --git a/compiler/rustc_mir_transform/src/copy_prop.rs b/compiler/rustc_mir_transform/src/copy_prop.rs index 90410a7dc52d9..025623cf8c073 100644 --- a/compiler/rustc_mir_transform/src/copy_prop.rs +++ b/compiler/rustc_mir_transform/src/copy_prop.rs @@ -59,6 +59,15 @@ impl<'tcx> crate::MirPass<'tcx> for CopyProp { let storage_to_remove = if tcx.sess.emit_lifetime_markers() { storage_to_remove.clear(); + // If the local is borrowed, we cannot easily determine if it is used, so we have to remove the storage statements. + let borrowed_locals = ssa.borrowed_locals(); + + for (local, &head) in ssa.copy_classes().iter_enumerated() { + if local != head && borrowed_locals.contains(local) { + storage_to_remove.insert(head); + } + } + let maybe_uninit = MaybeUninitializedLocals::new() .iterate_to_fixpoint(tcx, body, Some("mir_opt::copy_prop")) .into_results_cursor(body); @@ -66,7 +75,6 @@ impl<'tcx> crate::MirPass<'tcx> for CopyProp { let mut storage_checker = StorageChecker { maybe_uninit, copy_classes: ssa.copy_classes(), - borrowed_locals: ssa.borrowed_locals(), storage_to_remove, }; @@ -190,7 +198,6 @@ impl<'tcx> MutVisitor<'tcx> for Replacer<'_, 'tcx> { struct StorageChecker<'a, 'tcx> { maybe_uninit: ResultsCursor<'a, 'tcx, MaybeUninitializedLocals>, copy_classes: &'a IndexSlice, - borrowed_locals: &'a DenseBitSet, storage_to_remove: DenseBitSet, } @@ -217,12 +224,6 @@ impl<'a, 'tcx> Visitor<'tcx> for StorageChecker<'a, 'tcx> { return; } - // If the local is borrowed, we cannot easily determine if it is used, so we have to remove the storage statements. - if self.borrowed_locals.contains(local) { - self.storage_to_remove.insert(head); - return; - } - self.maybe_uninit.seek_before_primary_effect(loc); if self.maybe_uninit.get().contains(head) { From aaca6b15302000574e44e0023317a805243b0f26 Mon Sep 17 00:00:00 2001 From: Ohad Ravid Date: Fri, 4 Jul 2025 15:19:01 +0300 Subject: [PATCH 17/25] in copy_prop, we should only ignore storage statement --- compiler/rustc_mir_transform/src/copy_prop.rs | 18 ++++-------------- .../copy_prop_storage_preserve_head.rs | 2 +- 2 files changed, 5 insertions(+), 15 deletions(-) diff --git a/compiler/rustc_mir_transform/src/copy_prop.rs b/compiler/rustc_mir_transform/src/copy_prop.rs index 025623cf8c073..0eddb8b7aee25 100644 --- a/compiler/rustc_mir_transform/src/copy_prop.rs +++ b/compiler/rustc_mir_transform/src/copy_prop.rs @@ -61,7 +61,7 @@ impl<'tcx> crate::MirPass<'tcx> for CopyProp { // If the local is borrowed, we cannot easily determine if it is used, so we have to remove the storage statements. let borrowed_locals = ssa.borrowed_locals(); - + for (local, &head) in ssa.copy_classes().iter_enumerated() { if local != head && borrowed_locals.contains(local) { storage_to_remove.insert(head); @@ -203,19 +203,9 @@ struct StorageChecker<'a, 'tcx> { impl<'a, 'tcx> Visitor<'tcx> for StorageChecker<'a, 'tcx> { fn visit_local(&mut self, local: Local, context: PlaceContext, loc: Location) { - // We don't need to check storage statements and statements for which the local doesn't need to be initialized. - match context { - PlaceContext::MutatingUse( - MutatingUseContext::Store - | MutatingUseContext::Call - | MutatingUseContext::Yield - | MutatingUseContext::AsmOutput, - ) - | PlaceContext::NonUse(_) => { - return; - } - _ => {} - }; + if !context.is_use() { + return; + } let head = self.copy_classes[local]; diff --git a/tests/mir-opt/copy-prop/copy_prop_storage_preserve_head.rs b/tests/mir-opt/copy-prop/copy_prop_storage_preserve_head.rs index a54847915b969..311a7177e78f8 100644 --- a/tests/mir-opt/copy-prop/copy_prop_storage_preserve_head.rs +++ b/tests/mir-opt/copy-prop/copy_prop_storage_preserve_head.rs @@ -53,4 +53,4 @@ pub fn g() -> usize { Return() } } -} \ No newline at end of file +} From 2a3939c29d759de53e4cdaed3f3a23bb6587ebe5 Mon Sep 17 00:00:00 2001 From: Ohad Ravid Date: Fri, 4 Jul 2025 15:22:06 +0300 Subject: [PATCH 18/25] Remove `MaybeUninitializedLocals`'s new --- compiler/rustc_mir_transform/src/copy_prop.rs | 2 +- compiler/rustc_mir_transform/src/gvn.rs | 2 +- compiler/rustc_mir_transform/src/ssa.rs | 6 ------ 3 files changed, 2 insertions(+), 8 deletions(-) diff --git a/compiler/rustc_mir_transform/src/copy_prop.rs b/compiler/rustc_mir_transform/src/copy_prop.rs index 0eddb8b7aee25..f28639799eca5 100644 --- a/compiler/rustc_mir_transform/src/copy_prop.rs +++ b/compiler/rustc_mir_transform/src/copy_prop.rs @@ -68,7 +68,7 @@ impl<'tcx> crate::MirPass<'tcx> for CopyProp { } } - let maybe_uninit = MaybeUninitializedLocals::new() + let maybe_uninit = MaybeUninitializedLocals .iterate_to_fixpoint(tcx, body, Some("mir_opt::copy_prop")) .into_results_cursor(body); diff --git a/compiler/rustc_mir_transform/src/gvn.rs b/compiler/rustc_mir_transform/src/gvn.rs index 09a668de5ac89..4c3923f6dfe2b 100644 --- a/compiler/rustc_mir_transform/src/gvn.rs +++ b/compiler/rustc_mir_transform/src/gvn.rs @@ -156,7 +156,7 @@ impl<'tcx> crate::MirPass<'tcx> for GVN { // as this enables better optimizations. For each local use location, we mark it for storage removal // only if it might be uninitialized at that point. let storage_to_remove = if tcx.sess.emit_lifetime_markers() { - let maybe_uninit = MaybeUninitializedLocals::new() + let maybe_uninit = MaybeUninitializedLocals .iterate_to_fixpoint(tcx, body, Some("mir_opt::gvn")) .into_results_cursor(body); diff --git a/compiler/rustc_mir_transform/src/ssa.rs b/compiler/rustc_mir_transform/src/ssa.rs index 00249255044a1..b0a05935bce58 100644 --- a/compiler/rustc_mir_transform/src/ssa.rs +++ b/compiler/rustc_mir_transform/src/ssa.rs @@ -399,12 +399,6 @@ impl StorageLiveLocals { /// individual fields. pub(crate) struct MaybeUninitializedLocals; -impl MaybeUninitializedLocals { - pub(crate) fn new() -> Self { - Self {} - } -} - impl<'tcx> Analysis<'tcx> for MaybeUninitializedLocals { type Domain = DenseBitSet; From 980bce4e34f56a8bde2fc54384665e1ef35fbc5b Mon Sep 17 00:00:00 2001 From: Ohad Ravid Date: Fri, 4 Jul 2025 15:37:11 +0300 Subject: [PATCH 19/25] Added another small test to gvn storage --- .../gvn_storage_issue_141649.f_dead.GVN.diff | 22 +++++++++++++++++ tests/mir-opt/gvn_storage_issue_141649.rs | 24 +++++++++++++++++++ 2 files changed, 46 insertions(+) create mode 100644 tests/mir-opt/gvn_storage_issue_141649.f_dead.GVN.diff diff --git a/tests/mir-opt/gvn_storage_issue_141649.f_dead.GVN.diff b/tests/mir-opt/gvn_storage_issue_141649.f_dead.GVN.diff new file mode 100644 index 0000000000000..0a20c56d549e8 --- /dev/null +++ b/tests/mir-opt/gvn_storage_issue_141649.f_dead.GVN.diff @@ -0,0 +1,22 @@ +- // MIR for `f_dead` before GVN ++ // MIR for `f_dead` after GVN + + fn f_dead(_1: u32) -> () { + let mut _0: (); + let mut _2: S; + let mut _3: S; + + bb0: { +- StorageLive(_2); ++ nop; + _2 = S(copy _1, const 2_u32); +- StorageDead(_2); ++ nop; + StorageLive(_3); +- _3 = S(copy _1, const 2_u32); ++ _3 = copy _2; + StorageDead(_3); + return; + } + } + diff --git a/tests/mir-opt/gvn_storage_issue_141649.rs b/tests/mir-opt/gvn_storage_issue_141649.rs index f6375119080c0..f87d9aa426160 100644 --- a/tests/mir-opt/gvn_storage_issue_141649.rs +++ b/tests/mir-opt/gvn_storage_issue_141649.rs @@ -2,6 +2,7 @@ //@ test-mir-pass: GVN // EMIT_MIR gvn_storage_issue_141649.f.GVN.diff // EMIT_MIR gvn_storage_issue_141649.f_borrowed.GVN.diff +// EMIT_MIR gvn_storage_issue_141649.f_dead.GVN.diff #![feature(custom_mir, core_intrinsics)] @@ -57,3 +58,26 @@ pub fn f_borrowed(_1: u32) { } } } + +#[custom_mir(dialect = "runtime")] +pub fn f_dead(_1: u32) { + // CHECK-LABEL: fn f_dead( + mir! { + let _2: S; + let _3: S; + { + // CHECK-NOT: StorageLive(_2); + // CHECK: StorageLive(_3); + // CHECK: _3 = copy _2; + // CHECK: StorageDead(_3); + // CHECK-NOT: StorageDead(_2); + StorageLive(_2); + _2 = S(_1, 2); + StorageDead(_2); + StorageLive(_3); + _3 = S(_1, 2); + StorageDead(_3); + Return() + } + } +} From 84b38c960a96c855fd7db23734a667a8886dc8e7 Mon Sep 17 00:00:00 2001 From: Ohad Ravid Date: Fri, 4 Jul 2025 15:38:20 +0300 Subject: [PATCH 20/25] fix comment in copy_prop_storage_preserve_head.rs --- tests/mir-opt/copy-prop/copy_prop_storage_preserve_head.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tests/mir-opt/copy-prop/copy_prop_storage_preserve_head.rs b/tests/mir-opt/copy-prop/copy_prop_storage_preserve_head.rs index 311a7177e78f8..ec506c70327e4 100644 --- a/tests/mir-opt/copy-prop/copy_prop_storage_preserve_head.rs +++ b/tests/mir-opt/copy-prop/copy_prop_storage_preserve_head.rs @@ -47,7 +47,8 @@ pub fn g() -> usize { _2 = _1; _3 = _2; RET = _3 + _3; - // Even though the storage statements are in reverse order, we should be able to keep the ones for _1. + // Even though the storage statements are in reverse order, + // we should be able to keep the ones for _1. StorageDead(_1); StorageDead(_2); Return() From 11f7063accba244c700b9eeb5cf92df9dd1fbbe9 Mon Sep 17 00:00:00 2001 From: Ohad Ravid Date: Fri, 4 Jul 2025 16:13:40 +0300 Subject: [PATCH 21/25] rerun and bless again after rebase (reordered storage statements) --- ...ut_updating_operand.test.GVN.32bit.panic-abort.diff | 10 +++++----- ...ut_updating_operand.test.GVN.64bit.panic-abort.diff | 10 +++++----- ...p_threading.identity.JumpThreading.panic-abort.diff | 10 ++++------ ..._threading.identity.JumpThreading.panic-unwind.diff | 10 ++++------ .../derived_ord.demo_le.PreCodegen.after.mir | 4 ++-- ...nt_invalid_constant.main.GVN.32bit.panic-abort.diff | 3 +-- ...nt_invalid_constant.main.GVN.64bit.panic-abort.diff | 3 +-- .../pre-codegen/loops.int_range.PreCodegen.after.mir | 5 ++--- .../pre-codegen/loops.mapped.PreCodegen.after.mir | 9 ++++----- ..._iter.forward_loop.PreCodegen.after.panic-abort.mir | 5 ++--- ...iter.forward_loop.PreCodegen.after.panic-unwind.mir | 5 ++--- ...er.range_iter_next.PreCodegen.after.panic-abort.mir | 4 ++-- ...r.range_iter_next.PreCodegen.after.panic-unwind.mir | 4 ++-- ...tion_map.map_via_question_mark.PreCodegen.after.mir | 3 +-- ...nchecked_mut_range.PreCodegen.after.panic-abort.mir | 4 ++-- ...checked_mut_range.PreCodegen.after.panic-unwind.mir | 4 ++-- ...et_unchecked_range.PreCodegen.after.panic-abort.mir | 4 ++-- ...t_unchecked_range.PreCodegen.after.panic-unwind.mir | 4 ++-- .../separate_const_switch.identity.JumpThreading.diff | 10 ++++------ 19 files changed, 49 insertions(+), 62 deletions(-) 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 89c57901d7f5a..4ef4bd4c5a2c6 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 @@ -78,9 +78,8 @@ - _12 = AlignOf(()); + _11 = const 0_usize; + _12 = const 1_usize; - StorageLive(_14); StorageLive(_16); - StorageLive(_17); + StorageLive(_14); StorageLive(_19); _19 = const false; - switchInt(move _19) -> [0: bb6, otherwise: bb5]; @@ -103,16 +102,17 @@ } bb4: { + StorageLive(_17); _17 = copy ((_15 as Ok).0: std::ptr::NonNull<[u8]>); StorageLive(_22); _22 = copy _17 as *mut [u8] (Transmute); _13 = copy _22 as *mut u8 (PtrToPtr); StorageDead(_22); - StorageDead(_15); StorageDead(_17); - StorageDead(_16); + StorageDead(_15); StorageDead(_14); - _3 = ShallowInitBox(copy _13, ()); + StorageDead(_16); + _3 = ShallowInitBox(move _13, ()); StorageDead(_13); StorageDead(_12); StorageDead(_11); 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 7673cf0f36471..a9a58f7f0c400 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 @@ -78,9 +78,8 @@ - _12 = AlignOf(()); + _11 = const 0_usize; + _12 = const 1_usize; - StorageLive(_14); StorageLive(_16); - StorageLive(_17); + StorageLive(_14); StorageLive(_19); _19 = const false; - switchInt(move _19) -> [0: bb6, otherwise: bb5]; @@ -103,16 +102,17 @@ } bb4: { + StorageLive(_17); _17 = copy ((_15 as Ok).0: std::ptr::NonNull<[u8]>); StorageLive(_22); _22 = copy _17 as *mut [u8] (Transmute); _13 = copy _22 as *mut u8 (PtrToPtr); StorageDead(_22); - StorageDead(_15); StorageDead(_17); - StorageDead(_16); + StorageDead(_15); StorageDead(_14); - _3 = ShallowInitBox(copy _13, ()); + StorageDead(_16); + _3 = ShallowInitBox(move _13, ()); StorageDead(_13); StorageDead(_12); StorageDead(_11); diff --git a/tests/mir-opt/jump_threading.identity.JumpThreading.panic-abort.diff b/tests/mir-opt/jump_threading.identity.JumpThreading.panic-abort.diff index 79599f856115d..09811088d25f6 100644 --- a/tests/mir-opt/jump_threading.identity.JumpThreading.panic-abort.diff +++ b/tests/mir-opt/jump_threading.identity.JumpThreading.panic-abort.diff @@ -47,8 +47,6 @@ StorageLive(_4); _4 = copy _1; StorageLive(_10); - StorageLive(_11); - StorageLive(_12); _10 = discriminant(_4); switchInt(move _10) -> [0: bb7, 1: bb6, otherwise: bb1]; } @@ -92,8 +90,6 @@ } bb5: { - StorageDead(_12); - StorageDead(_11); StorageDead(_10); StorageDead(_4); _5 = discriminant(_3); @@ -102,24 +98,26 @@ } bb6: { + StorageLive(_12); _12 = move ((_4 as Err).0: i32); StorageLive(_13); _13 = Result::::Err(copy _12); _3 = ControlFlow::, i32>::Break(move _13); StorageDead(_13); + StorageDead(_12); - goto -> bb5; + goto -> bb8; } bb7: { + StorageLive(_11); _11 = move ((_4 as Ok).0: i32); _3 = ControlFlow::, i32>::Continue(copy _11); + StorageDead(_11); goto -> bb5; + } + + bb8: { -+ StorageDead(_12); -+ StorageDead(_11); + StorageDead(_10); + StorageDead(_4); + _5 = discriminant(_3); diff --git a/tests/mir-opt/jump_threading.identity.JumpThreading.panic-unwind.diff b/tests/mir-opt/jump_threading.identity.JumpThreading.panic-unwind.diff index 79599f856115d..09811088d25f6 100644 --- a/tests/mir-opt/jump_threading.identity.JumpThreading.panic-unwind.diff +++ b/tests/mir-opt/jump_threading.identity.JumpThreading.panic-unwind.diff @@ -47,8 +47,6 @@ StorageLive(_4); _4 = copy _1; StorageLive(_10); - StorageLive(_11); - StorageLive(_12); _10 = discriminant(_4); switchInt(move _10) -> [0: bb7, 1: bb6, otherwise: bb1]; } @@ -92,8 +90,6 @@ } bb5: { - StorageDead(_12); - StorageDead(_11); StorageDead(_10); StorageDead(_4); _5 = discriminant(_3); @@ -102,24 +98,26 @@ } bb6: { + StorageLive(_12); _12 = move ((_4 as Err).0: i32); StorageLive(_13); _13 = Result::::Err(copy _12); _3 = ControlFlow::, i32>::Break(move _13); StorageDead(_13); + StorageDead(_12); - goto -> bb5; + goto -> bb8; } bb7: { + StorageLive(_11); _11 = move ((_4 as Ok).0: i32); _3 = ControlFlow::, i32>::Continue(copy _11); + StorageDead(_11); goto -> bb5; + } + + bb8: { -+ StorageDead(_12); -+ StorageDead(_11); + StorageDead(_10); + StorageDead(_4); + _5 = discriminant(_3); diff --git a/tests/mir-opt/pre-codegen/derived_ord.demo_le.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/derived_ord.demo_le.PreCodegen.after.mir index f498f4326056d..63bdf8b3aa0ef 100644 --- a/tests/mir-opt/pre-codegen/derived_ord.demo_le.PreCodegen.after.mir +++ b/tests/mir-opt/pre-codegen/derived_ord.demo_le.PreCodegen.after.mir @@ -37,7 +37,6 @@ fn demo_le(_1: &MultiField, _2: &MultiField) -> bool { } bb0: { - StorageLive(_12); StorageLive(_11); StorageLive(_5); StorageLive(_7); @@ -80,13 +79,14 @@ fn demo_le(_1: &MultiField, _2: &MultiField) -> bool { } bb3: { + StorageLive(_12); _12 = move ((_11 as Some).0: std::cmp::Ordering); StorageLive(_13); _13 = discriminant(_12); _0 = Le(move _13, const 0_i8); StorageDead(_13); - StorageDead(_11); StorageDead(_12); + StorageDead(_11); return; } } 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 556ee3a27cfe2..4e9123804d4dc 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 @@ -83,13 +83,13 @@ StorageDead(_8); StorageDead(_7); StorageLive(_12); - StorageLive(_16); _12 = discriminant(_6); switchInt(move _12) -> [0: bb6, 1: bb5, otherwise: bb1]; } bb5: { StorageLive(_15); + StorageLive(_16); _16 = &_13; _15 = copy _16 as &dyn std::fmt::Debug (PointerCoercion(Unsize, Implicit)); _14 = result::unwrap_failed(const "called `Result::unwrap()` on an `Err` value", move _15) -> unwind unreachable; @@ -97,7 +97,6 @@ bb6: { _5 = move ((_6 as Ok).0: std::ptr::NonNull<[u8]>); - StorageDead(_16); StorageDead(_12); StorageDead(_6); _4 = copy _5 as *mut [u8] (Transmute); 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 9c28c1f867864..aad8ea249d843 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 @@ -83,13 +83,13 @@ StorageDead(_8); StorageDead(_7); StorageLive(_12); - StorageLive(_16); _12 = discriminant(_6); switchInt(move _12) -> [0: bb6, 1: bb5, otherwise: bb1]; } bb5: { StorageLive(_15); + StorageLive(_16); _16 = &_13; _15 = copy _16 as &dyn std::fmt::Debug (PointerCoercion(Unsize, Implicit)); _14 = result::unwrap_failed(const "called `Result::unwrap()` on an `Err` value", move _15) -> unwind unreachable; @@ -97,7 +97,6 @@ bb6: { _5 = move ((_6 as Ok).0: std::ptr::NonNull<[u8]>); - StorageDead(_16); StorageDead(_12); StorageDead(_6); _4 = copy _5 as *mut [u8] (Transmute); diff --git a/tests/mir-opt/pre-codegen/loops.int_range.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/loops.int_range.PreCodegen.after.mir index a4050a261dcf6..e2abc718d06c4 100644 --- a/tests/mir-opt/pre-codegen/loops.int_range.PreCodegen.after.mir +++ b/tests/mir-opt/pre-codegen/loops.int_range.PreCodegen.after.mir @@ -62,7 +62,6 @@ fn int_range(_1: usize, _2: usize) -> () { bb1: { StorageLive(_13); _5 = &mut _4; - StorageLive(_11); StorageLive(_10); StorageLive(_6); _6 = &(_4.0: usize); @@ -82,7 +81,6 @@ fn int_range(_1: usize, _2: usize) -> () { StorageDead(_7); StorageDead(_6); StorageDead(_10); - StorageDead(_11); StorageDead(_13); StorageDead(_4); return; @@ -91,14 +89,15 @@ fn int_range(_1: usize, _2: usize) -> () { bb3: { StorageDead(_7); StorageDead(_6); + StorageLive(_11); _11 = copy (_4.0: usize); StorageLive(_12); _12 = AddUnchecked(copy _11, const 1_usize); (_4.0: usize) = move _12; StorageDead(_12); _13 = Option::::Some(copy _11); - StorageDead(_10); StorageDead(_11); + StorageDead(_10); StorageLive(_14); _14 = copy ((_13 as Some).0: usize); _15 = opaque::(move _14) -> [return: bb4, unwind continue]; diff --git a/tests/mir-opt/pre-codegen/loops.mapped.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/loops.mapped.PreCodegen.after.mir index e1bb56ef66eb5..f04111485125a 100644 --- a/tests/mir-opt/pre-codegen/loops.mapped.PreCodegen.after.mir +++ b/tests/mir-opt/pre-codegen/loops.mapped.PreCodegen.after.mir @@ -54,7 +54,6 @@ fn mapped(_1: impl Iterator, _2: impl Fn(T) -> U) -> () { bb2: { StorageLive(_13); _5 = &mut _4; - StorageLive(_8); StorageLive(_7); StorageLive(_6); _6 = &mut (_4.0: impl Iterator); @@ -63,18 +62,17 @@ fn mapped(_1: impl Iterator, _2: impl Fn(T) -> U) -> () { bb3: { StorageDead(_6); + StorageLive(_8); _8 = &mut (_4.1: impl Fn(T) -> U); StorageLive(_9); - StorageLive(_10); _9 = discriminant(_7); switchInt(move _9) -> [0: bb4, 1: bb6, otherwise: bb9]; } bb4: { - StorageDead(_10); StorageDead(_9); - StorageDead(_7); StorageDead(_8); + StorageDead(_7); StorageDead(_13); drop(_4) -> [return: bb5, unwind continue]; } @@ -85,6 +83,7 @@ fn mapped(_1: impl Iterator, _2: impl Fn(T) -> U) -> () { } bb6: { + StorageLive(_10); _10 = move ((_7 as Some).0: T); StorageLive(_12); StorageLive(_11); @@ -98,8 +97,8 @@ fn mapped(_1: impl Iterator, _2: impl Fn(T) -> U) -> () { StorageDead(_12); StorageDead(_10); StorageDead(_9); - StorageDead(_7); StorageDead(_8); + StorageDead(_7); StorageLive(_14); _14 = move ((_13 as Some).0: U); _15 = opaque::(move _14) -> [return: bb8, unwind: bb10]; diff --git a/tests/mir-opt/pre-codegen/range_iter.forward_loop.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/range_iter.forward_loop.PreCodegen.after.panic-abort.mir index ef73dd8150f63..3d44fd6807f19 100644 --- a/tests/mir-opt/pre-codegen/range_iter.forward_loop.PreCodegen.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/range_iter.forward_loop.PreCodegen.after.panic-abort.mir @@ -49,7 +49,6 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { bb1: { StorageLive(_9); - StorageLive(_7); StorageLive(_6); StorageLive(_5); _5 = copy _4; @@ -60,7 +59,6 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { bb2: { StorageDead(_6); - StorageDead(_7); StorageDead(_9); StorageDead(_4); drop(_3) -> [return: bb3, unwind unreachable]; @@ -71,14 +69,15 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { } bb4: { + StorageLive(_7); _7 = copy _4; StorageLive(_8); _8 = AddUnchecked(copy _7, const 1_u32); _4 = move _8; StorageDead(_8); _9 = Option::::Some(copy _7); - StorageDead(_6); StorageDead(_7); + StorageDead(_6); StorageLive(_10); _10 = copy ((_9 as Some).0: u32); StorageLive(_11); diff --git a/tests/mir-opt/pre-codegen/range_iter.forward_loop.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/range_iter.forward_loop.PreCodegen.after.panic-unwind.mir index a3b6cda831833..b955501316549 100644 --- a/tests/mir-opt/pre-codegen/range_iter.forward_loop.PreCodegen.after.panic-unwind.mir +++ b/tests/mir-opt/pre-codegen/range_iter.forward_loop.PreCodegen.after.panic-unwind.mir @@ -49,7 +49,6 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { bb1: { StorageLive(_9); - StorageLive(_7); StorageLive(_6); StorageLive(_5); _5 = copy _4; @@ -60,7 +59,6 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { bb2: { StorageDead(_6); - StorageDead(_7); StorageDead(_9); StorageDead(_4); drop(_3) -> [return: bb3, unwind continue]; @@ -71,14 +69,15 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { } bb4: { + StorageLive(_7); _7 = copy _4; StorageLive(_8); _8 = AddUnchecked(copy _7, const 1_u32); _4 = move _8; StorageDead(_8); _9 = Option::::Some(copy _7); - StorageDead(_6); StorageDead(_7); + StorageDead(_6); StorageLive(_10); _10 = copy ((_9 as Some).0: u32); StorageLive(_11); diff --git a/tests/mir-opt/pre-codegen/range_iter.range_iter_next.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/range_iter.range_iter_next.PreCodegen.after.panic-abort.mir index 335e0bcb6b1f2..55caea9d8f96d 100644 --- a/tests/mir-opt/pre-codegen/range_iter.range_iter_next.PreCodegen.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/range_iter.range_iter_next.PreCodegen.after.panic-abort.mir @@ -26,7 +26,6 @@ fn range_iter_next(_1: &mut std::ops::Range) -> Option { } bb0: { - StorageLive(_5); StorageLive(_4); StorageLive(_2); _2 = copy ((*_1).0: u32); @@ -44,18 +43,19 @@ fn range_iter_next(_1: &mut std::ops::Range) -> Option { } bb2: { + StorageLive(_5); _5 = copy ((*_1).0: u32); StorageLive(_6); _6 = AddUnchecked(copy _5, const 1_u32); ((*_1).0: u32) = move _6; StorageDead(_6); _0 = Option::::Some(copy _5); + StorageDead(_5); goto -> bb3; } bb3: { StorageDead(_4); - StorageDead(_5); return; } } diff --git a/tests/mir-opt/pre-codegen/range_iter.range_iter_next.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/range_iter.range_iter_next.PreCodegen.after.panic-unwind.mir index 335e0bcb6b1f2..55caea9d8f96d 100644 --- a/tests/mir-opt/pre-codegen/range_iter.range_iter_next.PreCodegen.after.panic-unwind.mir +++ b/tests/mir-opt/pre-codegen/range_iter.range_iter_next.PreCodegen.after.panic-unwind.mir @@ -26,7 +26,6 @@ fn range_iter_next(_1: &mut std::ops::Range) -> Option { } bb0: { - StorageLive(_5); StorageLive(_4); StorageLive(_2); _2 = copy ((*_1).0: u32); @@ -44,18 +43,19 @@ fn range_iter_next(_1: &mut std::ops::Range) -> Option { } bb2: { + StorageLive(_5); _5 = copy ((*_1).0: u32); StorageLive(_6); _6 = AddUnchecked(copy _5, const 1_u32); ((*_1).0: u32) = move _6; StorageDead(_6); _0 = Option::::Some(copy _5); + StorageDead(_5); goto -> bb3; } bb3: { StorageDead(_4); - StorageDead(_5); return; } } diff --git a/tests/mir-opt/pre-codegen/simple_option_map.map_via_question_mark.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/simple_option_map.map_via_question_mark.PreCodegen.after.mir index b921b96966b29..fae561ae4b927 100644 --- a/tests/mir-opt/pre-codegen/simple_option_map.map_via_question_mark.PreCodegen.after.mir +++ b/tests/mir-opt/pre-codegen/simple_option_map.map_via_question_mark.PreCodegen.after.mir @@ -29,13 +29,11 @@ fn map_via_question_mark(_1: Option) -> Option { StorageLive(_6); StorageLive(_4); StorageLive(_2); - StorageLive(_3); _2 = discriminant(_1); switchInt(move _2) -> [0: bb1, 1: bb2, otherwise: bb4]; } bb1: { - StorageDead(_3); StorageDead(_2); _0 = const Option::::None; StorageDead(_6); @@ -44,6 +42,7 @@ fn map_via_question_mark(_1: Option) -> Option { } bb2: { + StorageLive(_3); _3 = copy ((_1 as Some).0: i32); _4 = ControlFlow::, i32>::Continue(copy _3); StorageDead(_3); diff --git a/tests/mir-opt/pre-codegen/slice_index.slice_get_unchecked_mut_range.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/slice_index.slice_get_unchecked_mut_range.PreCodegen.after.panic-abort.mir index b03344c848d80..7af8d5998dbb2 100644 --- a/tests/mir-opt/pre-codegen/slice_index.slice_get_unchecked_mut_range.PreCodegen.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/slice_index.slice_get_unchecked_mut_range.PreCodegen.after.panic-abort.mir @@ -38,7 +38,6 @@ fn slice_get_unchecked_mut_range(_1: &mut [u32], _2: std::ops::Range) -> StorageLive(_11); StorageLive(_5); _5 = &raw mut (*_1); - StorageLive(_8); StorageLive(_6); _6 = PtrMetadata(copy _1); _7 = as SliceIndex<[T]>>::get_unchecked_mut::precondition_check(copy _3, copy _4, move _6) -> [return: bb1, unwind unreachable]; @@ -46,10 +45,11 @@ fn slice_get_unchecked_mut_range(_1: &mut [u32], _2: std::ops::Range) -> bb1: { StorageDead(_6); + StorageLive(_8); _8 = SubUnchecked(copy _4, copy _3); StorageLive(_9); - StorageLive(_10); _9 = copy _5 as *mut u32 (PtrToPtr); + StorageLive(_10); _10 = Offset(copy _9, copy _3); _11 = *mut [u32] from (copy _10, copy _8); StorageDead(_10); diff --git a/tests/mir-opt/pre-codegen/slice_index.slice_get_unchecked_mut_range.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/slice_index.slice_get_unchecked_mut_range.PreCodegen.after.panic-unwind.mir index b03344c848d80..7af8d5998dbb2 100644 --- a/tests/mir-opt/pre-codegen/slice_index.slice_get_unchecked_mut_range.PreCodegen.after.panic-unwind.mir +++ b/tests/mir-opt/pre-codegen/slice_index.slice_get_unchecked_mut_range.PreCodegen.after.panic-unwind.mir @@ -38,7 +38,6 @@ fn slice_get_unchecked_mut_range(_1: &mut [u32], _2: std::ops::Range) -> StorageLive(_11); StorageLive(_5); _5 = &raw mut (*_1); - StorageLive(_8); StorageLive(_6); _6 = PtrMetadata(copy _1); _7 = as SliceIndex<[T]>>::get_unchecked_mut::precondition_check(copy _3, copy _4, move _6) -> [return: bb1, unwind unreachable]; @@ -46,10 +45,11 @@ fn slice_get_unchecked_mut_range(_1: &mut [u32], _2: std::ops::Range) -> bb1: { StorageDead(_6); + StorageLive(_8); _8 = SubUnchecked(copy _4, copy _3); StorageLive(_9); - StorageLive(_10); _9 = copy _5 as *mut u32 (PtrToPtr); + StorageLive(_10); _10 = Offset(copy _9, copy _3); _11 = *mut [u32] from (copy _10, copy _8); StorageDead(_10); diff --git a/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.PreCodegen.after.panic-abort.mir index 9e5c652c11d1a..bd8df2979c98e 100644 --- a/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.PreCodegen.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.PreCodegen.after.panic-abort.mir @@ -33,7 +33,6 @@ fn slice_ptr_get_unchecked_range(_1: *const [u32], _2: std::ops::Range) - StorageLive(_4); _3 = move (_2.0: usize); _4 = move (_2.1: usize); - StorageLive(_7); StorageLive(_5); _5 = PtrMetadata(copy _1); _6 = as SliceIndex<[T]>>::get_unchecked::precondition_check(copy _3, copy _4, move _5) -> [return: bb1, unwind unreachable]; @@ -41,10 +40,11 @@ fn slice_ptr_get_unchecked_range(_1: *const [u32], _2: std::ops::Range) - bb1: { StorageDead(_5); + StorageLive(_7); _7 = SubUnchecked(copy _4, copy _3); StorageLive(_8); - StorageLive(_9); _8 = copy _1 as *const u32 (PtrToPtr); + StorageLive(_9); _9 = Offset(copy _8, copy _3); _0 = *const [u32] from (copy _9, copy _7); StorageDead(_9); diff --git a/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.PreCodegen.after.panic-unwind.mir index 9e5c652c11d1a..bd8df2979c98e 100644 --- a/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.PreCodegen.after.panic-unwind.mir +++ b/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.PreCodegen.after.panic-unwind.mir @@ -33,7 +33,6 @@ fn slice_ptr_get_unchecked_range(_1: *const [u32], _2: std::ops::Range) - StorageLive(_4); _3 = move (_2.0: usize); _4 = move (_2.1: usize); - StorageLive(_7); StorageLive(_5); _5 = PtrMetadata(copy _1); _6 = as SliceIndex<[T]>>::get_unchecked::precondition_check(copy _3, copy _4, move _5) -> [return: bb1, unwind unreachable]; @@ -41,10 +40,11 @@ fn slice_ptr_get_unchecked_range(_1: *const [u32], _2: std::ops::Range) - bb1: { StorageDead(_5); + StorageLive(_7); _7 = SubUnchecked(copy _4, copy _3); StorageLive(_8); - StorageLive(_9); _8 = copy _1 as *const u32 (PtrToPtr); + StorageLive(_9); _9 = Offset(copy _8, copy _3); _0 = *const [u32] from (copy _9, copy _7); StorageDead(_9); diff --git a/tests/mir-opt/separate_const_switch.identity.JumpThreading.diff b/tests/mir-opt/separate_const_switch.identity.JumpThreading.diff index 516edfbeb9c7e..a388d0ae2d195 100644 --- a/tests/mir-opt/separate_const_switch.identity.JumpThreading.diff +++ b/tests/mir-opt/separate_const_switch.identity.JumpThreading.diff @@ -39,8 +39,6 @@ bb0: { StorageLive(_2); StorageLive(_6); - StorageLive(_7); - StorageLive(_8); _6 = discriminant(_1); switchInt(move _6) -> [0: bb6, 1: bb5, otherwise: bb1]; } @@ -69,8 +67,6 @@ } bb4: { - StorageDead(_8); - StorageDead(_7); StorageDead(_6); _3 = discriminant(_2); - switchInt(move _3) -> [0: bb2, 1: bb3, otherwise: bb1]; @@ -78,24 +74,26 @@ } bb5: { + StorageLive(_8); _8 = copy ((_1 as Err).0: i32); StorageLive(_9); _9 = Result::::Err(copy _8); _2 = ControlFlow::, i32>::Break(move _9); StorageDead(_9); + StorageDead(_8); - goto -> bb4; + goto -> bb7; } bb6: { + StorageLive(_7); _7 = copy ((_1 as Ok).0: i32); _2 = ControlFlow::, i32>::Continue(copy _7); + StorageDead(_7); goto -> bb4; + } + + bb7: { -+ StorageDead(_8); -+ StorageDead(_7); + StorageDead(_6); + _3 = discriminant(_2); + goto -> bb3; From 5a3e6890e48b0c57b1fb2660fb3add259378dc87 Mon Sep 17 00:00:00 2001 From: Ohad Ravid Date: Fri, 18 Jul 2025 18:25:34 +0300 Subject: [PATCH 22/25] Update the tests after the change to copy_prop --- ...l.borrow_in_loop.CopyProp.panic-abort.diff | 12 +- ....borrow_in_loop.CopyProp.panic-unwind.diff | 12 +- ...emoved_when_local_borrowed.f.CopyProp.diff | 9 +- ...rop_storage_removed_when_local_borrowed.rs | 9 +- ...variant_a-{closure#0}.PreCodegen.after.mir | 209 +++++++++++------- 5 files changed, 155 insertions(+), 96 deletions(-) diff --git a/tests/mir-opt/copy-prop/borrowed_local.borrow_in_loop.CopyProp.panic-abort.diff b/tests/mir-opt/copy-prop/borrowed_local.borrow_in_loop.CopyProp.panic-abort.diff index 8c5e6a9e827a0..3d76cd65e0385 100644 --- a/tests/mir-opt/copy-prop/borrowed_local.borrow_in_loop.CopyProp.panic-abort.diff +++ b/tests/mir-opt/copy-prop/borrowed_local.borrow_in_loop.CopyProp.panic-abort.diff @@ -43,12 +43,12 @@ } bb1: { -- StorageLive(_6); + StorageLive(_6); StorageLive(_7); _7 = copy (*_2); _6 = Not(move _7); StorageDead(_7); -- StorageLive(_8); + StorageLive(_8); StorageLive(_9); _9 = copy (*_2); _8 = Not(move _9); @@ -80,8 +80,8 @@ - StorageDead(_14); _0 = const (); StorageDead(_13); -- StorageDead(_8); -- StorageDead(_6); + StorageDead(_8); + StorageDead(_6); - StorageDead(_4); StorageDead(_2); StorageDead(_1); @@ -93,8 +93,8 @@ - StorageDead(_14); - _5 = const (); StorageDead(_13); -- StorageDead(_8); -- StorageDead(_6); + StorageDead(_8); + StorageDead(_6); goto -> bb1; } } diff --git a/tests/mir-opt/copy-prop/borrowed_local.borrow_in_loop.CopyProp.panic-unwind.diff b/tests/mir-opt/copy-prop/borrowed_local.borrow_in_loop.CopyProp.panic-unwind.diff index 8c5e6a9e827a0..3d76cd65e0385 100644 --- a/tests/mir-opt/copy-prop/borrowed_local.borrow_in_loop.CopyProp.panic-unwind.diff +++ b/tests/mir-opt/copy-prop/borrowed_local.borrow_in_loop.CopyProp.panic-unwind.diff @@ -43,12 +43,12 @@ } bb1: { -- StorageLive(_6); + StorageLive(_6); StorageLive(_7); _7 = copy (*_2); _6 = Not(move _7); StorageDead(_7); -- StorageLive(_8); + StorageLive(_8); StorageLive(_9); _9 = copy (*_2); _8 = Not(move _9); @@ -80,8 +80,8 @@ - StorageDead(_14); _0 = const (); StorageDead(_13); -- StorageDead(_8); -- StorageDead(_6); + StorageDead(_8); + StorageDead(_6); - StorageDead(_4); StorageDead(_2); StorageDead(_1); @@ -93,8 +93,8 @@ - StorageDead(_14); - _5 = const (); StorageDead(_13); -- StorageDead(_8); -- StorageDead(_6); + StorageDead(_8); + StorageDead(_6); goto -> bb1; } } diff --git a/tests/mir-opt/copy-prop/copy_prop_storage_removed_when_local_borrowed.f.CopyProp.diff b/tests/mir-opt/copy-prop/copy_prop_storage_removed_when_local_borrowed.f.CopyProp.diff index 782b053cf2240..109fa10cfde97 100644 --- a/tests/mir-opt/copy-prop/copy_prop_storage_removed_when_local_borrowed.f.CopyProp.diff +++ b/tests/mir-opt/copy-prop/copy_prop_storage_removed_when_local_borrowed.f.CopyProp.diff @@ -8,12 +8,11 @@ let mut _4: &T; bb0: { -- StorageLive(_2); + StorageLive(_2); _2 = copy (_1.0: T); -- _3 = copy _2; -- _4 = &_3; -- StorageDead(_2); -+ _4 = &_2; + _3 = copy _2; + _4 = &_3; + StorageDead(_2); _0 = copy (*_4); return; } diff --git a/tests/mir-opt/copy-prop/copy_prop_storage_removed_when_local_borrowed.rs b/tests/mir-opt/copy-prop/copy_prop_storage_removed_when_local_borrowed.rs index 0aef621a24d34..f7595e60078f9 100644 --- a/tests/mir-opt/copy-prop/copy_prop_storage_removed_when_local_borrowed.rs +++ b/tests/mir-opt/copy-prop/copy_prop_storage_removed_when_local_borrowed.rs @@ -18,9 +18,12 @@ pub fn f(_1: (T, T)) -> T { let _4: &T; // CHECK: bb0: { { - // CHECK-NOT: StorageLive(_2); - // CHECK: _4 = &_2; - // CHECK-NOT: StorageDead(_2); + // FIXME: Currently, copy propagation will not unify borrowed locals. + // If it does, the storage statements for `_2` should be remove + // so these checks will need to be updated. + // CHECK: StorageLive(_2); + // CHECK: _4 = &_3; + // CHECK: StorageDead(_2); StorageLive(_2); _2 = _1.0; _3 = _2; diff --git a/tests/mir-opt/pre-codegen/slice_filter.variant_a-{closure#0}.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/slice_filter.variant_a-{closure#0}.PreCodegen.after.mir index 2cab88182962f..bb93139c31be5 100644 --- a/tests/mir-opt/pre-codegen/slice_filter.variant_a-{closure#0}.PreCodegen.after.mir +++ b/tests/mir-opt/pre-codegen/slice_filter.variant_a-{closure#0}.PreCodegen.after.mir @@ -3,134 +3,191 @@ fn variant_a::{closure#0}(_1: &mut {closure@$DIR/slice_filter.rs:7:25: 7:39}, _2: &&(usize, usize, usize, usize)) -> bool { let mut _0: bool; let mut _3: &(usize, usize, usize, usize); - let mut _6: bool; - let mut _9: bool; - let mut _10: bool; - let _13: &usize; - let _14: &usize; + let _4: &usize; + let _5: &usize; + let _6: &usize; + let _7: &usize; + let mut _8: &&usize; + let _9: &usize; + let mut _10: &&usize; + let mut _13: bool; + let mut _14: &&usize; let _15: &usize; - let _16: &usize; - let mut _17: &&usize; - let mut _18: &&usize; - let mut _19: &&usize; + let mut _16: &&usize; + let mut _19: bool; let mut _20: &&usize; - let mut _21: &&usize; + let _21: &usize; let mut _22: &&usize; - let mut _23: &&usize; + let mut _23: bool; let mut _24: &&usize; + let _25: &usize; + let mut _26: &&usize; scope 1 { - debug a => _13; - debug b => _14; - debug c => _15; - debug d => _16; + debug a => _4; + debug b => _5; + debug c => _6; + debug d => _7; scope 2 (inlined std::cmp::impls::::le) { - debug self => _17; - debug other => _18; + debug self => _8; + debug other => _10; scope 3 (inlined std::cmp::impls::::le) { - debug self => _13; - debug other => _15; - let mut _4: usize; - let mut _5: usize; + debug self => _4; + debug other => _6; + let mut _11: usize; + let mut _12: usize; } } scope 4 (inlined std::cmp::impls::::le) { - debug self => _19; - debug other => _20; + debug self => _14; + debug other => _16; scope 5 (inlined std::cmp::impls::::le) { - debug self => _16; - debug other => _14; - let mut _7: usize; - let mut _8: usize; + debug self => _7; + debug other => _5; + let mut _17: usize; + let mut _18: usize; } } scope 6 (inlined std::cmp::impls::::le) { - debug self => _21; + debug self => _20; debug other => _22; scope 7 (inlined std::cmp::impls::::le) { - debug self => _15; - debug other => _13; + debug self => _6; + debug other => _4; } } scope 8 (inlined std::cmp::impls::::le) { - debug self => _23; - debug other => _24; + debug self => _24; + debug other => _26; scope 9 (inlined std::cmp::impls::::le) { - debug self => _14; - debug other => _16; - let mut _11: usize; - let mut _12: usize; + debug self => _5; + debug other => _7; + let mut _27: usize; + let mut _28: usize; } } } bb0: { + StorageLive(_4); _3 = copy (*_2); - // DBG: _13 = &((*_3).0: usize); - // DBG: _14 = &((*_3).1: usize); - // DBG: _15 = &((*_3).2: usize); - // DBG: _16 = &((*_3).3: usize); + _4 = &((*_3).0: usize); + StorageLive(_5); + _5 = &((*_3).1: usize); StorageLive(_6); - // DBG: _17 = &_13; - // DBG: _18 = &?; - _4 = copy ((*_3).0: usize); - _5 = copy ((*_3).2: usize); - _6 = Le(copy _4, copy _5); - switchInt(move _6) -> [0: bb2, otherwise: bb1]; + _6 = &((*_3).2: usize); + StorageLive(_7); + _7 = &((*_3).3: usize); + StorageLive(_13); + StorageLive(_8); + _8 = &_4; + StorageLive(_10); + StorageLive(_9); + _9 = copy _6; + _10 = &_9; + _11 = copy ((*_3).0: usize); + _12 = copy ((*_3).2: usize); + _13 = Le(copy _11, copy _12); + switchInt(move _13) -> [0: bb1, otherwise: bb2]; } bb1: { - StorageLive(_9); - // DBG: _19 = &_16; - // DBG: _20 = &?; - StorageLive(_7); - _7 = copy ((*_3).3: usize); - StorageLive(_8); - _8 = copy ((*_3).1: usize); - _9 = Le(move _7, move _8); + StorageDead(_9); + StorageDead(_10); StorageDead(_8); - StorageDead(_7); - switchInt(move _9) -> [0: bb2, otherwise: bb6]; + goto -> bb4; } bb2: { - StorageLive(_10); - // DBG: _21 = &_15; - // DBG: _22 = &?; - _10 = Le(copy _5, copy _4); - switchInt(move _10) -> [0: bb3, otherwise: bb4]; + StorageDead(_9); + StorageDead(_10); + StorageDead(_8); + StorageLive(_19); + StorageLive(_14); + _14 = &_7; + StorageLive(_16); + StorageLive(_15); + _15 = copy _5; + _16 = &_15; + StorageLive(_17); + _17 = copy ((*_3).3: usize); + StorageLive(_18); + _18 = copy ((*_3).1: usize); + _19 = Le(move _17, move _18); + StorageDead(_18); + StorageDead(_17); + switchInt(move _19) -> [0: bb3, otherwise: bb8]; } bb3: { - _0 = const false; - goto -> bb5; + StorageDead(_15); + StorageDead(_16); + StorageDead(_14); + goto -> bb4; } bb4: { - // DBG: _23 = &_14; - // DBG: _24 = &?; - StorageLive(_11); - _11 = copy ((*_3).1: usize); - StorageLive(_12); - _12 = copy ((*_3).3: usize); - _0 = Le(move _11, move _12); - StorageDead(_12); - StorageDead(_11); - goto -> bb5; + StorageLive(_23); + StorageLive(_20); + _20 = &_6; + StorageLive(_22); + StorageLive(_21); + _21 = copy _4; + _22 = &_21; + _23 = Le(copy _12, copy _11); + switchInt(move _23) -> [0: bb5, otherwise: bb6]; } bb5: { - StorageDead(_10); + StorageDead(_21); + StorageDead(_22); + StorageDead(_20); + _0 = const false; goto -> bb7; } bb6: { - _0 = const true; + StorageDead(_21); + StorageDead(_22); + StorageDead(_20); + StorageLive(_24); + _24 = &_5; + StorageLive(_26); + StorageLive(_25); + _25 = copy _7; + _26 = &_25; + StorageLive(_27); + _27 = copy ((*_3).1: usize); + StorageLive(_28); + _28 = copy ((*_3).3: usize); + _0 = Le(move _27, move _28); + StorageDead(_28); + StorageDead(_27); + StorageDead(_25); + StorageDead(_26); + StorageDead(_24); goto -> bb7; } bb7: { - StorageDead(_9); + StorageDead(_23); + goto -> bb9; + } + + bb8: { + StorageDead(_15); + StorageDead(_16); + StorageDead(_14); + _0 = const true; + goto -> bb9; + } + + bb9: { + StorageDead(_19); + StorageDead(_13); + StorageDead(_7); StorageDead(_6); + StorageDead(_5); + StorageDead(_4); return; } } From 577dcd3f1dd36b3590cf29763e0f9c6023ff9108 Mon Sep 17 00:00:00 2001 From: Ohad Ravid Date: Sat, 4 Oct 2025 10:54:31 +0300 Subject: [PATCH 23/25] Bless the tests after merging from master --- ...ng_operand.test.GVN.32bit.panic-abort.diff | 2 +- ...ng_operand.test.GVN.64bit.panic-abort.diff | 2 +- ....dereference_indexing.GVN.panic-abort.diff | 11 +- ...dereference_indexing.GVN.panic-unwind.diff | 11 +- .../gvn.fn_pointers.GVN.panic-abort.diff | 18 +- .../gvn.fn_pointers.GVN.panic-unwind.diff | 18 +- ...implifyComparisonIntegral.panic-abort.diff | 36 ++- ...mplifyComparisonIntegral.panic-unwind.diff | 36 ++- .../derived_ord.demo_le.PreCodegen.after.mir | 35 ++- ....{impl#0}-partial_cmp.PreCodegen.after.mir | 2 - ...ace.PreCodegen.after.32bit.panic-abort.mir | 6 + ...ce.PreCodegen.after.32bit.panic-unwind.mir | 6 + ...ace.PreCodegen.after.64bit.panic-abort.mir | 6 + ...ce.PreCodegen.after.64bit.panic-unwind.mir | 6 + ...ward_loop.PreCodegen.after.panic-abort.mir | 70 +++--- ...ard_loop.PreCodegen.after.panic-unwind.mir | 70 +++--- ...variant_a-{closure#0}.PreCodegen.after.mir | 209 +++++++----------- ...dex_range.PreCodegen.after.panic-abort.mir | 6 +- ...ex_range.PreCodegen.after.panic-unwind.mir | 6 +- 19 files changed, 256 insertions(+), 300 deletions(-) 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 4ef4bd4c5a2c6..6b2da8c987d63 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 @@ -112,7 +112,7 @@ StorageDead(_15); StorageDead(_14); StorageDead(_16); - _3 = ShallowInitBox(move _13, ()); + _3 = ShallowInitBox(copy _13, ()); StorageDead(_13); StorageDead(_12); StorageDead(_11); 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 a9a58f7f0c400..cb6b04573e5a4 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 @@ -112,7 +112,7 @@ StorageDead(_15); StorageDead(_14); StorageDead(_16); - _3 = ShallowInitBox(move _13, ()); + _3 = ShallowInitBox(copy _13, ()); StorageDead(_13); StorageDead(_12); StorageDead(_11); diff --git a/tests/mir-opt/gvn.dereference_indexing.GVN.panic-abort.diff b/tests/mir-opt/gvn.dereference_indexing.GVN.panic-abort.diff index cdfbef8e9633d..851871e4e0880 100644 --- a/tests/mir-opt/gvn.dereference_indexing.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn.dereference_indexing.GVN.panic-abort.diff @@ -21,8 +21,7 @@ bb0: { StorageLive(_3); -- StorageLive(_4); -+ nop; + StorageLive(_4); StorageLive(_5); _5 = copy _2; - _4 = Add(move _5, const 1_usize); @@ -38,14 +37,11 @@ bb1: { - _3 = &_1[_6]; -- StorageDead(_4); + _3 = &_1[_4]; -+ nop; - StorageDead(_6); + StorageDead(_4); StorageLive(_8); StorageLive(_9); -- _9 = copy (*_3); -+ _9 = copy _1[_4]; + _9 = copy (*_3); _8 = opaque::(move _9) -> [return: bb2, unwind unreachable]; } @@ -53,6 +49,7 @@ StorageDead(_9); StorageDead(_8); _0 = const (); + StorageDead(_6); StorageDead(_3); return; } diff --git a/tests/mir-opt/gvn.dereference_indexing.GVN.panic-unwind.diff b/tests/mir-opt/gvn.dereference_indexing.GVN.panic-unwind.diff index 8c817f9d5cf75..0842e73119dc5 100644 --- a/tests/mir-opt/gvn.dereference_indexing.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn.dereference_indexing.GVN.panic-unwind.diff @@ -21,8 +21,7 @@ bb0: { StorageLive(_3); -- StorageLive(_4); -+ nop; + StorageLive(_4); StorageLive(_5); _5 = copy _2; - _4 = Add(move _5, const 1_usize); @@ -38,14 +37,11 @@ bb1: { - _3 = &_1[_6]; -- StorageDead(_4); + _3 = &_1[_4]; -+ nop; - StorageDead(_6); + StorageDead(_4); StorageLive(_8); StorageLive(_9); -- _9 = copy (*_3); -+ _9 = copy _1[_4]; + _9 = copy (*_3); _8 = opaque::(move _9) -> [return: bb2, unwind continue]; } @@ -53,6 +49,7 @@ StorageDead(_9); StorageDead(_8); _0 = const (); + StorageDead(_6); StorageDead(_3); return; } diff --git a/tests/mir-opt/gvn.fn_pointers.GVN.panic-abort.diff b/tests/mir-opt/gvn.fn_pointers.GVN.panic-abort.diff index f8180886e97be..9101f52a154c4 100644 --- a/tests/mir-opt/gvn.fn_pointers.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn.fn_pointers.GVN.panic-abort.diff @@ -8,10 +8,10 @@ let mut _3: fn(u8) -> u8; let _5: (); let mut _6: fn(u8) -> u8; - let mut _9: {closure@$DIR/gvn.rs:620:19: 620:21}; + let mut _9: {closure@$DIR/gvn.rs:617:19: 617:21}; let _10: (); let mut _11: fn(); - let mut _13: {closure@$DIR/gvn.rs:620:19: 620:21}; + let mut _13: {closure@$DIR/gvn.rs:617:19: 617:21}; let _14: (); let mut _15: fn(); scope 1 { @@ -19,7 +19,7 @@ let _4: fn(u8) -> u8; scope 2 { debug g => _4; - let _7: {closure@$DIR/gvn.rs:620:19: 620:21}; + let _7: {closure@$DIR/gvn.rs:617:19: 617:21}; scope 3 { debug closure => _7; let _8: fn(); @@ -60,14 +60,14 @@ StorageDead(_6); StorageDead(_5); StorageLive(_7); -- _7 = {closure@$DIR/gvn.rs:620:19: 620:21}; -+ _7 = const ZeroSized: {closure@$DIR/gvn.rs:620:19: 620:21}; +- _7 = {closure@$DIR/gvn.rs:617:19: 617:21}; ++ _7 = const ZeroSized: {closure@$DIR/gvn.rs:617:19: 617:21}; StorageLive(_8); StorageLive(_9); - _9 = copy _7; - _8 = move _9 as fn() (PointerCoercion(ClosureFnPointer(Safe), AsCast)); -+ _9 = const ZeroSized: {closure@$DIR/gvn.rs:620:19: 620:21}; -+ _8 = const ZeroSized: {closure@$DIR/gvn.rs:620:19: 620:21} as fn() (PointerCoercion(ClosureFnPointer(Safe), AsCast)); ++ _9 = const ZeroSized: {closure@$DIR/gvn.rs:617:19: 617:21}; ++ _8 = const ZeroSized: {closure@$DIR/gvn.rs:617:19: 617:21} as fn() (PointerCoercion(ClosureFnPointer(Safe), AsCast)); StorageDead(_9); StorageLive(_10); StorageLive(_11); @@ -83,8 +83,8 @@ StorageLive(_13); - _13 = copy _7; - _12 = move _13 as fn() (PointerCoercion(ClosureFnPointer(Safe), AsCast)); -+ _13 = const ZeroSized: {closure@$DIR/gvn.rs:620:19: 620:21}; -+ _12 = const ZeroSized: {closure@$DIR/gvn.rs:620:19: 620:21} as fn() (PointerCoercion(ClosureFnPointer(Safe), AsCast)); ++ _13 = const ZeroSized: {closure@$DIR/gvn.rs:617:19: 617:21}; ++ _12 = const ZeroSized: {closure@$DIR/gvn.rs:617:19: 617:21} as fn() (PointerCoercion(ClosureFnPointer(Safe), AsCast)); StorageDead(_13); StorageLive(_14); StorageLive(_15); diff --git a/tests/mir-opt/gvn.fn_pointers.GVN.panic-unwind.diff b/tests/mir-opt/gvn.fn_pointers.GVN.panic-unwind.diff index 44e6e914cd92c..eef33e312cb97 100644 --- a/tests/mir-opt/gvn.fn_pointers.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn.fn_pointers.GVN.panic-unwind.diff @@ -8,10 +8,10 @@ let mut _3: fn(u8) -> u8; let _5: (); let mut _6: fn(u8) -> u8; - let mut _9: {closure@$DIR/gvn.rs:620:19: 620:21}; + let mut _9: {closure@$DIR/gvn.rs:617:19: 617:21}; let _10: (); let mut _11: fn(); - let mut _13: {closure@$DIR/gvn.rs:620:19: 620:21}; + let mut _13: {closure@$DIR/gvn.rs:617:19: 617:21}; let _14: (); let mut _15: fn(); scope 1 { @@ -19,7 +19,7 @@ let _4: fn(u8) -> u8; scope 2 { debug g => _4; - let _7: {closure@$DIR/gvn.rs:620:19: 620:21}; + let _7: {closure@$DIR/gvn.rs:617:19: 617:21}; scope 3 { debug closure => _7; let _8: fn(); @@ -60,14 +60,14 @@ StorageDead(_6); StorageDead(_5); StorageLive(_7); -- _7 = {closure@$DIR/gvn.rs:620:19: 620:21}; -+ _7 = const ZeroSized: {closure@$DIR/gvn.rs:620:19: 620:21}; +- _7 = {closure@$DIR/gvn.rs:617:19: 617:21}; ++ _7 = const ZeroSized: {closure@$DIR/gvn.rs:617:19: 617:21}; StorageLive(_8); StorageLive(_9); - _9 = copy _7; - _8 = move _9 as fn() (PointerCoercion(ClosureFnPointer(Safe), AsCast)); -+ _9 = const ZeroSized: {closure@$DIR/gvn.rs:620:19: 620:21}; -+ _8 = const ZeroSized: {closure@$DIR/gvn.rs:620:19: 620:21} as fn() (PointerCoercion(ClosureFnPointer(Safe), AsCast)); ++ _9 = const ZeroSized: {closure@$DIR/gvn.rs:617:19: 617:21}; ++ _8 = const ZeroSized: {closure@$DIR/gvn.rs:617:19: 617:21} as fn() (PointerCoercion(ClosureFnPointer(Safe), AsCast)); StorageDead(_9); StorageLive(_10); StorageLive(_11); @@ -83,8 +83,8 @@ StorageLive(_13); - _13 = copy _7; - _12 = move _13 as fn() (PointerCoercion(ClosureFnPointer(Safe), AsCast)); -+ _13 = const ZeroSized: {closure@$DIR/gvn.rs:620:19: 620:21}; -+ _12 = const ZeroSized: {closure@$DIR/gvn.rs:620:19: 620:21} as fn() (PointerCoercion(ClosureFnPointer(Safe), AsCast)); ++ _13 = const ZeroSized: {closure@$DIR/gvn.rs:617:19: 617:21}; ++ _12 = const ZeroSized: {closure@$DIR/gvn.rs:617:19: 617:21} as fn() (PointerCoercion(ClosureFnPointer(Safe), AsCast)); StorageDead(_13); StorageLive(_14); StorageLive(_15); diff --git a/tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-abort.diff b/tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-abort.diff index a01b10364a01d..95f9b5997d4f6 100644 --- a/tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-abort.diff +++ b/tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-abort.diff @@ -7,18 +7,16 @@ let _2: &[T]; let _3: &[T; 3]; let _4: [T; 3]; - let mut _5: usize; - let mut _6: bool; - let mut _10: !; + let mut _8: !; scope 1 { debug v => _2; + let _5: &T; + let _6: &T; let _7: &T; - let _8: &T; - let _9: &T; scope 2 { - debug v1 => _7; - debug v2 => _8; - debug v3 => _9; + debug v1 => _5; + debug v2 => _6; + debug v3 => _7; } } @@ -29,27 +27,25 @@ _3 = &_4; _2 = copy _3 as &[T] (PointerCoercion(Unsize, Implicit)); StorageDead(_3); - nop; - nop; goto -> bb2; } bb1: { - _10 = core::panicking::panic(const "internal error: entered unreachable code") -> unwind unreachable; + _8 = core::panicking::panic(const "internal error: entered unreachable code") -> unwind unreachable; } bb2: { - StorageLive(_7); - _7 = &(*_2)[0 of 3]; - StorageLive(_8); - _8 = &(*_2)[1 of 3]; - StorageLive(_9); - _9 = &(*_2)[2 of 3]; - StorageDead(_9); - StorageDead(_8); - StorageDead(_7); + // DBG: _5 = &(*_2)[0 of 3]; + // DBG: _6 = &(*_2)[1 of 3]; + // DBG: _7 = &(*_2)[2 of 3]; StorageDead(_4); return; } } + ALLOC0 (size: 40, align: 1) { + 0x00 │ 69 6e 74 65 72 6e 61 6c 20 65 72 72 6f 72 3a 20 │ internal error: + 0x10 │ 65 6e 74 65 72 65 64 20 75 6e 72 65 61 63 68 61 │ entered unreacha + 0x20 │ 62 6c 65 20 63 6f 64 65 │ ble code + } + diff --git a/tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-unwind.diff b/tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-unwind.diff index dd5d700863646..87449b043fd5e 100644 --- a/tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-unwind.diff +++ b/tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-unwind.diff @@ -7,18 +7,16 @@ let _2: &[T]; let _3: &[T; 3]; let _4: [T; 3]; - let mut _5: usize; - let mut _6: bool; - let mut _10: !; + let mut _8: !; scope 1 { debug v => _2; + let _5: &T; + let _6: &T; let _7: &T; - let _8: &T; - let _9: &T; scope 2 { - debug v1 => _7; - debug v2 => _8; - debug v3 => _9; + debug v1 => _5; + debug v2 => _6; + debug v3 => _7; } } @@ -29,27 +27,25 @@ _3 = &_4; _2 = copy _3 as &[T] (PointerCoercion(Unsize, Implicit)); StorageDead(_3); - nop; - nop; goto -> bb2; } bb1: { - _10 = core::panicking::panic(const "internal error: entered unreachable code") -> unwind continue; + _8 = core::panicking::panic(const "internal error: entered unreachable code") -> unwind continue; } bb2: { - StorageLive(_7); - _7 = &(*_2)[0 of 3]; - StorageLive(_8); - _8 = &(*_2)[1 of 3]; - StorageLive(_9); - _9 = &(*_2)[2 of 3]; - StorageDead(_9); - StorageDead(_8); - StorageDead(_7); + // DBG: _5 = &(*_2)[0 of 3]; + // DBG: _6 = &(*_2)[1 of 3]; + // DBG: _7 = &(*_2)[2 of 3]; StorageDead(_4); return; } } + ALLOC0 (size: 40, align: 1) { + 0x00 │ 69 6e 74 65 72 6e 61 6c 20 65 72 72 6f 72 3a 20 │ internal error: + 0x10 │ 65 6e 74 65 72 65 64 20 75 6e 72 65 61 63 68 61 │ entered unreacha + 0x20 │ 62 6c 65 20 63 6f 64 65 │ ble code + } + diff --git a/tests/mir-opt/pre-codegen/derived_ord.demo_le.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/derived_ord.demo_le.PreCodegen.after.mir index 63bdf8b3aa0ef..c578cc5a4228d 100644 --- a/tests/mir-opt/pre-codegen/derived_ord.demo_le.PreCodegen.after.mir +++ b/tests/mir-opt/pre-codegen/derived_ord.demo_le.PreCodegen.after.mir @@ -5,8 +5,9 @@ fn demo_le(_1: &MultiField, _2: &MultiField) -> bool { debug b => _2; let mut _0: bool; scope 1 (inlined ::le) { - let mut _11: std::option::Option; + let mut _6: std::option::Option; scope 2 (inlined Option::::is_some_and:: bool {std::cmp::Ordering::is_le}>) { + let mut _11: isize; let _12: std::cmp::Ordering; scope 3 { scope 4 (inlined bool {std::cmp::Ordering::is_le} as FnOnce<(std::cmp::Ordering,)>>::call_once - shim(fn(std::cmp::Ordering) -> bool {std::cmp::Ordering::is_le})) { @@ -19,7 +20,6 @@ fn demo_le(_1: &MultiField, _2: &MultiField) -> bool { } } scope 7 (inlined ::partial_cmp) { - let mut _6: std::option::Option; let mut _7: i8; scope 8 { } @@ -37,10 +37,9 @@ fn demo_le(_1: &MultiField, _2: &MultiField) -> bool { } bb0: { - StorageLive(_11); + StorageLive(_6); StorageLive(_5); StorageLive(_7); - StorageLive(_6); StorageLive(_3); _3 = copy ((*_1).0: char); StorageLive(_4); @@ -62,31 +61,45 @@ fn demo_le(_1: &MultiField, _2: &MultiField) -> bool { _10 = Cmp(move _8, move _9); StorageDead(_9); StorageDead(_8); - _11 = Option::::Some(move _10); + _6 = Option::::Some(move _10); StorageDead(_10); - StorageDead(_6); StorageDead(_7); StorageDead(_5); - goto -> bb3; + StorageLive(_11); + goto -> bb4; } bb2: { - _11 = copy _6; - StorageDead(_6); StorageDead(_7); StorageDead(_5); - goto -> bb3; + StorageLive(_11); + _11 = discriminant(_6); + switchInt(move _11) -> [0: bb3, 1: bb4, otherwise: bb6]; } bb3: { + _0 = const false; + goto -> bb5; + } + + bb4: { StorageLive(_12); - _12 = move ((_11 as Some).0: std::cmp::Ordering); + _12 = move ((_6 as Some).0: std::cmp::Ordering); StorageLive(_13); _13 = discriminant(_12); _0 = Le(move _13, const 0_i8); StorageDead(_13); StorageDead(_12); + goto -> bb5; + } + + bb5: { StorageDead(_11); + StorageDead(_6); return; } + + bb6: { + unreachable; + } } diff --git a/tests/mir-opt/pre-codegen/derived_ord.{impl#0}-partial_cmp.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/derived_ord.{impl#0}-partial_cmp.PreCodegen.after.mir index 3dce01f1c2172..5993bd79d274c 100644 --- a/tests/mir-opt/pre-codegen/derived_ord.{impl#0}-partial_cmp.PreCodegen.after.mir +++ b/tests/mir-opt/pre-codegen/derived_ord.{impl#0}-partial_cmp.PreCodegen.after.mir @@ -20,7 +20,6 @@ fn ::partial_cmp(_1: &MultiField, _2: &M } bb0: { - StorageLive(_6); StorageLive(_3); _3 = copy ((*_1).0: char); StorageLive(_4); @@ -52,7 +51,6 @@ fn ::partial_cmp(_1: &MultiField, _2: &M } bb3: { - StorageDead(_6); return; } } diff --git a/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.32bit.panic-abort.mir b/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.32bit.panic-abort.mir index 791d6b71a6f78..373c07b2faa32 100644 --- a/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.32bit.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.32bit.panic-abort.mir @@ -63,8 +63,11 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () { } bb0: { + StorageLive(_3); + StorageLive(_5); StorageLive(_2); _2 = copy (((*_1).0: std::ptr::Unique<[T]>).0: std::ptr::NonNull<[T]>); + StorageLive(_8); StorageLive(_4); _3 = copy _2 as *mut [T] (Transmute); _4 = copy _2 as *const [T] (Transmute); @@ -98,7 +101,10 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () { } bb4: { + StorageDead(_8); StorageDead(_2); + StorageDead(_5); + StorageDead(_3); return; } } diff --git a/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.32bit.panic-unwind.mir b/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.32bit.panic-unwind.mir index 791d6b71a6f78..373c07b2faa32 100644 --- a/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.32bit.panic-unwind.mir +++ b/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.32bit.panic-unwind.mir @@ -63,8 +63,11 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () { } bb0: { + StorageLive(_3); + StorageLive(_5); StorageLive(_2); _2 = copy (((*_1).0: std::ptr::Unique<[T]>).0: std::ptr::NonNull<[T]>); + StorageLive(_8); StorageLive(_4); _3 = copy _2 as *mut [T] (Transmute); _4 = copy _2 as *const [T] (Transmute); @@ -98,7 +101,10 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () { } bb4: { + StorageDead(_8); StorageDead(_2); + StorageDead(_5); + StorageDead(_3); return; } } diff --git a/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.64bit.panic-abort.mir b/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.64bit.panic-abort.mir index 791d6b71a6f78..373c07b2faa32 100644 --- a/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.64bit.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.64bit.panic-abort.mir @@ -63,8 +63,11 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () { } bb0: { + StorageLive(_3); + StorageLive(_5); StorageLive(_2); _2 = copy (((*_1).0: std::ptr::Unique<[T]>).0: std::ptr::NonNull<[T]>); + StorageLive(_8); StorageLive(_4); _3 = copy _2 as *mut [T] (Transmute); _4 = copy _2 as *const [T] (Transmute); @@ -98,7 +101,10 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () { } bb4: { + StorageDead(_8); StorageDead(_2); + StorageDead(_5); + StorageDead(_3); return; } } diff --git a/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.64bit.panic-unwind.mir b/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.64bit.panic-unwind.mir index 791d6b71a6f78..373c07b2faa32 100644 --- a/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.64bit.panic-unwind.mir +++ b/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.64bit.panic-unwind.mir @@ -63,8 +63,11 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () { } bb0: { + StorageLive(_3); + StorageLive(_5); StorageLive(_2); _2 = copy (((*_1).0: std::ptr::Unique<[T]>).0: std::ptr::NonNull<[T]>); + StorageLive(_8); StorageLive(_4); _3 = copy _2 as *mut [T] (Transmute); _4 = copy _2 as *const [T] (Transmute); @@ -98,7 +101,10 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () { } bb4: { + StorageDead(_8); StorageDead(_2); + StorageDead(_5); + StorageDead(_3); return; } } diff --git a/tests/mir-opt/pre-codegen/range_iter.forward_loop.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/range_iter.forward_loop.PreCodegen.after.panic-abort.mir index 3d44fd6807f19..d107a37da0fe0 100644 --- a/tests/mir-opt/pre-codegen/range_iter.forward_loop.PreCodegen.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/range_iter.forward_loop.PreCodegen.after.panic-abort.mir @@ -5,23 +5,21 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { debug end => _2; debug f => _3; let mut _0: (); - let mut _4: u32; - let mut _9: std::option::Option; - let mut _11: &impl Fn(u32); - let mut _12: (u32,); - let _13: (); + let mut _7: std::option::Option; + let mut _9: &impl Fn(u32); + let mut _10: (u32,); + let _11: (); scope 1 { - debug ((iter: std::ops::Range).0: u32) => _4; + debug ((iter: std::ops::Range).0: u32) => _1; debug ((iter: std::ops::Range).1: u32) => _2; - let _10: u32; + let _8: u32; scope 2 { - debug x => _10; + debug x => _8; } scope 4 (inlined iter::range::>::next) { scope 5 (inlined as iter::range::RangeIteratorImpl>::spec_next) { - let mut _6: bool; - let _7: u32; - let mut _8: u32; + let mut _5: bool; + let _6: u32; scope 6 { scope 8 (inlined ::forward_unchecked) { scope 9 (inlined #[track_caller] core::num::::unchecked_add) { @@ -33,7 +31,7 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { } } scope 7 (inlined std::cmp::impls::::lt) { - let mut _5: u32; + let mut _4: u32; } } } @@ -42,25 +40,22 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { } bb0: { - StorageLive(_4); - _4 = copy _1; goto -> bb1; } bb1: { - StorageLive(_9); - StorageLive(_6); + StorageLive(_7); StorageLive(_5); - _5 = copy _4; - _6 = Lt(move _5, copy _2); - StorageDead(_5); - switchInt(move _6) -> [0: bb2, otherwise: bb4]; + StorageLive(_4); + _4 = copy _1; + _5 = Lt(move _4, copy _2); + StorageDead(_4); + switchInt(move _5) -> [0: bb2, otherwise: bb4]; } bb2: { - StorageDead(_6); - StorageDead(_9); - StorageDead(_4); + StorageDead(_5); + StorageDead(_7); drop(_3) -> [return: bb3, unwind unreachable]; } @@ -69,29 +64,26 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { } bb4: { - StorageLive(_7); - _7 = copy _4; - StorageLive(_8); - _8 = AddUnchecked(copy _7, const 1_u32); - _4 = move _8; - StorageDead(_8); - _9 = Option::::Some(copy _7); - StorageDead(_7); + StorageLive(_6); + _6 = copy _1; + _1 = AddUnchecked(copy _6, const 1_u32); + _7 = Option::::Some(copy _6); StorageDead(_6); + StorageDead(_5); + StorageLive(_8); + _8 = copy ((_7 as Some).0: u32); + StorageLive(_9); + _9 = &_3; StorageLive(_10); - _10 = copy ((_9 as Some).0: u32); - StorageLive(_11); - _11 = &_3; - StorageLive(_12); - _12 = (copy _10,); - _13 = >::call(move _11, move _12) -> [return: bb5, unwind unreachable]; + _10 = (copy _8,); + _11 = >::call(move _9, move _10) -> [return: bb5, unwind unreachable]; } bb5: { - StorageDead(_12); - StorageDead(_11); StorageDead(_10); StorageDead(_9); + StorageDead(_8); + StorageDead(_7); goto -> bb1; } } diff --git a/tests/mir-opt/pre-codegen/range_iter.forward_loop.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/range_iter.forward_loop.PreCodegen.after.panic-unwind.mir index b955501316549..207dde62f7d61 100644 --- a/tests/mir-opt/pre-codegen/range_iter.forward_loop.PreCodegen.after.panic-unwind.mir +++ b/tests/mir-opt/pre-codegen/range_iter.forward_loop.PreCodegen.after.panic-unwind.mir @@ -5,23 +5,21 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { debug end => _2; debug f => _3; let mut _0: (); - let mut _4: u32; - let mut _9: std::option::Option; - let mut _11: &impl Fn(u32); - let mut _12: (u32,); - let _13: (); + let mut _7: std::option::Option; + let mut _9: &impl Fn(u32); + let mut _10: (u32,); + let _11: (); scope 1 { - debug ((iter: std::ops::Range).0: u32) => _4; + debug ((iter: std::ops::Range).0: u32) => _1; debug ((iter: std::ops::Range).1: u32) => _2; - let _10: u32; + let _8: u32; scope 2 { - debug x => _10; + debug x => _8; } scope 4 (inlined iter::range::>::next) { scope 5 (inlined as iter::range::RangeIteratorImpl>::spec_next) { - let mut _6: bool; - let _7: u32; - let mut _8: u32; + let mut _5: bool; + let _6: u32; scope 6 { scope 8 (inlined ::forward_unchecked) { scope 9 (inlined #[track_caller] core::num::::unchecked_add) { @@ -33,7 +31,7 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { } } scope 7 (inlined std::cmp::impls::::lt) { - let mut _5: u32; + let mut _4: u32; } } } @@ -42,25 +40,22 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { } bb0: { - StorageLive(_4); - _4 = copy _1; goto -> bb1; } bb1: { - StorageLive(_9); - StorageLive(_6); + StorageLive(_7); StorageLive(_5); - _5 = copy _4; - _6 = Lt(move _5, copy _2); - StorageDead(_5); - switchInt(move _6) -> [0: bb2, otherwise: bb4]; + StorageLive(_4); + _4 = copy _1; + _5 = Lt(move _4, copy _2); + StorageDead(_4); + switchInt(move _5) -> [0: bb2, otherwise: bb4]; } bb2: { - StorageDead(_6); - StorageDead(_9); - StorageDead(_4); + StorageDead(_5); + StorageDead(_7); drop(_3) -> [return: bb3, unwind continue]; } @@ -69,29 +64,26 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { } bb4: { - StorageLive(_7); - _7 = copy _4; - StorageLive(_8); - _8 = AddUnchecked(copy _7, const 1_u32); - _4 = move _8; - StorageDead(_8); - _9 = Option::::Some(copy _7); - StorageDead(_7); + StorageLive(_6); + _6 = copy _1; + _1 = AddUnchecked(copy _6, const 1_u32); + _7 = Option::::Some(copy _6); StorageDead(_6); + StorageDead(_5); + StorageLive(_8); + _8 = copy ((_7 as Some).0: u32); + StorageLive(_9); + _9 = &_3; StorageLive(_10); - _10 = copy ((_9 as Some).0: u32); - StorageLive(_11); - _11 = &_3; - StorageLive(_12); - _12 = (copy _10,); - _13 = >::call(move _11, move _12) -> [return: bb5, unwind: bb6]; + _10 = (copy _8,); + _11 = >::call(move _9, move _10) -> [return: bb5, unwind: bb6]; } bb5: { - StorageDead(_12); - StorageDead(_11); StorageDead(_10); StorageDead(_9); + StorageDead(_8); + StorageDead(_7); goto -> bb1; } diff --git a/tests/mir-opt/pre-codegen/slice_filter.variant_a-{closure#0}.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/slice_filter.variant_a-{closure#0}.PreCodegen.after.mir index bb93139c31be5..2cab88182962f 100644 --- a/tests/mir-opt/pre-codegen/slice_filter.variant_a-{closure#0}.PreCodegen.after.mir +++ b/tests/mir-opt/pre-codegen/slice_filter.variant_a-{closure#0}.PreCodegen.after.mir @@ -3,191 +3,134 @@ fn variant_a::{closure#0}(_1: &mut {closure@$DIR/slice_filter.rs:7:25: 7:39}, _2: &&(usize, usize, usize, usize)) -> bool { let mut _0: bool; let mut _3: &(usize, usize, usize, usize); - let _4: &usize; - let _5: &usize; - let _6: &usize; - let _7: &usize; - let mut _8: &&usize; - let _9: &usize; - let mut _10: &&usize; - let mut _13: bool; - let mut _14: &&usize; + let mut _6: bool; + let mut _9: bool; + let mut _10: bool; + let _13: &usize; + let _14: &usize; let _15: &usize; - let mut _16: &&usize; - let mut _19: bool; + let _16: &usize; + let mut _17: &&usize; + let mut _18: &&usize; + let mut _19: &&usize; let mut _20: &&usize; - let _21: &usize; + let mut _21: &&usize; let mut _22: &&usize; - let mut _23: bool; + let mut _23: &&usize; let mut _24: &&usize; - let _25: &usize; - let mut _26: &&usize; scope 1 { - debug a => _4; - debug b => _5; - debug c => _6; - debug d => _7; + debug a => _13; + debug b => _14; + debug c => _15; + debug d => _16; scope 2 (inlined std::cmp::impls::::le) { - debug self => _8; - debug other => _10; + debug self => _17; + debug other => _18; scope 3 (inlined std::cmp::impls::::le) { - debug self => _4; - debug other => _6; - let mut _11: usize; - let mut _12: usize; + debug self => _13; + debug other => _15; + let mut _4: usize; + let mut _5: usize; } } scope 4 (inlined std::cmp::impls::::le) { - debug self => _14; - debug other => _16; + debug self => _19; + debug other => _20; scope 5 (inlined std::cmp::impls::::le) { - debug self => _7; - debug other => _5; - let mut _17: usize; - let mut _18: usize; + debug self => _16; + debug other => _14; + let mut _7: usize; + let mut _8: usize; } } scope 6 (inlined std::cmp::impls::::le) { - debug self => _20; + debug self => _21; debug other => _22; scope 7 (inlined std::cmp::impls::::le) { - debug self => _6; - debug other => _4; + debug self => _15; + debug other => _13; } } scope 8 (inlined std::cmp::impls::::le) { - debug self => _24; - debug other => _26; + debug self => _23; + debug other => _24; scope 9 (inlined std::cmp::impls::::le) { - debug self => _5; - debug other => _7; - let mut _27: usize; - let mut _28: usize; + debug self => _14; + debug other => _16; + let mut _11: usize; + let mut _12: usize; } } } bb0: { - StorageLive(_4); _3 = copy (*_2); - _4 = &((*_3).0: usize); - StorageLive(_5); - _5 = &((*_3).1: usize); + // DBG: _13 = &((*_3).0: usize); + // DBG: _14 = &((*_3).1: usize); + // DBG: _15 = &((*_3).2: usize); + // DBG: _16 = &((*_3).3: usize); StorageLive(_6); - _6 = &((*_3).2: usize); - StorageLive(_7); - _7 = &((*_3).3: usize); - StorageLive(_13); - StorageLive(_8); - _8 = &_4; - StorageLive(_10); - StorageLive(_9); - _9 = copy _6; - _10 = &_9; - _11 = copy ((*_3).0: usize); - _12 = copy ((*_3).2: usize); - _13 = Le(copy _11, copy _12); - switchInt(move _13) -> [0: bb1, otherwise: bb2]; + // DBG: _17 = &_13; + // DBG: _18 = &?; + _4 = copy ((*_3).0: usize); + _5 = copy ((*_3).2: usize); + _6 = Le(copy _4, copy _5); + switchInt(move _6) -> [0: bb2, otherwise: bb1]; } bb1: { - StorageDead(_9); - StorageDead(_10); + StorageLive(_9); + // DBG: _19 = &_16; + // DBG: _20 = &?; + StorageLive(_7); + _7 = copy ((*_3).3: usize); + StorageLive(_8); + _8 = copy ((*_3).1: usize); + _9 = Le(move _7, move _8); StorageDead(_8); - goto -> bb4; + StorageDead(_7); + switchInt(move _9) -> [0: bb2, otherwise: bb6]; } bb2: { - StorageDead(_9); - StorageDead(_10); - StorageDead(_8); - StorageLive(_19); - StorageLive(_14); - _14 = &_7; - StorageLive(_16); - StorageLive(_15); - _15 = copy _5; - _16 = &_15; - StorageLive(_17); - _17 = copy ((*_3).3: usize); - StorageLive(_18); - _18 = copy ((*_3).1: usize); - _19 = Le(move _17, move _18); - StorageDead(_18); - StorageDead(_17); - switchInt(move _19) -> [0: bb3, otherwise: bb8]; + StorageLive(_10); + // DBG: _21 = &_15; + // DBG: _22 = &?; + _10 = Le(copy _5, copy _4); + switchInt(move _10) -> [0: bb3, otherwise: bb4]; } bb3: { - StorageDead(_15); - StorageDead(_16); - StorageDead(_14); - goto -> bb4; + _0 = const false; + goto -> bb5; } bb4: { - StorageLive(_23); - StorageLive(_20); - _20 = &_6; - StorageLive(_22); - StorageLive(_21); - _21 = copy _4; - _22 = &_21; - _23 = Le(copy _12, copy _11); - switchInt(move _23) -> [0: bb5, otherwise: bb6]; + // DBG: _23 = &_14; + // DBG: _24 = &?; + StorageLive(_11); + _11 = copy ((*_3).1: usize); + StorageLive(_12); + _12 = copy ((*_3).3: usize); + _0 = Le(move _11, move _12); + StorageDead(_12); + StorageDead(_11); + goto -> bb5; } bb5: { - StorageDead(_21); - StorageDead(_22); - StorageDead(_20); - _0 = const false; + StorageDead(_10); goto -> bb7; } bb6: { - StorageDead(_21); - StorageDead(_22); - StorageDead(_20); - StorageLive(_24); - _24 = &_5; - StorageLive(_26); - StorageLive(_25); - _25 = copy _7; - _26 = &_25; - StorageLive(_27); - _27 = copy ((*_3).1: usize); - StorageLive(_28); - _28 = copy ((*_3).3: usize); - _0 = Le(move _27, move _28); - StorageDead(_28); - StorageDead(_27); - StorageDead(_25); - StorageDead(_26); - StorageDead(_24); + _0 = const true; goto -> bb7; } bb7: { - StorageDead(_23); - goto -> bb9; - } - - bb8: { - StorageDead(_15); - StorageDead(_16); - StorageDead(_14); - _0 = const true; - goto -> bb9; - } - - bb9: { - StorageDead(_19); - StorageDead(_13); - StorageDead(_7); + StorageDead(_9); StorageDead(_6); - StorageDead(_5); - StorageDead(_4); return; } } diff --git a/tests/mir-opt/pre-codegen/slice_index.slice_index_range.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/slice_index.slice_index_range.PreCodegen.after.panic-abort.mir index 2df2c4b85b8fa..3d50d9dfcc9d6 100644 --- a/tests/mir-opt/pre-codegen/slice_index.slice_index_range.PreCodegen.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/slice_index.slice_index_range.PreCodegen.after.panic-abort.mir @@ -30,6 +30,8 @@ fn slice_index_range(_1: &[u32], _2: std::ops::Range) -> &[u32] { } bb0: { + StorageLive(_3); + StorageLive(_4); _3 = move (_2.0: usize); _4 = move (_2.1: usize); StorageLive(_5); @@ -58,8 +60,8 @@ fn slice_index_range(_1: &[u32], _2: std::ops::Range) -> &[u32] { StorageLive(_9); _9 = &raw const (*_1); StorageLive(_10); - StorageLive(_11); _10 = copy _9 as *const u32 (PtrToPtr); + StorageLive(_11); _11 = Offset(copy _10, copy _3); _12 = *const [u32] from (copy _11, copy _6); StorageDead(_11); @@ -68,6 +70,8 @@ fn slice_index_range(_1: &[u32], _2: std::ops::Range) -> &[u32] { _0 = &(*_12); StorageDead(_12); StorageDead(_8); + StorageDead(_3); + StorageDead(_4); return; } diff --git a/tests/mir-opt/pre-codegen/slice_index.slice_index_range.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/slice_index.slice_index_range.PreCodegen.after.panic-unwind.mir index d4b86b9633acd..08441c43d9b2a 100644 --- a/tests/mir-opt/pre-codegen/slice_index.slice_index_range.PreCodegen.after.panic-unwind.mir +++ b/tests/mir-opt/pre-codegen/slice_index.slice_index_range.PreCodegen.after.panic-unwind.mir @@ -30,6 +30,8 @@ fn slice_index_range(_1: &[u32], _2: std::ops::Range) -> &[u32] { } bb0: { + StorageLive(_3); + StorageLive(_4); _3 = move (_2.0: usize); _4 = move (_2.1: usize); StorageLive(_5); @@ -58,8 +60,8 @@ fn slice_index_range(_1: &[u32], _2: std::ops::Range) -> &[u32] { StorageLive(_9); _9 = &raw const (*_1); StorageLive(_10); - StorageLive(_11); _10 = copy _9 as *const u32 (PtrToPtr); + StorageLive(_11); _11 = Offset(copy _10, copy _3); _12 = *const [u32] from (copy _11, copy _6); StorageDead(_11); @@ -68,6 +70,8 @@ fn slice_index_range(_1: &[u32], _2: std::ops::Range) -> &[u32] { _0 = &(*_12); StorageDead(_12); StorageDead(_8); + StorageDead(_3); + StorageDead(_4); return; } From b1f5e071834d04208c850bedfb5f55444cd9a13c Mon Sep 17 00:00:00 2001 From: Ohad Ravid Date: Tue, 11 Nov 2025 09:54:35 +0200 Subject: [PATCH 24/25] Update MaybeUninitLocals to current Analysis API --- compiler/rustc_mir_transform/src/ssa.rs | 11 ++--------- 1 file changed, 2 insertions(+), 9 deletions(-) diff --git a/compiler/rustc_mir_transform/src/ssa.rs b/compiler/rustc_mir_transform/src/ssa.rs index b0a05935bce58..b1c53778db6ae 100644 --- a/compiler/rustc_mir_transform/src/ssa.rs +++ b/compiler/rustc_mir_transform/src/ssa.rs @@ -419,7 +419,7 @@ impl<'tcx> Analysis<'tcx> for MaybeUninitializedLocals { } fn apply_primary_statement_effect( - &mut self, + &self, state: &mut Self::Domain, statement: &Statement<'tcx>, _location: Location, @@ -431,13 +431,6 @@ impl<'tcx> Analysis<'tcx> for MaybeUninitializedLocals { state.remove(local); } } - // Deinit makes the local uninitialized. - StatementKind::Deinit(box place) => { - // A deinit makes a local uninitialized. - if let Some(local) = place.as_local() { - state.insert(local); - } - } // Storage{Live,Dead} makes a local uninitialized. StatementKind::StorageLive(local) | StatementKind::StorageDead(local) => { state.insert(local); @@ -447,7 +440,7 @@ impl<'tcx> Analysis<'tcx> for MaybeUninitializedLocals { } fn apply_call_return_effect( - &mut self, + &self, state: &mut Self::Domain, _block: BasicBlock, return_places: CallReturnPlaces<'_, 'tcx>, From fdb31c3a765fc10a76f676156044116df234c14f Mon Sep 17 00:00:00 2001 From: Ohad Ravid Date: Tue, 11 Nov 2025 09:55:22 +0200 Subject: [PATCH 25/25] Bless and update checks for mir-opt tests after rebasing from main --- tests/mir-opt/const_prop/union.main.GVN.diff | 6 +- tests/mir-opt/copy-prop/cycle.rs | 3 +- ...es_better.f.CopyProp.after.panic-abort.mir | 28 --- ...s_better.f.CopyProp.after.panic-unwind.mir | 28 --- tests/mir-opt/copy-prop/issue_107511.rs | 4 +- ...ng_operand.test.GVN.32bit.panic-abort.diff | 188 ++++++++++-------- ...g_operand.test.GVN.32bit.panic-unwind.diff | 79 +++++--- ...ng_operand.test.GVN.64bit.panic-abort.diff | 188 ++++++++++-------- ...g_operand.test.GVN.64bit.panic-unwind.diff | 79 +++++--- ....dereference_indexing.GVN.panic-abort.diff | 11 +- ...dereference_indexing.GVN.panic-unwind.diff | 11 +- .../gvn_copy_aggregate.all_copy_2.GVN.diff | 7 +- .../mir-opt/gvn_loop.loop_deref_mut.GVN.diff | 6 +- ...ef_nested_borrows.src.GVN.panic-abort.diff | 6 +- ...f_nested_borrows.src.GVN.panic-unwind.diff | 6 +- ...ap_unchecked.two_unwrap_unchecked.GVN.diff | 6 +- ....two_unwrap_unchecked.PreCodegen.after.mir | 2 + 17 files changed, 345 insertions(+), 313 deletions(-) delete mode 100644 tests/mir-opt/copy-prop/dead_stores_better.f.CopyProp.after.panic-abort.mir delete mode 100644 tests/mir-opt/copy-prop/dead_stores_better.f.CopyProp.after.panic-unwind.mir diff --git a/tests/mir-opt/const_prop/union.main.GVN.diff b/tests/mir-opt/const_prop/union.main.GVN.diff index 4212a44d0a0de..4c3e0bb68fd43 100644 --- a/tests/mir-opt/const_prop/union.main.GVN.diff +++ b/tests/mir-opt/const_prop/union.main.GVN.diff @@ -17,13 +17,11 @@ bb0: { StorageLive(_1); -- StorageLive(_2); -+ nop; + StorageLive(_2); _2 = const 1_u32; - _1 = Un { us: move _2 }; -- StorageDead(_2); + _1 = const Un {{ us: 1_u32 }}; -+ nop; + StorageDead(_2); StorageLive(_3); StorageLive(_4); - _4 = copy (_1.0: u32); diff --git a/tests/mir-opt/copy-prop/cycle.rs b/tests/mir-opt/copy-prop/cycle.rs index 9f8312cc8fcd4..9bd175f9c42d0 100644 --- a/tests/mir-opt/copy-prop/cycle.rs +++ b/tests/mir-opt/copy-prop/cycle.rs @@ -11,7 +11,7 @@ fn main() { // CHECK: debug x => [[x:_.*]]; // CHECK: debug y => [[y:_.*]]; // CHECK: debug z => [[y]]; - // CHECK-NOT: StorageLive([[y]]); + // CHECK: StorageLive([[y]]); // CHECK: [[y]] = copy [[x]]; // CHECK-NOT: StorageLive(_3); // CHECK-NOT: _3 = copy [[y]]; @@ -19,6 +19,7 @@ fn main() { // CHECK-NOT: _4 = copy _3; // CHECK-NOT: _1 = move _4; // CHECK: [[x]] = copy [[y]]; + // CHECK: StorageDead([[y]]); let mut x = val(); let y = x; let z = y; diff --git a/tests/mir-opt/copy-prop/dead_stores_better.f.CopyProp.after.panic-abort.mir b/tests/mir-opt/copy-prop/dead_stores_better.f.CopyProp.after.panic-abort.mir deleted file mode 100644 index 90bd2b8e07a8f..0000000000000 --- a/tests/mir-opt/copy-prop/dead_stores_better.f.CopyProp.after.panic-abort.mir +++ /dev/null @@ -1,28 +0,0 @@ -// MIR for `f` after CopyProp - -fn f(_1: usize) -> usize { - debug a => _1; - let mut _0: usize; - let _2: usize; - let mut _3: usize; - let mut _4: usize; - scope 1 { - debug b => _2; - } - - bb0: { - StorageLive(_2); - _2 = copy _1; - _1 = const 5_usize; - _1 = copy _2; - StorageLive(_4); - _4 = copy _1; - _0 = id::(move _4) -> [return: bb1, unwind unreachable]; - } - - bb1: { - StorageDead(_4); - StorageDead(_2); - return; - } -} diff --git a/tests/mir-opt/copy-prop/dead_stores_better.f.CopyProp.after.panic-unwind.mir b/tests/mir-opt/copy-prop/dead_stores_better.f.CopyProp.after.panic-unwind.mir deleted file mode 100644 index 72b51f0b60a7b..0000000000000 --- a/tests/mir-opt/copy-prop/dead_stores_better.f.CopyProp.after.panic-unwind.mir +++ /dev/null @@ -1,28 +0,0 @@ -// MIR for `f` after CopyProp - -fn f(_1: usize) -> usize { - debug a => _1; - let mut _0: usize; - let _2: usize; - let mut _3: usize; - let mut _4: usize; - scope 1 { - debug b => _2; - } - - bb0: { - StorageLive(_2); - _2 = copy _1; - _1 = const 5_usize; - _1 = copy _2; - StorageLive(_4); - _4 = copy _1; - _0 = id::(move _4) -> [return: bb1, unwind continue]; - } - - bb1: { - StorageDead(_4); - StorageDead(_2); - return; - } -} diff --git a/tests/mir-opt/copy-prop/issue_107511.rs b/tests/mir-opt/copy-prop/issue_107511.rs index d345d2db2b7d8..b3dcc775b63d6 100644 --- a/tests/mir-opt/copy-prop/issue_107511.rs +++ b/tests/mir-opt/copy-prop/issue_107511.rs @@ -5,8 +5,8 @@ fn main() { // CHECK-LABEL: fn main( // CHECK: debug i => [[i:_.*]]; - // CHECK-NOT: StorageLive([[i]]); - // CHECK-NOT: StorageDead([[i]]); + // CHECK: StorageLive([[i]]); + // CHECK: StorageDead([[i]]); let mut sum = 0; let a = [0, 10, 20, 30]; 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 6b2da8c987d63..9dbdb3483d05f 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 @@ -6,24 +6,28 @@ let _1: &std::boxed::Box<()>; let _2: &std::boxed::Box<()>; let _3: std::boxed::Box<()>; - let mut _6: *const (); - let mut _8: *const [()]; - let mut _9: std::boxed::Box<()>; - let mut _10: *const (); - let mut _23: usize; + let mut _4: (); + let mut _7: *const (); + let mut _9: *const [()]; + let mut _10: std::boxed::Box<()>; + let mut _11: *const (); + let mut _16: usize; + let mut _17: usize; + let mut _27: usize; scope 1 { debug vp_ctx => _1; - let _4: *const (); + let _5: *const (); scope 2 { - debug slf => _10; - let _5: *const [()]; + debug slf => _5; + let _6: *const [()]; scope 3 { - debug bytes => _5; - let _7: *mut (); + debug bytes => _6; + let _8: *mut (); scope 4 { - debug _x => _7; + debug _x => _8; } scope 18 (inlined foo) { + let mut _28: *const [()]; } } scope 16 (inlined slice_from_raw_parts::<()>) { @@ -33,21 +37,22 @@ } } scope 5 (inlined Box::<()>::new) { - let mut _11: usize; - let mut _12: usize; - let mut _13: *mut u8; + let mut _12: *mut u8; + let mut _13: *const (); + let mut _14: std::ptr::NonNull<()>; + let mut _15: std::ptr::Unique<()>; scope 6 (inlined alloc::alloc::exchange_malloc) { - let _14: std::alloc::Layout; - let mut _15: std::result::Result, std::alloc::AllocError>; - let mut _16: isize; - let mut _18: !; + let _18: std::alloc::Layout; + let mut _19: std::result::Result, std::alloc::AllocError>; + let mut _20: isize; + let mut _22: !; scope 7 { - let _17: std::ptr::NonNull<[u8]>; + let _21: std::ptr::NonNull<[u8]>; scope 8 { scope 11 (inlined NonNull::<[u8]>::as_mut_ptr) { scope 12 (inlined NonNull::<[u8]>::as_non_null_ptr) { scope 13 (inlined NonNull::<[u8]>::cast::) { - let mut _22: *mut [u8]; + let mut _26: *mut [u8]; scope 14 (inlined NonNull::<[u8]>::as_ptr) { } } @@ -60,30 +65,38 @@ } } scope 9 (inlined #[track_caller] Layout::from_size_align_unchecked) { - let mut _19: bool; - let _20: (); - let mut _21: std::ptr::Alignment; + let mut _23: bool; + let _24: (); + let mut _25: std::ptr::Alignment; } } } bb0: { StorageLive(_1); - StorageLive(_2); +- StorageLive(_2); ++ nop; StorageLive(_3); - StorageLive(_11); + StorageLive(_4); +- _4 = (); ++ _4 = const (); StorageLive(_12); StorageLive(_13); -- _11 = SizeOf(()); -- _12 = AlignOf(()); -+ _11 = const 0_usize; -+ _12 = const 1_usize; - StorageLive(_16); StorageLive(_14); - StorageLive(_19); - _19 = const false; -- switchInt(move _19) -> [0: bb6, otherwise: bb5]; -+ switchInt(const false) -> [0: bb6, otherwise: bb5]; + StorageLive(_15); + StorageLive(_16); +- _16 = const <() as std::mem::SizedTypeProperties>::SIZE; ++ _16 = const 0_usize; + StorageLive(_17); +- _17 = const <() as std::mem::SizedTypeProperties>::ALIGN; ++ _17 = const 1_usize; + StorageLive(_20); + StorageLive(_22); + StorageLive(_24); + StorageLive(_18); + StorageLive(_23); + _23 = UbChecks(); + switchInt(move _23) -> [0: bb6, otherwise: bb5]; } bb1: { @@ -97,76 +110,95 @@ } bb3: { -- _18 = handle_alloc_error(move _14) -> unwind unreachable; -+ _18 = handle_alloc_error(const Layout {{ size: 0_usize, align: std::ptr::Alignment(std::ptr::alignment::AlignmentEnum::_Align1Shl0) }}) -> unwind unreachable; +- _22 = handle_alloc_error(move _18) -> unwind unreachable; ++ _22 = handle_alloc_error(const Layout {{ size: 0_usize, align: std::ptr::Alignment(std::ptr::alignment::AlignmentEnum::_Align1Shl0) }}) -> unwind unreachable; } bb4: { - StorageLive(_17); - _17 = copy ((_15 as Ok).0: std::ptr::NonNull<[u8]>); - StorageLive(_22); - _22 = copy _17 as *mut [u8] (Transmute); - _13 = copy _22 as *mut u8 (PtrToPtr); + StorageLive(_21); + _21 = copy ((_19 as Ok).0: std::ptr::NonNull<[u8]>); +- StorageLive(_26); ++ nop; + _26 = copy _21 as *mut [u8] (Transmute); + _12 = copy _26 as *mut u8 (PtrToPtr); +- StorageDead(_26); ++ nop; + StorageDead(_21); + StorageDead(_19); + StorageDead(_18); + StorageDead(_24); StorageDead(_22); + StorageDead(_20); StorageDead(_17); + StorageDead(_16); +- _13 = copy _12 as *const () (PtrToPtr); ++ _13 = copy _26 as *const () (PtrToPtr); + _14 = NonNull::<()> { pointer: copy _13 }; + _15 = Unique::<()> { pointer: copy _14, _marker: const PhantomData::<()> }; + _3 = Box::<()>(move _15, const std::alloc::Global); +- (*_13) = move _4; ++ (*_13) = const (); StorageDead(_15); StorageDead(_14); - StorageDead(_16); - _3 = ShallowInitBox(copy _13, ()); StorageDead(_13); StorageDead(_12); - StorageDead(_11); + StorageDead(_4); _2 = &_3; - _1 = copy _2; - StorageDead(_2); - StorageLive(_4); -- _9 = deref_copy _3; -+ _9 = copy _3; - _10 = copy ((_9.0: std::ptr::Unique<()>).0: std::ptr::NonNull<()>) as *const () (Transmute); - _4 = copy _10; + _1 = &(*_2); +- StorageDead(_2); ++ nop; StorageLive(_5); +- _10 = copy (*_1); ++ _10 = copy (*_2); + _11 = copy ((_10.0: std::ptr::Unique<()>).0: std::ptr::NonNull<()>) as *const () (Transmute); + _5 = &raw const (*_11); StorageLive(_6); -- _6 = copy _4; -+ _6 = copy _10; - StorageLive(_23); - _23 = const 1_usize; -- _5 = *const [()] from (copy _6, copy _23); -+ _5 = *const [()] from (copy _10, const 1_usize); - StorageDead(_23); - StorageDead(_6); StorageLive(_7); + _7 = copy _5; + StorageLive(_27); + _27 = const 1_usize; +- _6 = *const [()] from (copy _7, copy _27); ++ _6 = *const [()] from (copy _5, const 1_usize); + StorageDead(_27); + StorageDead(_7); StorageLive(_8); - _8 = copy _5; -- _7 = copy _8 as *mut () (PtrToPtr); -+ _7 = copy ((_9.0: std::ptr::Unique<()>).0: std::ptr::NonNull<()>) as *mut () (Transmute); + StorageLive(_9); + _9 = copy _6; + StorageLive(_28); +- _28 = copy _9; +- _8 = copy _9 as *mut () (PtrToPtr); ++ _28 = copy _6; ++ _8 = copy _5 as *mut () (PtrToPtr); + StorageDead(_28); + StorageDead(_9); + _0 = const (); StorageDead(_8); - StorageDead(_7); + StorageDead(_6); StorageDead(_5); - StorageDead(_4); drop(_3) -> [return: bb1, unwind unreachable]; } bb5: { -- _20 = Layout::from_size_align_unchecked::precondition_check(copy _11, copy _12) -> [return: bb6, unwind unreachable]; -+ _20 = Layout::from_size_align_unchecked::precondition_check(const 0_usize, const 1_usize) -> [return: bb6, unwind unreachable]; +- _24 = Layout::from_size_align_unchecked::precondition_check(copy _16, copy _17) -> [return: bb6, unwind unreachable]; ++ _24 = Layout::from_size_align_unchecked::precondition_check(const 0_usize, const 1_usize) -> [return: bb6, unwind unreachable]; } bb6: { - StorageDead(_19); - StorageLive(_21); -- _21 = copy _12 as std::ptr::Alignment (Transmute); -- _14 = Layout { size: copy _11, align: move _21 }; -+ _21 = const std::ptr::Alignment(std::ptr::alignment::AlignmentEnum::_Align1Shl0); -+ _14 = const Layout {{ size: 0_usize, align: std::ptr::Alignment(std::ptr::alignment::AlignmentEnum::_Align1Shl0) }}; - StorageDead(_21); - StorageLive(_15); -- _15 = std::alloc::Global::alloc_impl(const alloc::alloc::exchange_malloc::promoted[0], copy _14, const false) -> [return: bb7, unwind unreachable]; -+ _15 = std::alloc::Global::alloc_impl(const alloc::alloc::exchange_malloc::promoted[0], const Layout {{ size: 0_usize, align: std::ptr::Alignment(std::ptr::alignment::AlignmentEnum::_Align1Shl0) }}, const false) -> [return: bb7, unwind unreachable]; + StorageDead(_23); + StorageLive(_25); +- _25 = copy _17 as std::ptr::Alignment (Transmute); +- _18 = Layout { size: copy _16, align: move _25 }; ++ _25 = const std::ptr::Alignment(std::ptr::alignment::AlignmentEnum::_Align1Shl0); ++ _18 = const Layout {{ size: 0_usize, align: std::ptr::Alignment(std::ptr::alignment::AlignmentEnum::_Align1Shl0) }}; + StorageDead(_25); + StorageLive(_19); +- _19 = std::alloc::Global::alloc_impl(const alloc::alloc::exchange_malloc::promoted[0], copy _18, const false) -> [return: bb7, unwind unreachable]; ++ _19 = std::alloc::Global::alloc_impl(const alloc::alloc::exchange_malloc::promoted[0], const Layout {{ size: 0_usize, align: std::ptr::Alignment(std::ptr::alignment::AlignmentEnum::_Align1Shl0) }}, const false) -> [return: bb7, unwind unreachable]; } bb7: { - _16 = discriminant(_15); - switchInt(move _16) -> [0: bb4, 1: bb3, otherwise: bb2]; + _20 = discriminant(_19); + switchInt(move _20) -> [0: bb4, 1: bb3, otherwise: bb2]; } + } + 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 30d8d63850a21..d61433b1efa77 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 @@ -6,24 +6,26 @@ let _1: &std::boxed::Box<()>; let _2: &std::boxed::Box<()>; let _3: std::boxed::Box<()>; - let mut _6: *const (); - let mut _8: *const [()]; - let mut _9: std::boxed::Box<()>; - let mut _10: *const (); - let mut _11: usize; + let mut _4: (); + let mut _7: *const (); + let mut _9: *const [()]; + let mut _10: std::boxed::Box<()>; + let mut _11: *const (); + let mut _12: usize; scope 1 { debug vp_ctx => _1; - let _4: *const (); + let _5: *const (); scope 2 { - debug slf => _10; - let _5: *const [()]; + debug slf => _5; + let _6: *const [()]; scope 3 { - debug bytes => _5; - let _7: *mut (); + debug bytes => _6; + let _8: *mut (); scope 4 { - debug _x => _7; + debug _x => _8; } scope 7 (inlined foo) { + let mut _13: *const [()]; } } scope 5 (inlined slice_from_raw_parts::<()>) { @@ -35,39 +37,50 @@ bb0: { StorageLive(_1); - StorageLive(_2); +- StorageLive(_2); ++ nop; StorageLive(_3); - _3 = Box::<()>::new(const ()) -> [return: bb1, unwind continue]; + StorageLive(_4); +- _4 = (); +- _3 = Box::<()>::new(move _4) -> [return: bb1, unwind continue]; ++ _4 = const (); ++ _3 = Box::<()>::new(const ()) -> [return: bb1, unwind continue]; } bb1: { + StorageDead(_4); _2 = &_3; - _1 = copy _2; - StorageDead(_2); - StorageLive(_4); -- _9 = deref_copy _3; -+ _9 = copy _3; - _10 = copy ((_9.0: std::ptr::Unique<()>).0: std::ptr::NonNull<()>) as *const () (Transmute); - _4 = copy _10; + _1 = &(*_2); +- StorageDead(_2); ++ nop; StorageLive(_5); +- _10 = copy (*_1); ++ _10 = copy (*_2); + _11 = copy ((_10.0: std::ptr::Unique<()>).0: std::ptr::NonNull<()>) as *const () (Transmute); + _5 = &raw const (*_11); StorageLive(_6); -- _6 = copy _4; -+ _6 = copy _10; - StorageLive(_11); - _11 = const 1_usize; -- _5 = *const [()] from (copy _6, copy _11); -+ _5 = *const [()] from (copy _10, const 1_usize); - StorageDead(_11); - StorageDead(_6); StorageLive(_7); + _7 = copy _5; + StorageLive(_12); + _12 = const 1_usize; +- _6 = *const [()] from (copy _7, copy _12); ++ _6 = *const [()] from (copy _5, const 1_usize); + StorageDead(_12); + StorageDead(_7); StorageLive(_8); - _8 = copy _5; -- _7 = copy _8 as *mut () (PtrToPtr); -+ _7 = copy ((_9.0: std::ptr::Unique<()>).0: std::ptr::NonNull<()>) as *mut () (Transmute); + StorageLive(_9); + _9 = copy _6; + StorageLive(_13); +- _13 = copy _9; +- _8 = copy _9 as *mut () (PtrToPtr); ++ _13 = copy _6; ++ _8 = copy _5 as *mut () (PtrToPtr); + StorageDead(_13); + StorageDead(_9); + _0 = const (); StorageDead(_8); - StorageDead(_7); + StorageDead(_6); StorageDead(_5); - StorageDead(_4); drop(_3) -> [return: bb2, unwind: bb3]; } 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 cb6b04573e5a4..207b50f78c1a1 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 @@ -6,24 +6,28 @@ let _1: &std::boxed::Box<()>; let _2: &std::boxed::Box<()>; let _3: std::boxed::Box<()>; - let mut _6: *const (); - let mut _8: *const [()]; - let mut _9: std::boxed::Box<()>; - let mut _10: *const (); - let mut _23: usize; + let mut _4: (); + let mut _7: *const (); + let mut _9: *const [()]; + let mut _10: std::boxed::Box<()>; + let mut _11: *const (); + let mut _16: usize; + let mut _17: usize; + let mut _27: usize; scope 1 { debug vp_ctx => _1; - let _4: *const (); + let _5: *const (); scope 2 { - debug slf => _10; - let _5: *const [()]; + debug slf => _5; + let _6: *const [()]; scope 3 { - debug bytes => _5; - let _7: *mut (); + debug bytes => _6; + let _8: *mut (); scope 4 { - debug _x => _7; + debug _x => _8; } scope 18 (inlined foo) { + let mut _28: *const [()]; } } scope 16 (inlined slice_from_raw_parts::<()>) { @@ -33,21 +37,22 @@ } } scope 5 (inlined Box::<()>::new) { - let mut _11: usize; - let mut _12: usize; - let mut _13: *mut u8; + let mut _12: *mut u8; + let mut _13: *const (); + let mut _14: std::ptr::NonNull<()>; + let mut _15: std::ptr::Unique<()>; scope 6 (inlined alloc::alloc::exchange_malloc) { - let _14: std::alloc::Layout; - let mut _15: std::result::Result, std::alloc::AllocError>; - let mut _16: isize; - let mut _18: !; + let _18: std::alloc::Layout; + let mut _19: std::result::Result, std::alloc::AllocError>; + let mut _20: isize; + let mut _22: !; scope 7 { - let _17: std::ptr::NonNull<[u8]>; + let _21: std::ptr::NonNull<[u8]>; scope 8 { scope 11 (inlined NonNull::<[u8]>::as_mut_ptr) { scope 12 (inlined NonNull::<[u8]>::as_non_null_ptr) { scope 13 (inlined NonNull::<[u8]>::cast::) { - let mut _22: *mut [u8]; + let mut _26: *mut [u8]; scope 14 (inlined NonNull::<[u8]>::as_ptr) { } } @@ -60,30 +65,38 @@ } } scope 9 (inlined #[track_caller] Layout::from_size_align_unchecked) { - let mut _19: bool; - let _20: (); - let mut _21: std::ptr::Alignment; + let mut _23: bool; + let _24: (); + let mut _25: std::ptr::Alignment; } } } bb0: { StorageLive(_1); - StorageLive(_2); +- StorageLive(_2); ++ nop; StorageLive(_3); - StorageLive(_11); + StorageLive(_4); +- _4 = (); ++ _4 = const (); StorageLive(_12); StorageLive(_13); -- _11 = SizeOf(()); -- _12 = AlignOf(()); -+ _11 = const 0_usize; -+ _12 = const 1_usize; - StorageLive(_16); StorageLive(_14); - StorageLive(_19); - _19 = const false; -- switchInt(move _19) -> [0: bb6, otherwise: bb5]; -+ switchInt(const false) -> [0: bb6, otherwise: bb5]; + StorageLive(_15); + StorageLive(_16); +- _16 = const <() as std::mem::SizedTypeProperties>::SIZE; ++ _16 = const 0_usize; + StorageLive(_17); +- _17 = const <() as std::mem::SizedTypeProperties>::ALIGN; ++ _17 = const 1_usize; + StorageLive(_20); + StorageLive(_22); + StorageLive(_24); + StorageLive(_18); + StorageLive(_23); + _23 = UbChecks(); + switchInt(move _23) -> [0: bb6, otherwise: bb5]; } bb1: { @@ -97,76 +110,95 @@ } bb3: { -- _18 = handle_alloc_error(move _14) -> unwind unreachable; -+ _18 = handle_alloc_error(const Layout {{ size: 0_usize, align: std::ptr::Alignment(std::ptr::alignment::AlignmentEnum::_Align1Shl0) }}) -> unwind unreachable; +- _22 = handle_alloc_error(move _18) -> unwind unreachable; ++ _22 = handle_alloc_error(const Layout {{ size: 0_usize, align: std::ptr::Alignment(std::ptr::alignment::AlignmentEnum::_Align1Shl0) }}) -> unwind unreachable; } bb4: { - StorageLive(_17); - _17 = copy ((_15 as Ok).0: std::ptr::NonNull<[u8]>); - StorageLive(_22); - _22 = copy _17 as *mut [u8] (Transmute); - _13 = copy _22 as *mut u8 (PtrToPtr); + StorageLive(_21); + _21 = copy ((_19 as Ok).0: std::ptr::NonNull<[u8]>); +- StorageLive(_26); ++ nop; + _26 = copy _21 as *mut [u8] (Transmute); + _12 = copy _26 as *mut u8 (PtrToPtr); +- StorageDead(_26); ++ nop; + StorageDead(_21); + StorageDead(_19); + StorageDead(_18); + StorageDead(_24); StorageDead(_22); + StorageDead(_20); StorageDead(_17); + StorageDead(_16); +- _13 = copy _12 as *const () (PtrToPtr); ++ _13 = copy _26 as *const () (PtrToPtr); + _14 = NonNull::<()> { pointer: copy _13 }; + _15 = Unique::<()> { pointer: copy _14, _marker: const PhantomData::<()> }; + _3 = Box::<()>(move _15, const std::alloc::Global); +- (*_13) = move _4; ++ (*_13) = const (); StorageDead(_15); StorageDead(_14); - StorageDead(_16); - _3 = ShallowInitBox(copy _13, ()); StorageDead(_13); StorageDead(_12); - StorageDead(_11); + StorageDead(_4); _2 = &_3; - _1 = copy _2; - StorageDead(_2); - StorageLive(_4); -- _9 = deref_copy _3; -+ _9 = copy _3; - _10 = copy ((_9.0: std::ptr::Unique<()>).0: std::ptr::NonNull<()>) as *const () (Transmute); - _4 = copy _10; + _1 = &(*_2); +- StorageDead(_2); ++ nop; StorageLive(_5); +- _10 = copy (*_1); ++ _10 = copy (*_2); + _11 = copy ((_10.0: std::ptr::Unique<()>).0: std::ptr::NonNull<()>) as *const () (Transmute); + _5 = &raw const (*_11); StorageLive(_6); -- _6 = copy _4; -+ _6 = copy _10; - StorageLive(_23); - _23 = const 1_usize; -- _5 = *const [()] from (copy _6, copy _23); -+ _5 = *const [()] from (copy _10, const 1_usize); - StorageDead(_23); - StorageDead(_6); StorageLive(_7); + _7 = copy _5; + StorageLive(_27); + _27 = const 1_usize; +- _6 = *const [()] from (copy _7, copy _27); ++ _6 = *const [()] from (copy _5, const 1_usize); + StorageDead(_27); + StorageDead(_7); StorageLive(_8); - _8 = copy _5; -- _7 = copy _8 as *mut () (PtrToPtr); -+ _7 = copy ((_9.0: std::ptr::Unique<()>).0: std::ptr::NonNull<()>) as *mut () (Transmute); + StorageLive(_9); + _9 = copy _6; + StorageLive(_28); +- _28 = copy _9; +- _8 = copy _9 as *mut () (PtrToPtr); ++ _28 = copy _6; ++ _8 = copy _5 as *mut () (PtrToPtr); + StorageDead(_28); + StorageDead(_9); + _0 = const (); StorageDead(_8); - StorageDead(_7); + StorageDead(_6); StorageDead(_5); - StorageDead(_4); drop(_3) -> [return: bb1, unwind unreachable]; } bb5: { -- _20 = Layout::from_size_align_unchecked::precondition_check(copy _11, copy _12) -> [return: bb6, unwind unreachable]; -+ _20 = Layout::from_size_align_unchecked::precondition_check(const 0_usize, const 1_usize) -> [return: bb6, unwind unreachable]; +- _24 = Layout::from_size_align_unchecked::precondition_check(copy _16, copy _17) -> [return: bb6, unwind unreachable]; ++ _24 = Layout::from_size_align_unchecked::precondition_check(const 0_usize, const 1_usize) -> [return: bb6, unwind unreachable]; } bb6: { - StorageDead(_19); - StorageLive(_21); -- _21 = copy _12 as std::ptr::Alignment (Transmute); -- _14 = Layout { size: copy _11, align: move _21 }; -+ _21 = const std::ptr::Alignment(std::ptr::alignment::AlignmentEnum::_Align1Shl0); -+ _14 = const Layout {{ size: 0_usize, align: std::ptr::Alignment(std::ptr::alignment::AlignmentEnum::_Align1Shl0) }}; - StorageDead(_21); - StorageLive(_15); -- _15 = std::alloc::Global::alloc_impl(const alloc::alloc::exchange_malloc::promoted[0], copy _14, const false) -> [return: bb7, unwind unreachable]; -+ _15 = std::alloc::Global::alloc_impl(const alloc::alloc::exchange_malloc::promoted[0], const Layout {{ size: 0_usize, align: std::ptr::Alignment(std::ptr::alignment::AlignmentEnum::_Align1Shl0) }}, const false) -> [return: bb7, unwind unreachable]; + StorageDead(_23); + StorageLive(_25); +- _25 = copy _17 as std::ptr::Alignment (Transmute); +- _18 = Layout { size: copy _16, align: move _25 }; ++ _25 = const std::ptr::Alignment(std::ptr::alignment::AlignmentEnum::_Align1Shl0); ++ _18 = const Layout {{ size: 0_usize, align: std::ptr::Alignment(std::ptr::alignment::AlignmentEnum::_Align1Shl0) }}; + StorageDead(_25); + StorageLive(_19); +- _19 = std::alloc::Global::alloc_impl(const alloc::alloc::exchange_malloc::promoted[0], copy _18, const false) -> [return: bb7, unwind unreachable]; ++ _19 = std::alloc::Global::alloc_impl(const alloc::alloc::exchange_malloc::promoted[0], const Layout {{ size: 0_usize, align: std::ptr::Alignment(std::ptr::alignment::AlignmentEnum::_Align1Shl0) }}, const false) -> [return: bb7, unwind unreachable]; } bb7: { - _16 = discriminant(_15); - switchInt(move _16) -> [0: bb4, 1: bb3, otherwise: bb2]; + _20 = discriminant(_19); + switchInt(move _20) -> [0: bb4, 1: bb3, otherwise: bb2]; } + } + 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 30d8d63850a21..d61433b1efa77 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 @@ -6,24 +6,26 @@ let _1: &std::boxed::Box<()>; let _2: &std::boxed::Box<()>; let _3: std::boxed::Box<()>; - let mut _6: *const (); - let mut _8: *const [()]; - let mut _9: std::boxed::Box<()>; - let mut _10: *const (); - let mut _11: usize; + let mut _4: (); + let mut _7: *const (); + let mut _9: *const [()]; + let mut _10: std::boxed::Box<()>; + let mut _11: *const (); + let mut _12: usize; scope 1 { debug vp_ctx => _1; - let _4: *const (); + let _5: *const (); scope 2 { - debug slf => _10; - let _5: *const [()]; + debug slf => _5; + let _6: *const [()]; scope 3 { - debug bytes => _5; - let _7: *mut (); + debug bytes => _6; + let _8: *mut (); scope 4 { - debug _x => _7; + debug _x => _8; } scope 7 (inlined foo) { + let mut _13: *const [()]; } } scope 5 (inlined slice_from_raw_parts::<()>) { @@ -35,39 +37,50 @@ bb0: { StorageLive(_1); - StorageLive(_2); +- StorageLive(_2); ++ nop; StorageLive(_3); - _3 = Box::<()>::new(const ()) -> [return: bb1, unwind continue]; + StorageLive(_4); +- _4 = (); +- _3 = Box::<()>::new(move _4) -> [return: bb1, unwind continue]; ++ _4 = const (); ++ _3 = Box::<()>::new(const ()) -> [return: bb1, unwind continue]; } bb1: { + StorageDead(_4); _2 = &_3; - _1 = copy _2; - StorageDead(_2); - StorageLive(_4); -- _9 = deref_copy _3; -+ _9 = copy _3; - _10 = copy ((_9.0: std::ptr::Unique<()>).0: std::ptr::NonNull<()>) as *const () (Transmute); - _4 = copy _10; + _1 = &(*_2); +- StorageDead(_2); ++ nop; StorageLive(_5); +- _10 = copy (*_1); ++ _10 = copy (*_2); + _11 = copy ((_10.0: std::ptr::Unique<()>).0: std::ptr::NonNull<()>) as *const () (Transmute); + _5 = &raw const (*_11); StorageLive(_6); -- _6 = copy _4; -+ _6 = copy _10; - StorageLive(_11); - _11 = const 1_usize; -- _5 = *const [()] from (copy _6, copy _11); -+ _5 = *const [()] from (copy _10, const 1_usize); - StorageDead(_11); - StorageDead(_6); StorageLive(_7); + _7 = copy _5; + StorageLive(_12); + _12 = const 1_usize; +- _6 = *const [()] from (copy _7, copy _12); ++ _6 = *const [()] from (copy _5, const 1_usize); + StorageDead(_12); + StorageDead(_7); StorageLive(_8); - _8 = copy _5; -- _7 = copy _8 as *mut () (PtrToPtr); -+ _7 = copy ((_9.0: std::ptr::Unique<()>).0: std::ptr::NonNull<()>) as *mut () (Transmute); + StorageLive(_9); + _9 = copy _6; + StorageLive(_13); +- _13 = copy _9; +- _8 = copy _9 as *mut () (PtrToPtr); ++ _13 = copy _6; ++ _8 = copy _5 as *mut () (PtrToPtr); + StorageDead(_13); + StorageDead(_9); + _0 = const (); StorageDead(_8); - StorageDead(_7); + StorageDead(_6); StorageDead(_5); - StorageDead(_4); drop(_3) -> [return: bb2, unwind: bb3]; } diff --git a/tests/mir-opt/gvn.dereference_indexing.GVN.panic-abort.diff b/tests/mir-opt/gvn.dereference_indexing.GVN.panic-abort.diff index 851871e4e0880..cdfbef8e9633d 100644 --- a/tests/mir-opt/gvn.dereference_indexing.GVN.panic-abort.diff +++ b/tests/mir-opt/gvn.dereference_indexing.GVN.panic-abort.diff @@ -21,7 +21,8 @@ bb0: { StorageLive(_3); - StorageLive(_4); +- StorageLive(_4); ++ nop; StorageLive(_5); _5 = copy _2; - _4 = Add(move _5, const 1_usize); @@ -37,11 +38,14 @@ bb1: { - _3 = &_1[_6]; +- StorageDead(_4); + _3 = &_1[_4]; - StorageDead(_4); ++ nop; + StorageDead(_6); StorageLive(_8); StorageLive(_9); - _9 = copy (*_3); +- _9 = copy (*_3); ++ _9 = copy _1[_4]; _8 = opaque::(move _9) -> [return: bb2, unwind unreachable]; } @@ -49,7 +53,6 @@ StorageDead(_9); StorageDead(_8); _0 = const (); - StorageDead(_6); StorageDead(_3); return; } diff --git a/tests/mir-opt/gvn.dereference_indexing.GVN.panic-unwind.diff b/tests/mir-opt/gvn.dereference_indexing.GVN.panic-unwind.diff index 0842e73119dc5..8c817f9d5cf75 100644 --- a/tests/mir-opt/gvn.dereference_indexing.GVN.panic-unwind.diff +++ b/tests/mir-opt/gvn.dereference_indexing.GVN.panic-unwind.diff @@ -21,7 +21,8 @@ bb0: { StorageLive(_3); - StorageLive(_4); +- StorageLive(_4); ++ nop; StorageLive(_5); _5 = copy _2; - _4 = Add(move _5, const 1_usize); @@ -37,11 +38,14 @@ bb1: { - _3 = &_1[_6]; +- StorageDead(_4); + _3 = &_1[_4]; - StorageDead(_4); ++ nop; + StorageDead(_6); StorageLive(_8); StorageLive(_9); - _9 = copy (*_3); +- _9 = copy (*_3); ++ _9 = copy _1[_4]; _8 = opaque::(move _9) -> [return: bb2, unwind continue]; } @@ -49,7 +53,6 @@ StorageDead(_9); StorageDead(_8); _0 = const (); - StorageDead(_6); StorageDead(_3); return; } diff --git a/tests/mir-opt/gvn_copy_aggregate.all_copy_2.GVN.diff b/tests/mir-opt/gvn_copy_aggregate.all_copy_2.GVN.diff index a9fb55f1d8f9a..fcbeeb234f95b 100644 --- a/tests/mir-opt/gvn_copy_aggregate.all_copy_2.GVN.diff +++ b/tests/mir-opt/gvn_copy_aggregate.all_copy_2.GVN.diff @@ -25,16 +25,15 @@ bb0: { StorageLive(_2); -- _8 = deref_copy (*_1); -+ _8 = copy (*_1); + _8 = copy (*_1); _2 = copy ((*_8).0: i32); StorageLive(_3); -- _9 = deref_copy (*_1); +- _9 = copy (*_1); - _3 = copy ((*_9).1: u64); + _9 = copy _8; + _3 = copy ((*_8).1: u64); StorageLive(_4); -- _10 = deref_copy (*_1); +- _10 = copy (*_1); - _4 = copy ((*_10).2: [i8; 3]); + _10 = copy _8; + _4 = copy ((*_8).2: [i8; 3]); diff --git a/tests/mir-opt/gvn_loop.loop_deref_mut.GVN.diff b/tests/mir-opt/gvn_loop.loop_deref_mut.GVN.diff index e5d719cf3ca99..b008980074e81 100644 --- a/tests/mir-opt/gvn_loop.loop_deref_mut.GVN.diff +++ b/tests/mir-opt/gvn_loop.loop_deref_mut.GVN.diff @@ -58,9 +58,8 @@ } bb3: { -- StorageLive(_7); + StorageLive(_7); - _7 = copy (((*_2) as V0).0: i32); -+ nop; + _7 = copy (((*_3) as V0).0: i32); StorageLive(_9); goto -> bb4; @@ -85,8 +84,7 @@ StorageDead(_13); StorageDead(_11); StorageDead(_9); -- StorageDead(_7); -+ nop; + StorageDead(_7); StorageDead(_5); StorageDead(_2); return; diff --git a/tests/mir-opt/pre-codegen/deref_nested_borrows.src.GVN.panic-abort.diff b/tests/mir-opt/pre-codegen/deref_nested_borrows.src.GVN.panic-abort.diff index f64efed6b3814..f0b3a373d50ac 100644 --- a/tests/mir-opt/pre-codegen/deref_nested_borrows.src.GVN.panic-abort.diff +++ b/tests/mir-opt/pre-codegen/deref_nested_borrows.src.GVN.panic-abort.diff @@ -16,16 +16,14 @@ bb0: { StorageLive(_2); -- _6 = deref_copy (*_1); -+ _6 = copy (*_1); + _6 = copy (*_1); _2 = copy (*_6); _3 = unknown() -> [return: bb1, unwind unreachable]; } bb1: { StorageLive(_4); -- _7 = deref_copy (*_1); -+ _7 = copy (*_1); + _7 = copy (*_1); _4 = copy (*_7); StorageLive(_5); _5 = copy _2; diff --git a/tests/mir-opt/pre-codegen/deref_nested_borrows.src.GVN.panic-unwind.diff b/tests/mir-opt/pre-codegen/deref_nested_borrows.src.GVN.panic-unwind.diff index 077bca2805d63..8676208dbf71a 100644 --- a/tests/mir-opt/pre-codegen/deref_nested_borrows.src.GVN.panic-unwind.diff +++ b/tests/mir-opt/pre-codegen/deref_nested_borrows.src.GVN.panic-unwind.diff @@ -16,16 +16,14 @@ bb0: { StorageLive(_2); -- _6 = deref_copy (*_1); -+ _6 = copy (*_1); + _6 = copy (*_1); _2 = copy (*_6); _3 = unknown() -> [return: bb1, unwind continue]; } bb1: { StorageLive(_4); -- _7 = deref_copy (*_1); -+ _7 = copy (*_1); + _7 = copy (*_1); _4 = copy (*_7); StorageLive(_5); _5 = copy _2; diff --git a/tests/mir-opt/pre-codegen/two_unwrap_unchecked.two_unwrap_unchecked.GVN.diff b/tests/mir-opt/pre-codegen/two_unwrap_unchecked.two_unwrap_unchecked.GVN.diff index 5b063e6762e07..78d58c6f60fae 100644 --- a/tests/mir-opt/pre-codegen/two_unwrap_unchecked.two_unwrap_unchecked.GVN.diff +++ b/tests/mir-opt/pre-codegen/two_unwrap_unchecked.two_unwrap_unchecked.GVN.diff @@ -40,9 +40,8 @@ } bb0: { -- StorageLive(_2); + StorageLive(_2); - StorageLive(_3); -+ nop; + nop; _3 = copy (*_1); - StorageLive(_8); @@ -97,8 +96,7 @@ StorageDead(_7); StorageDead(_6); StorageDead(_4); -- StorageDead(_2); -+ nop; + StorageDead(_2); return; } } diff --git a/tests/mir-opt/pre-codegen/two_unwrap_unchecked.two_unwrap_unchecked.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/two_unwrap_unchecked.two_unwrap_unchecked.PreCodegen.after.mir index b2b7f88d8534b..0b41ce991eab8 100644 --- a/tests/mir-opt/pre-codegen/two_unwrap_unchecked.two_unwrap_unchecked.PreCodegen.after.mir +++ b/tests/mir-opt/pre-codegen/two_unwrap_unchecked.two_unwrap_unchecked.PreCodegen.after.mir @@ -34,6 +34,7 @@ fn two_unwrap_unchecked(_1: &Option) -> i32 { } bb0: { + StorageLive(_4); _2 = copy (*_1); _3 = discriminant(_2); switchInt(copy _3) -> [0: bb2, 1: bb1, otherwise: bb2]; @@ -42,6 +43,7 @@ fn two_unwrap_unchecked(_1: &Option) -> i32 { bb1: { _4 = copy ((_2 as Some).0: i32); _0 = Add(copy _4, copy _4); + StorageDead(_4); return; }