From 27d6a57e5821c8b7f5c8b049e36b856ed9440bfe Mon Sep 17 00:00:00 2001 From: Camille GILLOT Date: Thu, 12 Jan 2023 20:04:42 +0000 Subject: [PATCH] Preserve DebugInfo in DeadStoreElimination. --- compiler/rustc_index/src/bit_set.rs | 8 +- compiler/rustc_mir_dataflow/src/debuginfo.rs | 20 ++ compiler/rustc_mir_dataflow/src/lib.rs | 1 + .../src/dead_store_elimination.rs | 22 +- .../cycle.cycle.DeadStoreElimination.diff | 29 ++ ...ycle.DeadStoreElimination.panic-abort.diff | 73 ----- ...cle.DeadStoreElimination.panic-unwind.diff | 73 ----- tests/mir-opt/dead-store-elimination/cycle.rs | 37 ++- ...stinationPropagation.after.panic-abort.mir | 7 +- ...tinationPropagation.after.panic-unwind.mir | 7 +- ...in.DestinationPropagation.panic-abort.diff | 2 + ...n.DestinationPropagation.panic-unwind.diff | 2 + ...ue_101973.inner.ConstProp.panic-abort.diff | 1 + ...e_101973.inner.ConstProp.panic-unwind.diff | 1 + ..._to_digit.PreCodegen.after.panic-abort.mir | 45 +-- ...to_digit.PreCodegen.after.panic-unwind.mir | 45 +-- ...cked_ops.step_forward.PreCodegen.after.mir | 45 +-- .../loops.filter_mapped.PreCodegen.after.mir | 43 +-- .../loops.int_range.PreCodegen.after.mir | 101 +++---- ...ward_loop.PreCodegen.after.panic-abort.mir | 117 ++++---- ...ard_loop.PreCodegen.after.panic-unwind.mir | 117 ++++---- ...iter_next.PreCodegen.after.panic-abort.mir | 64 +++-- ...ter_next.PreCodegen.after.panic-unwind.mir | 64 +++-- ...variant_a-{closure#0}.PreCodegen.after.mir | 264 +++++++++--------- ...mut_range.PreCodegen.after.panic-abort.mir | 14 +- ...ut_range.PreCodegen.after.panic-unwind.mir | 14 +- ...ange_loop.PreCodegen.after.panic-abort.mir | 133 ++++----- ...nge_loop.PreCodegen.after.panic-unwind.mir | 133 ++++----- ...erse_loop.PreCodegen.after.panic-abort.mir | 49 ++-- ...rse_loop.PreCodegen.after.panic-unwind.mir | 49 ++-- 30 files changed, 773 insertions(+), 807 deletions(-) create mode 100644 compiler/rustc_mir_dataflow/src/debuginfo.rs create mode 100644 tests/mir-opt/dead-store-elimination/cycle.cycle.DeadStoreElimination.diff delete mode 100644 tests/mir-opt/dead-store-elimination/cycle.cycle.DeadStoreElimination.panic-abort.diff delete mode 100644 tests/mir-opt/dead-store-elimination/cycle.cycle.DeadStoreElimination.panic-unwind.diff diff --git a/compiler/rustc_index/src/bit_set.rs b/compiler/rustc_index/src/bit_set.rs index 12a7ecf8133..ece61ff1252 100644 --- a/compiler/rustc_index/src/bit_set.rs +++ b/compiler/rustc_index/src/bit_set.rs @@ -365,7 +365,7 @@ impl From> for BitSet { /// All operations that involve an element will panic if the element is equal /// to or greater than the domain size. All operations that involve two bitsets /// will panic if the bitsets have differing domain sizes. -#[derive(Debug, PartialEq, Eq)] +#[derive(PartialEq, Eq)] pub struct ChunkedBitSet { domain_size: usize, @@ -1074,6 +1074,12 @@ impl fmt::Debug for BitSet { } } +impl fmt::Debug for ChunkedBitSet { + fn fmt(&self, w: &mut fmt::Formatter<'_>) -> fmt::Result { + w.debug_list().entries(self.iter()).finish() + } +} + impl ToString for BitSet { fn to_string(&self) -> String { let mut result = String::new(); diff --git a/compiler/rustc_mir_dataflow/src/debuginfo.rs b/compiler/rustc_mir_dataflow/src/debuginfo.rs new file mode 100644 index 00000000000..fd5e8cf2955 --- /dev/null +++ b/compiler/rustc_mir_dataflow/src/debuginfo.rs @@ -0,0 +1,20 @@ +use rustc_index::bit_set::BitSet; +use rustc_middle::mir::visit::*; +use rustc_middle::mir::*; + +/// Return the set of locals that appear in debuginfo. +pub fn debuginfo_locals(body: &Body<'_>) -> BitSet { + let mut visitor = DebuginfoLocals(BitSet::new_empty(body.local_decls.len())); + for debuginfo in body.var_debug_info.iter() { + visitor.visit_var_debug_info(debuginfo); + } + visitor.0 +} + +struct DebuginfoLocals(BitSet); + +impl Visitor<'_> for DebuginfoLocals { + fn visit_local(&mut self, local: Local, _: PlaceContext, _: Location) { + self.0.insert(local); + } +} diff --git a/compiler/rustc_mir_dataflow/src/lib.rs b/compiler/rustc_mir_dataflow/src/lib.rs index 0cdbee19d2c..ecf46715cd0 100644 --- a/compiler/rustc_mir_dataflow/src/lib.rs +++ b/compiler/rustc_mir_dataflow/src/lib.rs @@ -35,6 +35,7 @@ pub use self::framework::{ use self::move_paths::MoveData; +pub mod debuginfo; pub mod drop_flag_effects; pub mod elaborate_drops; mod errors; diff --git a/compiler/rustc_mir_transform/src/dead_store_elimination.rs b/compiler/rustc_mir_transform/src/dead_store_elimination.rs index ef14105041b..3d74ef7e327 100644 --- a/compiler/rustc_mir_transform/src/dead_store_elimination.rs +++ b/compiler/rustc_mir_transform/src/dead_store_elimination.rs @@ -13,10 +13,10 @@ //! use crate::util::is_within_packed; -use rustc_index::bit_set::BitSet; use rustc_middle::mir::visit::Visitor; use rustc_middle::mir::*; use rustc_middle::ty::TyCtxt; +use rustc_mir_dataflow::debuginfo::debuginfo_locals; use rustc_mir_dataflow::impls::{ borrowed_locals, LivenessTransferFunction, MaybeTransitiveLiveLocals, }; @@ -26,8 +26,15 @@ use rustc_mir_dataflow::Analysis; /// /// The `borrowed` set must be a `BitSet` of all the locals that are ever borrowed in this body. It /// can be generated via the [`borrowed_locals`] function. -pub fn eliminate<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>, borrowed: &BitSet) { - let mut live = MaybeTransitiveLiveLocals::new(borrowed) +pub fn eliminate<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) { + let borrowed_locals = borrowed_locals(body); + + // If the user requests complete debuginfo, mark the locals that appear in it as live, so + // we don't remove assignements to them. + let mut always_live = debuginfo_locals(body); + always_live.union(&borrowed_locals); + + let mut live = MaybeTransitiveLiveLocals::new(&always_live) .into_engine(tcx, body) .iterate_to_fixpoint() .into_results_cursor(body); @@ -48,7 +55,9 @@ pub fn eliminate<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>, borrowed: &BitS for (index, arg) in args.iter().enumerate().rev() { if let Operand::Copy(place) = *arg && !place.is_indirect() - && !borrowed.contains(place.local) + // Do not skip the transformation if the local is in debuginfo, as we do + // not really lose any information for this purpose. + && !borrowed_locals.contains(place.local) && !state.contains(place.local) // If `place` is a projection of a disaligned field in a packed ADT, // the move may be codegened as a pointer to that field. @@ -75,7 +84,7 @@ pub fn eliminate<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>, borrowed: &BitS StatementKind::Assign(box (place, _)) | StatementKind::SetDiscriminant { place: box place, .. } | StatementKind::Deinit(box place) => { - if !place.is_indirect() && !borrowed.contains(place.local) { + if !place.is_indirect() && !always_live.contains(place.local) { live.seek_before_primary_effect(loc); if !live.get().contains(place.local) { patch.push(loc); @@ -126,7 +135,6 @@ impl<'tcx> MirPass<'tcx> for DeadStoreElimination { } fn run_pass(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) { - let borrowed = borrowed_locals(body); - eliminate(tcx, body, &borrowed); + eliminate(tcx, body); } } diff --git a/tests/mir-opt/dead-store-elimination/cycle.cycle.DeadStoreElimination.diff b/tests/mir-opt/dead-store-elimination/cycle.cycle.DeadStoreElimination.diff new file mode 100644 index 00000000000..cf73358dc52 --- /dev/null +++ b/tests/mir-opt/dead-store-elimination/cycle.cycle.DeadStoreElimination.diff @@ -0,0 +1,29 @@ +- // MIR for `cycle` before DeadStoreElimination ++ // MIR for `cycle` after DeadStoreElimination + + fn cycle(_1: i32, _2: i32, _3: i32) -> () { + let mut _0: (); + let mut _4: bool; +- let mut _5: i32; + + bb0: { + _4 = cond() -> [return: bb1, unwind continue]; + } + + bb1: { + switchInt(_4) -> [1: bb2, otherwise: bb3]; + } + + bb2: { +- _5 = _3; +- _3 = _2; +- _2 = _1; +- _1 = _5; + _4 = cond() -> [return: bb1, unwind continue]; + } + + bb3: { + return; + } + } + diff --git a/tests/mir-opt/dead-store-elimination/cycle.cycle.DeadStoreElimination.panic-abort.diff b/tests/mir-opt/dead-store-elimination/cycle.cycle.DeadStoreElimination.panic-abort.diff deleted file mode 100644 index 6221d478041..00000000000 --- a/tests/mir-opt/dead-store-elimination/cycle.cycle.DeadStoreElimination.panic-abort.diff +++ /dev/null @@ -1,73 +0,0 @@ -- // MIR for `cycle` before DeadStoreElimination -+ // MIR for `cycle` after DeadStoreElimination - - fn cycle(_1: i32, _2: i32, _3: i32) -> () { - debug x => _1; - debug y => _2; - debug z => _3; - let mut _0: (); -- let mut _4: (); -- let mut _5: bool; -- let _6: i32; -- let mut _7: i32; -- let mut _8: i32; -- let mut _9: i32; -- let mut _10: !; -- let _11: (); -- let mut _12: !; -+ let mut _4: bool; -+ let _5: i32; - scope 1 { -- debug temp => _6; -+ debug temp => _5; - } - - bb0: { - goto -> bb1; - } - - bb1: { -- StorageLive(_5); -- _5 = cond() -> [return: bb2, unwind unreachable]; -+ StorageLive(_4); -+ _4 = cond() -> [return: bb2, unwind unreachable]; - } - - bb2: { -- switchInt(move _5) -> [0: bb4, otherwise: bb3]; -+ switchInt(move _4) -> [0: bb4, otherwise: bb3]; - } - - bb3: { -- StorageLive(_6); -- _6 = _3; -- StorageLive(_7); -- _7 = _2; -- _3 = move _7; -- StorageDead(_7); -- StorageLive(_8); -- _8 = _1; -- _2 = move _8; -- StorageDead(_8); -- StorageLive(_9); -- _9 = _6; -- _1 = move _9; -- StorageDead(_9); -- _4 = const (); -- StorageDead(_6); -+ StorageLive(_5); - StorageDead(_5); -+ StorageDead(_4); - goto -> bb1; - } - - bb4: { -- StorageLive(_11); - _0 = const (); -- StorageDead(_11); -- StorageDead(_5); -+ StorageDead(_4); - return; - } - } - diff --git a/tests/mir-opt/dead-store-elimination/cycle.cycle.DeadStoreElimination.panic-unwind.diff b/tests/mir-opt/dead-store-elimination/cycle.cycle.DeadStoreElimination.panic-unwind.diff deleted file mode 100644 index 4b922e05e10..00000000000 --- a/tests/mir-opt/dead-store-elimination/cycle.cycle.DeadStoreElimination.panic-unwind.diff +++ /dev/null @@ -1,73 +0,0 @@ -- // MIR for `cycle` before DeadStoreElimination -+ // MIR for `cycle` after DeadStoreElimination - - fn cycle(_1: i32, _2: i32, _3: i32) -> () { - debug x => _1; - debug y => _2; - debug z => _3; - let mut _0: (); -- let mut _4: (); -- let mut _5: bool; -- let _6: i32; -- let mut _7: i32; -- let mut _8: i32; -- let mut _9: i32; -- let mut _10: !; -- let _11: (); -- let mut _12: !; -+ let mut _4: bool; -+ let _5: i32; - scope 1 { -- debug temp => _6; -+ debug temp => _5; - } - - bb0: { - goto -> bb1; - } - - bb1: { -- StorageLive(_5); -- _5 = cond() -> [return: bb2, unwind continue]; -+ StorageLive(_4); -+ _4 = cond() -> [return: bb2, unwind continue]; - } - - bb2: { -- switchInt(move _5) -> [0: bb4, otherwise: bb3]; -+ switchInt(move _4) -> [0: bb4, otherwise: bb3]; - } - - bb3: { -- StorageLive(_6); -- _6 = _3; -- StorageLive(_7); -- _7 = _2; -- _3 = move _7; -- StorageDead(_7); -- StorageLive(_8); -- _8 = _1; -- _2 = move _8; -- StorageDead(_8); -- StorageLive(_9); -- _9 = _6; -- _1 = move _9; -- StorageDead(_9); -- _4 = const (); -- StorageDead(_6); -+ StorageLive(_5); - StorageDead(_5); -+ StorageDead(_4); - goto -> bb1; - } - - bb4: { -- StorageLive(_11); - _0 = const (); -- StorageDead(_11); -- StorageDead(_5); -+ StorageDead(_4); - return; - } - } - diff --git a/tests/mir-opt/dead-store-elimination/cycle.rs b/tests/mir-opt/dead-store-elimination/cycle.rs index cd34fe96e8c..e3def2f65da 100644 --- a/tests/mir-opt/dead-store-elimination/cycle.rs +++ b/tests/mir-opt/dead-store-elimination/cycle.rs @@ -1,21 +1,40 @@ -// EMIT_MIR_FOR_EACH_PANIC_STRATEGY +// This example is interesting because the non-transitive version of `MaybeLiveLocals` would +// report that *all* of these stores are live. +// +// needs-unwind // unit-test: DeadStoreElimination +#![feature(core_intrinsics, custom_mir)] +use std::intrinsics::mir::*; + #[inline(never)] fn cond() -> bool { false } // EMIT_MIR cycle.cycle.DeadStoreElimination.diff +#[custom_mir(dialect = "runtime", phase = "post-cleanup")] fn cycle(mut x: i32, mut y: i32, mut z: i32) { - // This example is interesting because the non-transitive version of `MaybeLiveLocals` would - // report that *all* of these stores are live. - while cond() { - let temp = z; - z = y; - y = x; - x = temp; - } + // We use custom MIR to avoid generating debuginfo, that would force to preserve writes. + mir!( + let condition: bool; + { + Call(condition = cond(), bb1) + } + bb1 = { + match condition { true => bb2, _ => ret } + } + bb2 = { + let temp = z; + z = y; + y = x; + x = temp; + Call(condition = cond(), bb1) + } + ret = { + Return() + } + ) } fn main() { diff --git a/tests/mir-opt/dest-prop/dead_stores_better.f.DestinationPropagation.after.panic-abort.mir b/tests/mir-opt/dest-prop/dead_stores_better.f.DestinationPropagation.after.panic-abort.mir index a3ec0901075..eb160fc194a 100644 --- a/tests/mir-opt/dest-prop/dead_stores_better.f.DestinationPropagation.after.panic-abort.mir +++ b/tests/mir-opt/dest-prop/dead_stores_better.f.DestinationPropagation.after.panic-abort.mir @@ -7,15 +7,16 @@ fn f(_1: usize) -> usize { let mut _3: usize; let mut _4: usize; scope 1 { - debug b => _1; + debug b => _3; } bb0: { nop; + _3 = _1; + _1 = const 5_usize; nop; nop; - nop; - nop; + _1 = move _3; nop; nop; nop; diff --git a/tests/mir-opt/dest-prop/dead_stores_better.f.DestinationPropagation.after.panic-unwind.mir b/tests/mir-opt/dest-prop/dead_stores_better.f.DestinationPropagation.after.panic-unwind.mir index 185feb4b418..9147de2ec47 100644 --- a/tests/mir-opt/dest-prop/dead_stores_better.f.DestinationPropagation.after.panic-unwind.mir +++ b/tests/mir-opt/dest-prop/dead_stores_better.f.DestinationPropagation.after.panic-unwind.mir @@ -7,15 +7,16 @@ fn f(_1: usize) -> usize { let mut _3: usize; let mut _4: usize; scope 1 { - debug b => _1; + debug b => _3; } bb0: { nop; + _3 = _1; + _1 = const 5_usize; nop; nop; - nop; - nop; + _1 = move _3; nop; nop; nop; diff --git a/tests/mir-opt/dest-prop/union.main.DestinationPropagation.panic-abort.diff b/tests/mir-opt/dest-prop/union.main.DestinationPropagation.panic-abort.diff index 459a9c442b3..d5e58265dcc 100644 --- a/tests/mir-opt/dest-prop/union.main.DestinationPropagation.panic-abort.diff +++ b/tests/mir-opt/dest-prop/union.main.DestinationPropagation.panic-abort.diff @@ -22,8 +22,10 @@ } bb1: { + _1 = Un { us: move _2 }; StorageDead(_2); StorageLive(_3); + _3 = (_1.0: u32); StorageDead(_3); StorageDead(_1); return; diff --git a/tests/mir-opt/dest-prop/union.main.DestinationPropagation.panic-unwind.diff b/tests/mir-opt/dest-prop/union.main.DestinationPropagation.panic-unwind.diff index d2eef90582d..5eaaeba135b 100644 --- a/tests/mir-opt/dest-prop/union.main.DestinationPropagation.panic-unwind.diff +++ b/tests/mir-opt/dest-prop/union.main.DestinationPropagation.panic-unwind.diff @@ -22,8 +22,10 @@ } bb1: { + _1 = Un { us: move _2 }; StorageDead(_2); StorageLive(_3); + _3 = (_1.0: u32); StorageDead(_3); StorageDead(_1); return; diff --git a/tests/mir-opt/issue_101973.inner.ConstProp.panic-abort.diff b/tests/mir-opt/issue_101973.inner.ConstProp.panic-abort.diff index ce490e894f0..3748d148380 100644 --- a/tests/mir-opt/issue_101973.inner.ConstProp.panic-abort.diff +++ b/tests/mir-opt/issue_101973.inner.ConstProp.panic-abort.diff @@ -33,6 +33,7 @@ StorageLive(_2); StorageLive(_3); StorageLive(_4); + _4 = const 0_u32; StorageLive(_15); StorageLive(_14); _14 = Shr(_1, const 0_i32); diff --git a/tests/mir-opt/issue_101973.inner.ConstProp.panic-unwind.diff b/tests/mir-opt/issue_101973.inner.ConstProp.panic-unwind.diff index 254557b9947..9dab4233c56 100644 --- a/tests/mir-opt/issue_101973.inner.ConstProp.panic-unwind.diff +++ b/tests/mir-opt/issue_101973.inner.ConstProp.panic-unwind.diff @@ -33,6 +33,7 @@ StorageLive(_2); StorageLive(_3); StorageLive(_4); + _4 = const 0_u32; StorageLive(_15); StorageLive(_14); _14 = Shr(_1, const 0_i32); diff --git a/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.panic-abort.mir b/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.panic-abort.mir index 55ccf6a8b45..5d25c655700 100644 --- a/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.panic-abort.mir +++ b/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.panic-abort.mir @@ -3,60 +3,61 @@ fn num_to_digit(_1: char) -> u32 { debug num => _1; let mut _0: u32; - let mut _4: std::option::Option; + let mut _5: std::option::Option; scope 1 (inlined char::methods::::is_digit) { debug self => _1; debug radix => const 8_u32; let _2: std::option::Option; - let mut _7: &std::option::Option; + let mut _3: &std::option::Option; scope 2 (inlined Option::::is_some) { - debug self => _7; - let mut _3: isize; + debug self => _3; + let mut _4: isize; } } scope 3 (inlined #[track_caller] Option::::unwrap) { - debug self => _4; - let mut _5: isize; - let mut _6: !; + debug self => _5; + let mut _6: isize; + let mut _7: !; scope 4 { debug val => _0; } } bb0: { - StorageLive(_7); + StorageLive(_3); StorageLive(_2); _2 = char::methods::::to_digit(_1, const 8_u32) -> [return: bb1, unwind unreachable]; } bb1: { - StorageLive(_3); - _3 = discriminant(_2); - StorageDead(_7); + _3 = &_2; + StorageLive(_4); + _4 = discriminant(_2); + StorageDead(_3); StorageDead(_2); - switchInt(move _3) -> [1: bb2, otherwise: bb7]; + switchInt(move _4) -> [1: bb2, otherwise: bb7]; } bb2: { - StorageDead(_3); - StorageLive(_4); - _4 = char::methods::::to_digit(move _1, const 8_u32) -> [return: bb3, unwind unreachable]; + StorageDead(_4); + StorageLive(_5); + _5 = char::methods::::to_digit(move _1, const 8_u32) -> [return: bb3, unwind unreachable]; } bb3: { - StorageLive(_5); - _5 = discriminant(_4); - switchInt(move _5) -> [0: bb4, 1: bb5, otherwise: bb6]; + StorageLive(_6); + _6 = discriminant(_5); + switchInt(move _6) -> [0: bb4, 1: bb5, otherwise: bb6]; } bb4: { - _6 = core::panicking::panic(const "called `Option::unwrap()` on a `None` value") -> unwind unreachable; + _7 = core::panicking::panic(const "called `Option::unwrap()` on a `None` value") -> unwind unreachable; } bb5: { - _0 = move ((_4 as Some).0: u32); + _0 = move ((_5 as Some).0: u32); + StorageDead(_6); StorageDead(_5); - StorageDead(_4); goto -> bb8; } @@ -65,7 +66,7 @@ fn num_to_digit(_1: char) -> u32 { } bb7: { - StorageDead(_3); + StorageDead(_4); _0 = const 0_u32; goto -> bb8; } diff --git a/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.panic-unwind.mir index cb70a83e7f8..4677c0108e3 100644 --- a/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.panic-unwind.mir +++ b/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.panic-unwind.mir @@ -3,60 +3,61 @@ fn num_to_digit(_1: char) -> u32 { debug num => _1; let mut _0: u32; - let mut _4: std::option::Option; + let mut _5: std::option::Option; scope 1 (inlined char::methods::::is_digit) { debug self => _1; debug radix => const 8_u32; let _2: std::option::Option; - let mut _7: &std::option::Option; + let mut _3: &std::option::Option; scope 2 (inlined Option::::is_some) { - debug self => _7; - let mut _3: isize; + debug self => _3; + let mut _4: isize; } } scope 3 (inlined #[track_caller] Option::::unwrap) { - debug self => _4; - let mut _5: isize; - let mut _6: !; + debug self => _5; + let mut _6: isize; + let mut _7: !; scope 4 { debug val => _0; } } bb0: { - StorageLive(_7); + StorageLive(_3); StorageLive(_2); _2 = char::methods::::to_digit(_1, const 8_u32) -> [return: bb1, unwind continue]; } bb1: { - StorageLive(_3); - _3 = discriminant(_2); - StorageDead(_7); + _3 = &_2; + StorageLive(_4); + _4 = discriminant(_2); + StorageDead(_3); StorageDead(_2); - switchInt(move _3) -> [1: bb2, otherwise: bb7]; + switchInt(move _4) -> [1: bb2, otherwise: bb7]; } bb2: { - StorageDead(_3); - StorageLive(_4); - _4 = char::methods::::to_digit(move _1, const 8_u32) -> [return: bb3, unwind continue]; + StorageDead(_4); + StorageLive(_5); + _5 = char::methods::::to_digit(move _1, const 8_u32) -> [return: bb3, unwind continue]; } bb3: { - StorageLive(_5); - _5 = discriminant(_4); - switchInt(move _5) -> [0: bb4, 1: bb5, otherwise: bb6]; + StorageLive(_6); + _6 = discriminant(_5); + switchInt(move _6) -> [0: bb4, 1: bb5, otherwise: bb6]; } bb4: { - _6 = core::panicking::panic(const "called `Option::unwrap()` on a `None` value") -> unwind continue; + _7 = core::panicking::panic(const "called `Option::unwrap()` on a `None` value") -> unwind continue; } bb5: { - _0 = move ((_4 as Some).0: u32); + _0 = move ((_5 as Some).0: u32); + StorageDead(_6); StorageDead(_5); - StorageDead(_4); goto -> bb8; } @@ -65,7 +66,7 @@ fn num_to_digit(_1: char) -> u32 { } bb7: { - StorageDead(_3); + StorageDead(_4); _0 = const 0_u32; goto -> bb8; } diff --git a/tests/mir-opt/pre-codegen/checked_ops.step_forward.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/checked_ops.step_forward.PreCodegen.after.mir index e3c81061a46..cf7feef0051 100644 --- a/tests/mir-opt/pre-codegen/checked_ops.step_forward.PreCodegen.after.mir +++ b/tests/mir-opt/pre-codegen/checked_ops.step_forward.PreCodegen.after.mir @@ -8,61 +8,62 @@ fn step_forward(_1: u32, _2: usize) -> u32 { debug start => _1; debug n => _2; let _3: std::option::Option; - let mut _6: bool; - let mut _7: u32; - let mut _8: &std::option::Option; + let mut _4: &std::option::Option; + let mut _7: bool; + let mut _8: u32; scope 2 { } scope 3 (inlined Option::::is_none) { - debug self => _8; - let mut _5: bool; + debug self => _4; + let mut _6: bool; scope 4 (inlined Option::::is_some) { - debug self => _8; - let mut _4: isize; + debug self => _4; + let mut _5: isize; } } scope 5 (inlined core::num::::wrapping_add) { debug self => _1; - debug rhs => _7; + debug rhs => _8; } } bb0: { - StorageLive(_6); - StorageLive(_8); + StorageLive(_7); + StorageLive(_4); StorageLive(_3); _3 = ::forward_checked(_1, _2) -> [return: bb1, unwind continue]; } bb1: { + _4 = &_3; + StorageLive(_6); StorageLive(_5); - StorageLive(_4); - _4 = discriminant(_3); - _5 = Eq(_4, const 1_isize); - StorageDead(_4); - _6 = Not(move _5); + _5 = discriminant(_3); + _6 = Eq(_5, const 1_isize); StorageDead(_5); - switchInt(move _6) -> [0: bb2, otherwise: bb3]; + _7 = Not(move _6); + StorageDead(_6); + switchInt(move _7) -> [0: bb2, otherwise: bb3]; } bb2: { StorageDead(_3); - StorageDead(_8); + StorageDead(_4); goto -> bb4; } bb3: { StorageDead(_3); - StorageDead(_8); + StorageDead(_4); assert(!const true, "attempt to compute `{} + {}`, which would overflow", const _, const 1_u32) -> [success: bb4, unwind continue]; } bb4: { - StorageDead(_6); - StorageLive(_7); - _7 = _2 as u32 (IntToInt); - _0 = Add(_1, _7); StorageDead(_7); + StorageLive(_8); + _8 = _2 as u32 (IntToInt); + _0 = Add(_1, _8); + StorageDead(_8); 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 4db829a5ec3..2fbe5088268 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 @@ -7,20 +7,20 @@ fn filter_mapped(_1: impl Iterator, _2: impl Fn(T) -> Option) -> () let mut _3: std::iter::FilterMap, impl Fn(T) -> Option>; let mut _4: std::iter::FilterMap, impl Fn(T) -> Option>; let mut _5: std::iter::FilterMap, impl Fn(T) -> Option>; - let mut _8: std::option::Option; - let mut _9: isize; - let _11: (); - let mut _12: &mut std::iter::FilterMap, impl Fn(T) -> Option>; + let mut _6: &mut std::iter::FilterMap, impl Fn(T) -> Option>; + let mut _9: std::option::Option; + let mut _10: isize; + let _12: (); scope 1 { debug iter => _5; - let _10: U; + let _11: U; scope 2 { - debug x => _10; + debug x => _11; } scope 4 (inlined , impl Fn(T) -> Option> as Iterator>::next) { - debug self => _12; - let mut _6: &mut impl Iterator; - let mut _7: &mut impl Fn(T) -> Option; + debug self => _6; + let mut _7: &mut impl Iterator; + let mut _8: &mut impl Fn(T) -> Option; } } scope 3 (inlined , impl Fn(T) -> Option> as IntoIterator>::into_iter) { @@ -42,23 +42,24 @@ fn filter_mapped(_1: impl Iterator, _2: impl Fn(T) -> Option) -> () } bb2: { - StorageLive(_8); - StorageLive(_6); - _6 = &mut (_5.0: impl Iterator); + StorageLive(_9); + _6 = &mut _5; StorageLive(_7); - _7 = &mut (_5.1: impl Fn(T) -> Option); - _8 = as Iterator>::find_map:: Option>(move _6, move _7) -> [return: bb3, unwind: bb9]; + _7 = &mut (_5.0: impl Iterator); + StorageLive(_8); + _8 = &mut (_5.1: impl Fn(T) -> Option); + _9 = as Iterator>::find_map:: Option>(move _7, move _8) -> [return: bb3, unwind: bb9]; } bb3: { + StorageDead(_8); StorageDead(_7); - StorageDead(_6); - _9 = discriminant(_8); - switchInt(move _9) -> [0: bb4, 1: bb6, otherwise: bb8]; + _10 = discriminant(_9); + switchInt(move _10) -> [0: bb4, 1: bb6, otherwise: bb8]; } bb4: { - StorageDead(_8); + StorageDead(_9); drop(_5) -> [return: bb5, unwind continue]; } @@ -69,12 +70,12 @@ fn filter_mapped(_1: impl Iterator, _2: impl Fn(T) -> Option) -> () } bb6: { - _10 = move ((_8 as Some).0: U); - _11 = opaque::(move _10) -> [return: bb7, unwind: bb9]; + _11 = move ((_9 as Some).0: U); + _12 = opaque::(move _11) -> [return: bb7, unwind: bb9]; } bb7: { - StorageDead(_8); + StorageDead(_9); 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 0d79f2de10d..49f685cfacd 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 @@ -6,35 +6,35 @@ fn int_range(_1: usize, _2: usize) -> () { let mut _0: (); let mut _3: std::ops::Range; let mut _4: std::ops::Range; - let mut _8: std::option::Option; - let mut _11: isize; - let _13: (); - let mut _14: &mut std::ops::Range; + let mut _5: &mut std::ops::Range; + let mut _11: std::option::Option; + let mut _14: isize; + let _16: (); scope 1 { debug iter => _4; - let _12: usize; + let _15: usize; scope 2 { - debug i => _12; + debug i => _15; } scope 4 (inlined iter::range::>::next) { - debug self => _14; + debug self => _5; scope 5 (inlined as iter::range::RangeIteratorImpl>::spec_next) { - debug self => _14; - let mut _7: bool; - let _9: usize; - let mut _10: usize; - let mut _15: &usize; - let mut _16: &usize; + debug self => _5; + let mut _6: &usize; + let mut _7: &usize; + let mut _10: bool; + let _12: usize; + let mut _13: usize; scope 6 { - debug old => _9; + debug old => _12; scope 7 { } } scope 8 (inlined cmp::impls::::lt) { - debug self => _15; - debug other => _16; - let mut _5: usize; - let mut _6: usize; + debug self => _6; + debug other => _7; + let mut _8: usize; + let mut _9: usize; } } } @@ -51,63 +51,66 @@ fn int_range(_1: usize, _2: usize) -> () { } bb1: { - StorageLive(_8); - StorageLive(_9); - StorageLive(_7); - StorageLive(_15); - StorageLive(_16); - StorageLive(_5); - _5 = (_4.0: usize); + StorageLive(_11); + _5 = &mut _4; + StorageLive(_12); + StorageLive(_10); StorageLive(_6); - _6 = (_4.1: usize); - _7 = Lt(move _5, move _6); - StorageDead(_6); - StorageDead(_5); - switchInt(move _7) -> [0: bb2, otherwise: bb3]; + _6 = &(_4.0: usize); + StorageLive(_7); + _7 = &(_4.1: usize); + StorageLive(_8); + _8 = (_4.0: usize); + StorageLive(_9); + _9 = (_4.1: usize); + _10 = Lt(move _8, move _9); + StorageDead(_9); + StorageDead(_8); + switchInt(move _10) -> [0: bb2, otherwise: bb3]; } bb2: { - StorageDead(_16); - StorageDead(_15); - _8 = Option::::None; + StorageDead(_7); + StorageDead(_6); + _11 = Option::::None; goto -> bb5; } bb3: { - StorageDead(_16); - StorageDead(_15); - _9 = (_4.0: usize); - StorageLive(_10); - _10 = ::forward_unchecked(_9, const 1_usize) -> [return: bb4, unwind continue]; + StorageDead(_7); + StorageDead(_6); + _12 = (_4.0: usize); + StorageLive(_13); + _13 = ::forward_unchecked(_12, const 1_usize) -> [return: bb4, unwind continue]; } bb4: { - (_4.0: usize) = move _10; - StorageDead(_10); - _8 = Option::::Some(_9); + (_4.0: usize) = move _13; + StorageDead(_13); + _11 = Option::::Some(_12); goto -> bb5; } bb5: { - StorageDead(_7); - StorageDead(_9); - _11 = discriminant(_8); - switchInt(move _11) -> [0: bb6, 1: bb7, otherwise: bb9]; + StorageDead(_10); + StorageDead(_12); + _14 = discriminant(_11); + switchInt(move _14) -> [0: bb6, 1: bb7, otherwise: bb9]; } bb6: { - StorageDead(_8); + StorageDead(_11); StorageDead(_4); return; } bb7: { - _12 = ((_8 as Some).0: usize); - _13 = opaque::(move _12) -> [return: bb8, unwind continue]; + _15 = ((_11 as Some).0: usize); + _16 = opaque::(move _15) -> [return: bb8, unwind continue]; } bb8: { - StorageDead(_8); + StorageDead(_11); goto -> bb1; } 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 9664ccfb094..91c3731f492 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 @@ -7,37 +7,37 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { let mut _0: (); let mut _4: std::ops::Range; let mut _5: std::ops::Range; - let mut _9: std::option::Option; - let mut _12: isize; - let mut _14: &impl Fn(u32); - let mut _15: (u32,); - let _16: (); - let mut _17: &mut std::ops::Range; + let mut _6: &mut std::ops::Range; + let mut _12: std::option::Option; + let mut _15: isize; + let mut _17: &impl Fn(u32); + let mut _18: (u32,); + let _19: (); scope 1 { debug iter => _5; - let _13: u32; + let _16: u32; scope 2 { - debug x => _13; + debug x => _16; } scope 4 (inlined iter::range::>::next) { - debug self => _17; + debug self => _6; scope 5 (inlined as iter::range::RangeIteratorImpl>::spec_next) { - debug self => _17; - let mut _8: bool; - let _10: u32; - let mut _11: u32; - let mut _18: &u32; - let mut _19: &u32; + debug self => _6; + let mut _7: &u32; + let mut _8: &u32; + let mut _11: bool; + let _13: u32; + let mut _14: u32; scope 6 { - debug old => _10; + debug old => _13; scope 7 { } } scope 8 (inlined cmp::impls::::lt) { - debug self => _18; - debug other => _19; - let mut _6: u32; - let mut _7: u32; + debug self => _7; + debug other => _8; + let mut _9: u32; + let mut _10: u32; } } } @@ -54,52 +54,55 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { } bb1: { - StorageLive(_9); - StorageLive(_10); - StorageLive(_8); - StorageLive(_18); - StorageLive(_19); - StorageLive(_6); - _6 = (_5.0: u32); + StorageLive(_12); + _6 = &mut _5; + StorageLive(_13); + StorageLive(_11); StorageLive(_7); - _7 = (_5.1: u32); - _8 = Lt(move _6, move _7); - StorageDead(_7); - StorageDead(_6); - switchInt(move _8) -> [0: bb2, otherwise: bb3]; + _7 = &(_5.0: u32); + StorageLive(_8); + _8 = &(_5.1: u32); + StorageLive(_9); + _9 = (_5.0: u32); + StorageLive(_10); + _10 = (_5.1: u32); + _11 = Lt(move _9, move _10); + StorageDead(_10); + StorageDead(_9); + switchInt(move _11) -> [0: bb2, otherwise: bb3]; } bb2: { - StorageDead(_19); - StorageDead(_18); - _9 = Option::::None; + StorageDead(_8); + StorageDead(_7); + _12 = Option::::None; goto -> bb5; } bb3: { - StorageDead(_19); - StorageDead(_18); - _10 = (_5.0: u32); - StorageLive(_11); - _11 = ::forward_unchecked(_10, const 1_usize) -> [return: bb4, unwind unreachable]; + StorageDead(_8); + StorageDead(_7); + _13 = (_5.0: u32); + StorageLive(_14); + _14 = ::forward_unchecked(_13, const 1_usize) -> [return: bb4, unwind unreachable]; } bb4: { - (_5.0: u32) = move _11; - StorageDead(_11); - _9 = Option::::Some(_10); + (_5.0: u32) = move _14; + StorageDead(_14); + _12 = Option::::Some(_13); goto -> bb5; } bb5: { - StorageDead(_8); - StorageDead(_10); - _12 = discriminant(_9); - switchInt(move _12) -> [0: bb6, 1: bb8, otherwise: bb10]; + StorageDead(_11); + StorageDead(_13); + _15 = discriminant(_12); + switchInt(move _15) -> [0: bb6, 1: bb8, otherwise: bb10]; } bb6: { - StorageDead(_9); + StorageDead(_12); StorageDead(_5); drop(_3) -> [return: bb7, unwind unreachable]; } @@ -109,18 +112,18 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { } bb8: { - _13 = ((_9 as Some).0: u32); - StorageLive(_14); - _14 = &_3; - StorageLive(_15); - _15 = (_13,); - _16 = >::call(move _14, move _15) -> [return: bb9, unwind unreachable]; + _16 = ((_12 as Some).0: u32); + StorageLive(_17); + _17 = &_3; + StorageLive(_18); + _18 = (_16,); + _19 = >::call(move _17, move _18) -> [return: bb9, unwind unreachable]; } bb9: { - StorageDead(_15); - StorageDead(_14); - StorageDead(_9); + StorageDead(_18); + StorageDead(_17); + StorageDead(_12); 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 dc8b46b6c08..f76de02c9d1 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 @@ -7,37 +7,37 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { let mut _0: (); let mut _4: std::ops::Range; let mut _5: std::ops::Range; - let mut _9: std::option::Option; - let mut _12: isize; - let mut _14: &impl Fn(u32); - let mut _15: (u32,); - let _16: (); - let mut _17: &mut std::ops::Range; + let mut _6: &mut std::ops::Range; + let mut _12: std::option::Option; + let mut _15: isize; + let mut _17: &impl Fn(u32); + let mut _18: (u32,); + let _19: (); scope 1 { debug iter => _5; - let _13: u32; + let _16: u32; scope 2 { - debug x => _13; + debug x => _16; } scope 4 (inlined iter::range::>::next) { - debug self => _17; + debug self => _6; scope 5 (inlined as iter::range::RangeIteratorImpl>::spec_next) { - debug self => _17; - let mut _8: bool; - let _10: u32; - let mut _11: u32; - let mut _18: &u32; - let mut _19: &u32; + debug self => _6; + let mut _7: &u32; + let mut _8: &u32; + let mut _11: bool; + let _13: u32; + let mut _14: u32; scope 6 { - debug old => _10; + debug old => _13; scope 7 { } } scope 8 (inlined cmp::impls::::lt) { - debug self => _18; - debug other => _19; - let mut _6: u32; - let mut _7: u32; + debug self => _7; + debug other => _8; + let mut _9: u32; + let mut _10: u32; } } } @@ -54,52 +54,55 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { } bb1: { - StorageLive(_9); - StorageLive(_10); - StorageLive(_8); - StorageLive(_18); - StorageLive(_19); - StorageLive(_6); - _6 = (_5.0: u32); + StorageLive(_12); + _6 = &mut _5; + StorageLive(_13); + StorageLive(_11); StorageLive(_7); - _7 = (_5.1: u32); - _8 = Lt(move _6, move _7); - StorageDead(_7); - StorageDead(_6); - switchInt(move _8) -> [0: bb2, otherwise: bb3]; + _7 = &(_5.0: u32); + StorageLive(_8); + _8 = &(_5.1: u32); + StorageLive(_9); + _9 = (_5.0: u32); + StorageLive(_10); + _10 = (_5.1: u32); + _11 = Lt(move _9, move _10); + StorageDead(_10); + StorageDead(_9); + switchInt(move _11) -> [0: bb2, otherwise: bb3]; } bb2: { - StorageDead(_19); - StorageDead(_18); - _9 = Option::::None; + StorageDead(_8); + StorageDead(_7); + _12 = Option::::None; goto -> bb5; } bb3: { - StorageDead(_19); - StorageDead(_18); - _10 = (_5.0: u32); - StorageLive(_11); - _11 = ::forward_unchecked(_10, const 1_usize) -> [return: bb4, unwind: bb11]; + StorageDead(_8); + StorageDead(_7); + _13 = (_5.0: u32); + StorageLive(_14); + _14 = ::forward_unchecked(_13, const 1_usize) -> [return: bb4, unwind: bb11]; } bb4: { - (_5.0: u32) = move _11; - StorageDead(_11); - _9 = Option::::Some(_10); + (_5.0: u32) = move _14; + StorageDead(_14); + _12 = Option::::Some(_13); goto -> bb5; } bb5: { - StorageDead(_8); - StorageDead(_10); - _12 = discriminant(_9); - switchInt(move _12) -> [0: bb6, 1: bb8, otherwise: bb10]; + StorageDead(_11); + StorageDead(_13); + _15 = discriminant(_12); + switchInt(move _15) -> [0: bb6, 1: bb8, otherwise: bb10]; } bb6: { - StorageDead(_9); + StorageDead(_12); StorageDead(_5); drop(_3) -> [return: bb7, unwind continue]; } @@ -109,18 +112,18 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { } bb8: { - _13 = ((_9 as Some).0: u32); - StorageLive(_14); - _14 = &_3; - StorageLive(_15); - _15 = (_13,); - _16 = >::call(move _14, move _15) -> [return: bb9, unwind: bb11]; + _16 = ((_12 as Some).0: u32); + StorageLive(_17); + _17 = &_3; + StorageLive(_18); + _18 = (_16,); + _19 = >::call(move _17, move _18) -> [return: bb9, unwind: bb11]; } bb9: { - StorageDead(_15); - StorageDead(_14); - StorageDead(_9); + StorageDead(_18); + StorageDead(_17); + StorageDead(_12); 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 fff713b5a79..a7824f36d50 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 @@ -7,65 +7,67 @@ fn range_iter_next(_1: &mut std::ops::Range) -> Option { debug self => _1; scope 2 (inlined as iter::range::RangeIteratorImpl>::spec_next) { debug self => _1; - let mut _4: bool; - let _5: u32; - let mut _6: u32; - let mut _7: &u32; - let mut _8: &u32; + let mut _2: &u32; + let mut _3: &u32; + let mut _6: bool; + let _7: u32; + let mut _8: u32; scope 3 { - debug old => _5; + debug old => _7; scope 4 { } } scope 5 (inlined cmp::impls::::lt) { - debug self => _7; - debug other => _8; - let mut _2: u32; - let mut _3: u32; + debug self => _2; + debug other => _3; + let mut _4: u32; + let mut _5: u32; } } } bb0: { - StorageLive(_5); - StorageLive(_4); StorageLive(_7); - StorageLive(_8); + StorageLive(_6); StorageLive(_2); - _2 = ((*_1).0: u32); + _2 = &((*_1).0: u32); StorageLive(_3); - _3 = ((*_1).1: u32); - _4 = Lt(move _2, move _3); - StorageDead(_3); - StorageDead(_2); - switchInt(move _4) -> [0: bb1, otherwise: bb2]; + _3 = &((*_1).1: u32); + StorageLive(_4); + _4 = ((*_1).0: u32); + StorageLive(_5); + _5 = ((*_1).1: u32); + _6 = Lt(move _4, move _5); + StorageDead(_5); + StorageDead(_4); + switchInt(move _6) -> [0: bb1, otherwise: bb2]; } bb1: { - StorageDead(_8); - StorageDead(_7); + StorageDead(_3); + StorageDead(_2); _0 = Option::::None; goto -> bb4; } bb2: { - StorageDead(_8); - StorageDead(_7); - _5 = ((*_1).0: u32); - StorageLive(_6); - _6 = ::forward_unchecked(_5, const 1_usize) -> [return: bb3, unwind unreachable]; + StorageDead(_3); + StorageDead(_2); + _7 = ((*_1).0: u32); + StorageLive(_8); + _8 = ::forward_unchecked(_7, const 1_usize) -> [return: bb3, unwind unreachable]; } bb3: { - ((*_1).0: u32) = move _6; - StorageDead(_6); - _0 = Option::::Some(_5); + ((*_1).0: u32) = move _8; + StorageDead(_8); + _0 = Option::::Some(_7); goto -> bb4; } bb4: { - StorageDead(_4); - StorageDead(_5); + StorageDead(_6); + StorageDead(_7); 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 cc12c0122b7..83c9e6c1af2 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 @@ -7,65 +7,67 @@ fn range_iter_next(_1: &mut std::ops::Range) -> Option { debug self => _1; scope 2 (inlined as iter::range::RangeIteratorImpl>::spec_next) { debug self => _1; - let mut _4: bool; - let _5: u32; - let mut _6: u32; - let mut _7: &u32; - let mut _8: &u32; + let mut _2: &u32; + let mut _3: &u32; + let mut _6: bool; + let _7: u32; + let mut _8: u32; scope 3 { - debug old => _5; + debug old => _7; scope 4 { } } scope 5 (inlined cmp::impls::::lt) { - debug self => _7; - debug other => _8; - let mut _2: u32; - let mut _3: u32; + debug self => _2; + debug other => _3; + let mut _4: u32; + let mut _5: u32; } } } bb0: { - StorageLive(_5); - StorageLive(_4); StorageLive(_7); - StorageLive(_8); + StorageLive(_6); StorageLive(_2); - _2 = ((*_1).0: u32); + _2 = &((*_1).0: u32); StorageLive(_3); - _3 = ((*_1).1: u32); - _4 = Lt(move _2, move _3); - StorageDead(_3); - StorageDead(_2); - switchInt(move _4) -> [0: bb1, otherwise: bb2]; + _3 = &((*_1).1: u32); + StorageLive(_4); + _4 = ((*_1).0: u32); + StorageLive(_5); + _5 = ((*_1).1: u32); + _6 = Lt(move _4, move _5); + StorageDead(_5); + StorageDead(_4); + switchInt(move _6) -> [0: bb1, otherwise: bb2]; } bb1: { - StorageDead(_8); - StorageDead(_7); + StorageDead(_3); + StorageDead(_2); _0 = Option::::None; goto -> bb4; } bb2: { - StorageDead(_8); - StorageDead(_7); - _5 = ((*_1).0: u32); - StorageLive(_6); - _6 = ::forward_unchecked(_5, const 1_usize) -> [return: bb3, unwind continue]; + StorageDead(_3); + StorageDead(_2); + _7 = ((*_1).0: u32); + StorageLive(_8); + _8 = ::forward_unchecked(_7, const 1_usize) -> [return: bb3, unwind continue]; } bb3: { - ((*_1).0: u32) = move _6; - StorageDead(_6); - _0 = Option::::Some(_5); + ((*_1).0: u32) = move _8; + StorageDead(_8); + _0 = Option::::Some(_7); goto -> bb4; } bb4: { - StorageDead(_4); - StorageDead(_5); + StorageDead(_6); + StorageDead(_7); return; } } 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 9c10e96b0ea..b35d3a105ba 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 @@ -10,74 +10,74 @@ fn variant_a::{closure#0}(_1: &mut {closure@$DIR/slice_filter.rs:7:25: 7:39}, _2 let _8: &usize; let mut _9: &(usize, usize, usize, usize); let _10: &usize; - let _11: &usize; - let mut _16: bool; - let _17: &usize; - let mut _22: bool; - let _23: &usize; - let mut _28: bool; - let _29: &usize; - let mut _34: &&usize; + let mut _11: &&usize; + let _12: &usize; + let mut _13: &&usize; + let mut _18: bool; + let mut _19: &&usize; + let _20: &usize; + let mut _21: &&usize; + let mut _26: bool; + let mut _27: &&usize; + let _28: &usize; + let mut _29: &&usize; + let mut _34: bool; let mut _35: &&usize; - let mut _36: &&usize; + let _36: &usize; let mut _37: &&usize; - let mut _38: &&usize; - let mut _39: &&usize; - let mut _40: &&usize; - let mut _41: &&usize; scope 1 { debug a => _4; debug b => _6; debug c => _8; debug d => _10; scope 2 (inlined cmp::impls::::le) { - debug self => _34; - debug other => _35; - let mut _12: &usize; - let mut _13: &usize; + debug self => _11; + debug other => _13; + let mut _14: &usize; + let mut _15: &usize; scope 3 (inlined cmp::impls::::le) { - debug self => _12; - debug other => _13; - let mut _14: usize; - let mut _15: usize; + debug self => _14; + debug other => _15; + let mut _16: usize; + let mut _17: usize; } } scope 4 (inlined cmp::impls::::le) { - debug self => _36; - debug other => _37; - let mut _18: &usize; - let mut _19: &usize; + debug self => _19; + debug other => _21; + let mut _22: &usize; + let mut _23: &usize; scope 5 (inlined cmp::impls::::le) { - debug self => _18; - debug other => _19; - let mut _20: usize; - let mut _21: usize; + debug self => _22; + debug other => _23; + let mut _24: usize; + let mut _25: usize; } } scope 6 (inlined cmp::impls::::le) { - debug self => _38; - debug other => _39; - let mut _24: &usize; - let mut _25: &usize; - scope 7 (inlined cmp::impls::::le) { - debug self => _24; - debug other => _25; - let mut _26: usize; - let mut _27: usize; - } - } - scope 8 (inlined cmp::impls::::le) { - debug self => _40; - debug other => _41; + debug self => _27; + debug other => _29; let mut _30: &usize; let mut _31: &usize; - scope 9 (inlined cmp::impls::::le) { + scope 7 (inlined cmp::impls::::le) { debug self => _30; debug other => _31; let mut _32: usize; let mut _33: usize; } } + scope 8 (inlined cmp::impls::::le) { + debug self => _35; + debug other => _37; + let mut _38: &usize; + let mut _39: &usize; + scope 9 (inlined cmp::impls::::le) { + debug self => _38; + debug other => _39; + let mut _40: usize; + let mut _41: usize; + } + } } bb0: { @@ -93,139 +93,147 @@ fn variant_a::{closure#0}(_1: &mut {closure@$DIR/slice_filter.rs:7:25: 7:39}, _2 StorageLive(_10); _9 = deref_copy (*_2); _10 = &((*_9).3: usize); - StorageLive(_16); - StorageLive(_34); - StorageLive(_35); + StorageLive(_18); StorageLive(_11); - _11 = _8; - StorageLive(_12); + _11 = &_4; StorageLive(_13); - _12 = deref_copy _4; - _13 = deref_copy _11; + StorageLive(_12); + _12 = _8; + _13 = &_12; StorageLive(_14); - _14 = (*_12); StorageLive(_15); - _15 = (*_13); - _16 = Le(move _14, move _15); + _14 = deref_copy _4; + _15 = deref_copy _12; + StorageLive(_16); + _16 = (*_14); + StorageLive(_17); + _17 = (*_15); + _18 = Le(move _16, move _17); + StorageDead(_17); + StorageDead(_16); StorageDead(_15); StorageDead(_14); - StorageDead(_13); - StorageDead(_12); - switchInt(move _16) -> [0: bb1, otherwise: bb2]; + switchInt(move _18) -> [0: bb1, otherwise: bb2]; } bb1: { + StorageDead(_12); + StorageDead(_13); StorageDead(_11); - StorageDead(_35); - StorageDead(_34); goto -> bb4; } bb2: { + StorageDead(_12); + StorageDead(_13); StorageDead(_11); - StorageDead(_35); - StorageDead(_34); - StorageLive(_22); - StorageLive(_36); - StorageLive(_37); - StorageLive(_17); - _17 = _6; - StorageLive(_18); + StorageLive(_26); StorageLive(_19); - _18 = deref_copy _10; - _19 = deref_copy _17; - StorageLive(_20); - _20 = (*_18); + _19 = &_10; StorageLive(_21); - _21 = (*_19); - _22 = Le(move _20, move _21); - StorageDead(_21); - StorageDead(_20); - StorageDead(_19); - StorageDead(_18); - switchInt(move _22) -> [0: bb3, otherwise: bb8]; + StorageLive(_20); + _20 = _6; + _21 = &_20; + StorageLive(_22); + StorageLive(_23); + _22 = deref_copy _10; + _23 = deref_copy _20; + StorageLive(_24); + _24 = (*_22); + StorageLive(_25); + _25 = (*_23); + _26 = Le(move _24, move _25); + StorageDead(_25); + StorageDead(_24); + StorageDead(_23); + StorageDead(_22); + switchInt(move _26) -> [0: bb3, otherwise: bb8]; } bb3: { - StorageDead(_17); - StorageDead(_37); - StorageDead(_36); + StorageDead(_20); + StorageDead(_21); + StorageDead(_19); goto -> bb4; } bb4: { - StorageLive(_28); - StorageLive(_38); - StorageLive(_39); - StorageLive(_23); - _23 = _4; - StorageLive(_24); - StorageLive(_25); - _24 = deref_copy _8; - _25 = deref_copy _23; - StorageLive(_26); - _26 = (*_24); + StorageLive(_34); StorageLive(_27); - _27 = (*_25); - _28 = Le(move _26, move _27); - StorageDead(_27); - StorageDead(_26); - StorageDead(_25); - StorageDead(_24); - switchInt(move _28) -> [0: bb5, otherwise: bb6]; + _27 = &_8; + StorageLive(_29); + StorageLive(_28); + _28 = _4; + _29 = &_28; + StorageLive(_30); + StorageLive(_31); + _30 = deref_copy _8; + _31 = deref_copy _28; + StorageLive(_32); + _32 = (*_30); + StorageLive(_33); + _33 = (*_31); + _34 = Le(move _32, move _33); + StorageDead(_33); + StorageDead(_32); + StorageDead(_31); + StorageDead(_30); + switchInt(move _34) -> [0: bb5, otherwise: bb6]; } bb5: { - StorageDead(_23); - StorageDead(_39); - StorageDead(_38); + StorageDead(_28); + StorageDead(_29); + StorageDead(_27); _0 = const false; goto -> bb7; } bb6: { - StorageDead(_23); - StorageDead(_39); - StorageDead(_38); - StorageLive(_40); - StorageLive(_41); - StorageLive(_29); - _29 = _10; - StorageLive(_30); - StorageLive(_31); - _30 = deref_copy _6; - _31 = deref_copy _29; - StorageLive(_32); - _32 = (*_30); - StorageLive(_33); - _33 = (*_31); - _0 = Le(move _32, move _33); - StorageDead(_33); - StorageDead(_32); - StorageDead(_31); - StorageDead(_30); + StorageDead(_28); StorageDead(_29); + StorageDead(_27); + StorageLive(_35); + _35 = &_6; + StorageLive(_37); + StorageLive(_36); + _36 = _10; + _37 = &_36; + StorageLive(_38); + StorageLive(_39); + _38 = deref_copy _6; + _39 = deref_copy _36; + StorageLive(_40); + _40 = (*_38); + StorageLive(_41); + _41 = (*_39); + _0 = Le(move _40, move _41); StorageDead(_41); StorageDead(_40); + StorageDead(_39); + StorageDead(_38); + StorageDead(_36); + StorageDead(_37); + StorageDead(_35); goto -> bb7; } bb7: { - StorageDead(_28); + StorageDead(_34); goto -> bb9; } bb8: { - StorageDead(_17); - StorageDead(_37); - StorageDead(_36); + StorageDead(_20); + StorageDead(_21); + StorageDead(_19); _0 = const true; goto -> bb9; } bb9: { - StorageDead(_22); - StorageDead(_16); + StorageDead(_26); + StorageDead(_18); StorageDead(_10); StorageDead(_8); StorageDead(_6); 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 2fd669aeeb6..729841ec5ea 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 @@ -19,11 +19,9 @@ fn slice_get_unchecked_mut_range(_1: &mut [u32], _2: std::ops::Range) -> debug slice => _5; let mut _7: *mut u32; let mut _8: *mut u32; - let _15: usize; - let _16: usize; scope 4 { - debug ((this: std::ops::Range).0: usize) => _15; - debug ((this: std::ops::Range).1: usize) => _16; + debug ((this: std::ops::Range).0: usize) => _3; + debug ((this: std::ops::Range).1: usize) => _4; scope 5 { let _6: usize; scope 6 { @@ -56,8 +54,8 @@ fn slice_get_unchecked_mut_range(_1: &mut [u32], _2: std::ops::Range) -> } } scope 7 (inlined as SliceIndex<[T]>>::get_unchecked_mut::runtime::) { - debug ((this: std::ops::Range).0: usize) => _15; - debug ((this: std::ops::Range).1: usize) => _16; + debug ((this: std::ops::Range).0: usize) => _3; + debug ((this: std::ops::Range).1: usize) => _4; debug slice => _5; scope 8 (inlined ptr::mut_ptr::::len) { debug self => _5; @@ -82,8 +80,6 @@ fn slice_get_unchecked_mut_range(_1: &mut [u32], _2: std::ops::Range) -> _5 = &raw mut (*_1); StorageLive(_6); StorageLive(_14); - StorageLive(_15); - StorageLive(_16); _6 = SubUnchecked(_4, _3); StorageLive(_8); StorageLive(_7); @@ -104,8 +100,6 @@ fn slice_get_unchecked_mut_range(_1: &mut [u32], _2: std::ops::Range) -> StorageDead(_12); StorageDead(_9); StorageDead(_8); - StorageDead(_16); - StorageDead(_15); StorageDead(_14); StorageDead(_6); StorageDead(_5); 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 2fd669aeeb6..729841ec5ea 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 @@ -19,11 +19,9 @@ fn slice_get_unchecked_mut_range(_1: &mut [u32], _2: std::ops::Range) -> debug slice => _5; let mut _7: *mut u32; let mut _8: *mut u32; - let _15: usize; - let _16: usize; scope 4 { - debug ((this: std::ops::Range).0: usize) => _15; - debug ((this: std::ops::Range).1: usize) => _16; + debug ((this: std::ops::Range).0: usize) => _3; + debug ((this: std::ops::Range).1: usize) => _4; scope 5 { let _6: usize; scope 6 { @@ -56,8 +54,8 @@ fn slice_get_unchecked_mut_range(_1: &mut [u32], _2: std::ops::Range) -> } } scope 7 (inlined as SliceIndex<[T]>>::get_unchecked_mut::runtime::) { - debug ((this: std::ops::Range).0: usize) => _15; - debug ((this: std::ops::Range).1: usize) => _16; + debug ((this: std::ops::Range).0: usize) => _3; + debug ((this: std::ops::Range).1: usize) => _4; debug slice => _5; scope 8 (inlined ptr::mut_ptr::::len) { debug self => _5; @@ -82,8 +80,6 @@ fn slice_get_unchecked_mut_range(_1: &mut [u32], _2: std::ops::Range) -> _5 = &raw mut (*_1); StorageLive(_6); StorageLive(_14); - StorageLive(_15); - StorageLive(_16); _6 = SubUnchecked(_4, _3); StorageLive(_8); StorageLive(_7); @@ -104,8 +100,6 @@ fn slice_get_unchecked_mut_range(_1: &mut [u32], _2: std::ops::Range) -> StorageDead(_12); StorageDead(_9); StorageDead(_8); - StorageDead(_16); - StorageDead(_15); StorageDead(_14); StorageDead(_6); StorageDead(_5); diff --git a/tests/mir-opt/pre-codegen/slice_iter.range_loop.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/slice_iter.range_loop.PreCodegen.after.panic-abort.mir index 4afe2eda188..ac1de7b4c90 100644 --- a/tests/mir-opt/pre-codegen/slice_iter.range_loop.PreCodegen.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/slice_iter.range_loop.PreCodegen.after.panic-abort.mir @@ -7,43 +7,43 @@ fn range_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () { let mut _3: usize; let mut _4: std::ops::Range; let mut _5: std::ops::Range; - let mut _9: std::option::Option; - let mut _12: isize; - let mut _14: usize; - let mut _15: bool; - let mut _17: &impl Fn(usize, &T); - let mut _18: (usize, &T); - let _19: (); - let mut _20: &mut std::ops::Range; + let mut _6: &mut std::ops::Range; + let mut _12: std::option::Option; + let mut _15: isize; + let mut _17: usize; + let mut _18: bool; + let mut _20: &impl Fn(usize, &T); + let mut _21: (usize, &T); + let _22: (); scope 1 { debug iter => _5; - let _13: usize; + let _16: usize; scope 2 { - debug i => _13; - let _16: &T; + debug i => _16; + let _19: &T; scope 3 { - debug x => _16; + debug x => _19; } } scope 5 (inlined iter::range::>::next) { - debug self => _20; + debug self => _6; scope 6 (inlined as iter::range::RangeIteratorImpl>::spec_next) { - debug self => _20; - let mut _8: bool; - let _10: usize; - let mut _11: usize; - let mut _21: &usize; - let mut _22: &usize; + debug self => _6; + let mut _7: &usize; + let mut _8: &usize; + let mut _11: bool; + let _13: usize; + let mut _14: usize; scope 7 { - debug old => _10; + debug old => _13; scope 8 { } } scope 9 (inlined cmp::impls::::lt) { - debug self => _21; - debug other => _22; - let mut _6: usize; - let mut _7: usize; + debug self => _7; + debug other => _8; + let mut _9: usize; + let mut _10: usize; } } } @@ -63,52 +63,55 @@ fn range_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () { } bb1: { - StorageLive(_9); - StorageLive(_10); - StorageLive(_8); - StorageLive(_21); - StorageLive(_22); - StorageLive(_6); - _6 = (_5.0: usize); + StorageLive(_12); + _6 = &mut _5; + StorageLive(_13); + StorageLive(_11); StorageLive(_7); - _7 = (_5.1: usize); - _8 = Lt(move _6, move _7); - StorageDead(_7); - StorageDead(_6); - switchInt(move _8) -> [0: bb2, otherwise: bb3]; + _7 = &(_5.0: usize); + StorageLive(_8); + _8 = &(_5.1: usize); + StorageLive(_9); + _9 = (_5.0: usize); + StorageLive(_10); + _10 = (_5.1: usize); + _11 = Lt(move _9, move _10); + StorageDead(_10); + StorageDead(_9); + switchInt(move _11) -> [0: bb2, otherwise: bb3]; } bb2: { - StorageDead(_22); - StorageDead(_21); - _9 = Option::::None; + StorageDead(_8); + StorageDead(_7); + _12 = Option::::None; goto -> bb5; } bb3: { - StorageDead(_22); - StorageDead(_21); - _10 = (_5.0: usize); - StorageLive(_11); - _11 = ::forward_unchecked(_10, const 1_usize) -> [return: bb4, unwind unreachable]; + StorageDead(_8); + StorageDead(_7); + _13 = (_5.0: usize); + StorageLive(_14); + _14 = ::forward_unchecked(_13, const 1_usize) -> [return: bb4, unwind unreachable]; } bb4: { - (_5.0: usize) = move _11; - StorageDead(_11); - _9 = Option::::Some(_10); + (_5.0: usize) = move _14; + StorageDead(_14); + _12 = Option::::Some(_13); goto -> bb5; } bb5: { - StorageDead(_8); - StorageDead(_10); - _12 = discriminant(_9); - switchInt(move _12) -> [0: bb6, 1: bb8, otherwise: bb11]; + StorageDead(_11); + StorageDead(_13); + _15 = discriminant(_12); + switchInt(move _15) -> [0: bb6, 1: bb8, otherwise: bb11]; } bb6: { - StorageDead(_9); + StorageDead(_12); StorageDead(_5); drop(_2) -> [return: bb7, unwind unreachable]; } @@ -118,25 +121,25 @@ fn range_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () { } bb8: { - _13 = ((_9 as Some).0: usize); - _14 = Len((*_1)); - _15 = Lt(_13, _14); - assert(move _15, "index out of bounds: the length is {} but the index is {}", move _14, _13) -> [success: bb9, unwind unreachable]; + _16 = ((_12 as Some).0: usize); + _17 = Len((*_1)); + _18 = Lt(_16, _17); + assert(move _18, "index out of bounds: the length is {} but the index is {}", move _17, _16) -> [success: bb9, unwind unreachable]; } bb9: { - _16 = &(*_1)[_13]; - StorageLive(_17); - _17 = &_2; - StorageLive(_18); - _18 = (_13, _16); - _19 = >::call(move _17, move _18) -> [return: bb10, unwind unreachable]; + _19 = &(*_1)[_16]; + StorageLive(_20); + _20 = &_2; + StorageLive(_21); + _21 = (_16, _19); + _22 = >::call(move _20, move _21) -> [return: bb10, unwind unreachable]; } bb10: { - StorageDead(_18); - StorageDead(_17); - StorageDead(_9); + StorageDead(_21); + StorageDead(_20); + StorageDead(_12); goto -> bb1; } diff --git a/tests/mir-opt/pre-codegen/slice_iter.range_loop.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/slice_iter.range_loop.PreCodegen.after.panic-unwind.mir index 48092608d9c..3c49ecf95a1 100644 --- a/tests/mir-opt/pre-codegen/slice_iter.range_loop.PreCodegen.after.panic-unwind.mir +++ b/tests/mir-opt/pre-codegen/slice_iter.range_loop.PreCodegen.after.panic-unwind.mir @@ -7,43 +7,43 @@ fn range_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () { let mut _3: usize; let mut _4: std::ops::Range; let mut _5: std::ops::Range; - let mut _9: std::option::Option; - let mut _12: isize; - let mut _14: usize; - let mut _15: bool; - let mut _17: &impl Fn(usize, &T); - let mut _18: (usize, &T); - let _19: (); - let mut _20: &mut std::ops::Range; + let mut _6: &mut std::ops::Range; + let mut _12: std::option::Option; + let mut _15: isize; + let mut _17: usize; + let mut _18: bool; + let mut _20: &impl Fn(usize, &T); + let mut _21: (usize, &T); + let _22: (); scope 1 { debug iter => _5; - let _13: usize; + let _16: usize; scope 2 { - debug i => _13; - let _16: &T; + debug i => _16; + let _19: &T; scope 3 { - debug x => _16; + debug x => _19; } } scope 5 (inlined iter::range::>::next) { - debug self => _20; + debug self => _6; scope 6 (inlined as iter::range::RangeIteratorImpl>::spec_next) { - debug self => _20; - let mut _8: bool; - let _10: usize; - let mut _11: usize; - let mut _21: &usize; - let mut _22: &usize; + debug self => _6; + let mut _7: &usize; + let mut _8: &usize; + let mut _11: bool; + let _13: usize; + let mut _14: usize; scope 7 { - debug old => _10; + debug old => _13; scope 8 { } } scope 9 (inlined cmp::impls::::lt) { - debug self => _21; - debug other => _22; - let mut _6: usize; - let mut _7: usize; + debug self => _7; + debug other => _8; + let mut _9: usize; + let mut _10: usize; } } } @@ -63,52 +63,55 @@ fn range_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () { } bb1: { - StorageLive(_9); - StorageLive(_10); - StorageLive(_8); - StorageLive(_21); - StorageLive(_22); - StorageLive(_6); - _6 = (_5.0: usize); + StorageLive(_12); + _6 = &mut _5; + StorageLive(_13); + StorageLive(_11); StorageLive(_7); - _7 = (_5.1: usize); - _8 = Lt(move _6, move _7); - StorageDead(_7); - StorageDead(_6); - switchInt(move _8) -> [0: bb2, otherwise: bb3]; + _7 = &(_5.0: usize); + StorageLive(_8); + _8 = &(_5.1: usize); + StorageLive(_9); + _9 = (_5.0: usize); + StorageLive(_10); + _10 = (_5.1: usize); + _11 = Lt(move _9, move _10); + StorageDead(_10); + StorageDead(_9); + switchInt(move _11) -> [0: bb2, otherwise: bb3]; } bb2: { - StorageDead(_22); - StorageDead(_21); - _9 = Option::::None; + StorageDead(_8); + StorageDead(_7); + _12 = Option::::None; goto -> bb5; } bb3: { - StorageDead(_22); - StorageDead(_21); - _10 = (_5.0: usize); - StorageLive(_11); - _11 = ::forward_unchecked(_10, const 1_usize) -> [return: bb4, unwind: bb12]; + StorageDead(_8); + StorageDead(_7); + _13 = (_5.0: usize); + StorageLive(_14); + _14 = ::forward_unchecked(_13, const 1_usize) -> [return: bb4, unwind: bb12]; } bb4: { - (_5.0: usize) = move _11; - StorageDead(_11); - _9 = Option::::Some(_10); + (_5.0: usize) = move _14; + StorageDead(_14); + _12 = Option::::Some(_13); goto -> bb5; } bb5: { - StorageDead(_8); - StorageDead(_10); - _12 = discriminant(_9); - switchInt(move _12) -> [0: bb6, 1: bb8, otherwise: bb11]; + StorageDead(_11); + StorageDead(_13); + _15 = discriminant(_12); + switchInt(move _15) -> [0: bb6, 1: bb8, otherwise: bb11]; } bb6: { - StorageDead(_9); + StorageDead(_12); StorageDead(_5); drop(_2) -> [return: bb7, unwind continue]; } @@ -118,25 +121,25 @@ fn range_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () { } bb8: { - _13 = ((_9 as Some).0: usize); - _14 = Len((*_1)); - _15 = Lt(_13, _14); - assert(move _15, "index out of bounds: the length is {} but the index is {}", move _14, _13) -> [success: bb9, unwind: bb12]; + _16 = ((_12 as Some).0: usize); + _17 = Len((*_1)); + _18 = Lt(_16, _17); + assert(move _18, "index out of bounds: the length is {} but the index is {}", move _17, _16) -> [success: bb9, unwind: bb12]; } bb9: { - _16 = &(*_1)[_13]; - StorageLive(_17); - _17 = &_2; - StorageLive(_18); - _18 = (_13, _16); - _19 = >::call(move _17, move _18) -> [return: bb10, unwind: bb12]; + _19 = &(*_1)[_16]; + StorageLive(_20); + _20 = &_2; + StorageLive(_21); + _21 = (_16, _19); + _22 = >::call(move _20, move _21) -> [return: bb10, unwind: bb12]; } bb10: { - StorageDead(_18); - StorageDead(_17); - StorageDead(_9); + StorageDead(_21); + StorageDead(_20); + StorageDead(_12); goto -> bb1; } diff --git a/tests/mir-opt/pre-codegen/slice_iter.reverse_loop.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/slice_iter.reverse_loop.PreCodegen.after.panic-abort.mir index 549cb4f46a0..f3760463fe0 100644 --- a/tests/mir-opt/pre-codegen/slice_iter.reverse_loop.PreCodegen.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/slice_iter.reverse_loop.PreCodegen.after.panic-abort.mir @@ -7,21 +7,21 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () { let mut _13: std::slice::Iter<'_, T>; let mut _14: std::iter::Rev>; let mut _15: std::iter::Rev>; - let mut _17: std::option::Option<&T>; - let mut _18: isize; - let mut _20: &impl Fn(&T); - let mut _21: (&T,); - let _22: (); - let mut _23: &mut std::iter::Rev>; + let mut _16: &mut std::iter::Rev>; + let mut _18: std::option::Option<&T>; + let mut _19: isize; + let mut _21: &impl Fn(&T); + let mut _22: (&T,); + let _23: (); scope 1 { debug iter => _15; - let _19: &T; + let _20: &T; scope 2 { - debug x => _19; + debug x => _20; } scope 25 (inlined > as Iterator>::next) { - debug self => _23; - let mut _16: &mut std::slice::Iter<'_, T>; + debug self => _16; + let mut _17: &mut std::slice::Iter<'_, T>; } } scope 3 (inlined core::slice::::iter) { @@ -153,20 +153,21 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () { } bb4: { + StorageLive(_18); + _16 = &mut _15; StorageLive(_17); - StorageLive(_16); - _16 = &mut (_15.0: std::slice::Iter<'_, T>); - _17 = as DoubleEndedIterator>::next_back(move _16) -> [return: bb5, unwind unreachable]; + _17 = &mut (_15.0: std::slice::Iter<'_, T>); + _18 = as DoubleEndedIterator>::next_back(move _17) -> [return: bb5, unwind unreachable]; } bb5: { - StorageDead(_16); - _18 = discriminant(_17); - switchInt(move _18) -> [0: bb6, 1: bb8, otherwise: bb10]; + StorageDead(_17); + _19 = discriminant(_18); + switchInt(move _19) -> [0: bb6, 1: bb8, otherwise: bb10]; } bb6: { - StorageDead(_17); + StorageDead(_18); StorageDead(_15); drop(_2) -> [return: bb7, unwind unreachable]; } @@ -176,18 +177,18 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () { } bb8: { - _19 = ((_17 as Some).0: &T); - StorageLive(_20); - _20 = &_2; + _20 = ((_18 as Some).0: &T); StorageLive(_21); - _21 = (_19,); - _22 = >::call(move _20, move _21) -> [return: bb9, unwind unreachable]; + _21 = &_2; + StorageLive(_22); + _22 = (_20,); + _23 = >::call(move _21, move _22) -> [return: bb9, unwind unreachable]; } bb9: { + StorageDead(_22); StorageDead(_21); - StorageDead(_20); - StorageDead(_17); + StorageDead(_18); goto -> bb4; } diff --git a/tests/mir-opt/pre-codegen/slice_iter.reverse_loop.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/slice_iter.reverse_loop.PreCodegen.after.panic-unwind.mir index 3cdc49f6056..e63f8b89308 100644 --- a/tests/mir-opt/pre-codegen/slice_iter.reverse_loop.PreCodegen.after.panic-unwind.mir +++ b/tests/mir-opt/pre-codegen/slice_iter.reverse_loop.PreCodegen.after.panic-unwind.mir @@ -7,21 +7,21 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () { let mut _13: std::slice::Iter<'_, T>; let mut _14: std::iter::Rev>; let mut _15: std::iter::Rev>; - let mut _17: std::option::Option<&T>; - let mut _18: isize; - let mut _20: &impl Fn(&T); - let mut _21: (&T,); - let _22: (); - let mut _23: &mut std::iter::Rev>; + let mut _16: &mut std::iter::Rev>; + let mut _18: std::option::Option<&T>; + let mut _19: isize; + let mut _21: &impl Fn(&T); + let mut _22: (&T,); + let _23: (); scope 1 { debug iter => _15; - let _19: &T; + let _20: &T; scope 2 { - debug x => _19; + debug x => _20; } scope 25 (inlined > as Iterator>::next) { - debug self => _23; - let mut _16: &mut std::slice::Iter<'_, T>; + debug self => _16; + let mut _17: &mut std::slice::Iter<'_, T>; } } scope 3 (inlined core::slice::::iter) { @@ -153,20 +153,21 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () { } bb4: { + StorageLive(_18); + _16 = &mut _15; StorageLive(_17); - StorageLive(_16); - _16 = &mut (_15.0: std::slice::Iter<'_, T>); - _17 = as DoubleEndedIterator>::next_back(move _16) -> [return: bb5, unwind: bb11]; + _17 = &mut (_15.0: std::slice::Iter<'_, T>); + _18 = as DoubleEndedIterator>::next_back(move _17) -> [return: bb5, unwind: bb11]; } bb5: { - StorageDead(_16); - _18 = discriminant(_17); - switchInt(move _18) -> [0: bb6, 1: bb8, otherwise: bb10]; + StorageDead(_17); + _19 = discriminant(_18); + switchInt(move _19) -> [0: bb6, 1: bb8, otherwise: bb10]; } bb6: { - StorageDead(_17); + StorageDead(_18); StorageDead(_15); drop(_2) -> [return: bb7, unwind continue]; } @@ -176,18 +177,18 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () { } bb8: { - _19 = ((_17 as Some).0: &T); - StorageLive(_20); - _20 = &_2; + _20 = ((_18 as Some).0: &T); StorageLive(_21); - _21 = (_19,); - _22 = >::call(move _20, move _21) -> [return: bb9, unwind: bb11]; + _21 = &_2; + StorageLive(_22); + _22 = (_20,); + _23 = >::call(move _21, move _22) -> [return: bb9, unwind: bb11]; } bb9: { + StorageDead(_22); StorageDead(_21); - StorageDead(_20); - StorageDead(_17); + StorageDead(_18); goto -> bb4; }