diff --git a/compiler/rustc_mir_transform/src/dest_prop.rs b/compiler/rustc_mir_transform/src/dest_prop.rs index f6c5ae1e43f60..3bb7ce9c3d6c0 100644 --- a/compiler/rustc_mir_transform/src/dest_prop.rs +++ b/compiler/rustc_mir_transform/src/dest_prop.rs @@ -141,7 +141,10 @@ use rustc_data_structures::union_find::UnionFind; use rustc_index::bit_set::DenseBitSet; use rustc_index::interval::SparseIntervalMatrix; use rustc_index::{IndexVec, newtype_index}; -use rustc_middle::mir::visit::{MutVisitor, PlaceContext, VisitPlacesWith, Visitor}; +use rustc_middle::mir::visit::{ + MutVisitor, MutatingUseContext, NonMutatingUseContext, NonUseContext, PlaceContext, + VisitPlacesWith, Visitor, +}; use rustc_middle::mir::*; use rustc_middle::ty::TyCtxt; use rustc_mir_dataflow::impls::{DefUse, MaybeLiveLocals}; @@ -149,6 +152,8 @@ use rustc_mir_dataflow::points::DenseLocationMap; use rustc_mir_dataflow::{Analysis, EntryStates, GenKill}; use tracing::{debug, trace}; +use crate::util::most_packed_projection; + pub(super) struct DestinationPropagation; impl<'tcx> crate::MirPass<'tcx> for DestinationPropagation { @@ -163,7 +168,7 @@ impl<'tcx> crate::MirPass<'tcx> for DestinationPropagation { let borrowed = rustc_mir_dataflow::impls::borrowed_locals(body); - let candidates = Candidates::find(body, &borrowed); + let candidates = Candidates::find(tcx, body, &borrowed); trace!(?candidates); if candidates.c.is_empty() { return; @@ -177,60 +182,115 @@ impl<'tcx> crate::MirPass<'tcx> for DestinationPropagation { dest_prop_mir_dump(tcx, body, &points, &live, &relevant); - let mut merged_locals = DenseBitSet::new_empty(body.local_decls.len()); + let mut storage_to_remove = DenseBitSet::new_empty(body.local_decls.len()); + + // Maps locals to the place with which they are unified. When a local maps to another + // local, this behaves as a union-find set, to be queried by `find_targets`. + let mut merged_targets: IndexVec> = + body.local_decls.indices().map(|l| l.into()).collect(); + let find_targets = |merged_targets: &mut IndexVec<_, _>, local| { + let mut place: Place<'tcx> = merged_targets[local]; + while let Some(head) = place.as_local() { + if place == merged_targets[head] { + break; + } + place = merged_targets[head]; + } + merged_targets[local] = place; + trace!("find_targets({local:?}) = {place:?}"); + place + }; + + for (orig_src, orig_dst) in candidates.c.into_iter() { + // We want to replace `src` by `dst`. + trace!(?orig_src, ?orig_dst); - for (src, dst) in candidates.c.into_iter() { - trace!(?src, ?dst); + let mut src_place = find_targets(&mut merged_targets, orig_src); + let mut dst_place = find_targets(&mut merged_targets, orig_dst.local) + .project_deeper(orig_dst.projection, tcx); + trace!(?src_place, ?dst_place); + if src_place == dst_place { + continue; + } - let Some(mut src) = relevant.find(src) else { continue }; - let Some(mut dst) = relevant.find(dst) else { continue }; + let Some(mut src) = relevant.find(orig_src) else { continue }; + let Some(mut dst) = relevant.find(orig_dst.local) else { continue }; if src == dst { continue; } + // We cannot unify a local that appears in an index with a place that has projections. + let src_requires_bare = relevant.requires_bare_local.contains(src); + let dst_requires_bare = relevant.requires_bare_local.contains(dst); + trace!(?src_requires_bare, ?dst_requires_bare); + + if (src_requires_bare || dst_requires_bare) + && (!src_place.projection.is_empty() || !dst_place.projection.is_empty()) + { + debug!("projection in index"); + continue; + } + let Some(src_live_ranges) = live.row(src) else { continue }; let Some(dst_live_ranges) = live.row(dst) else { continue }; trace!(?src, ?src_live_ranges); trace!(?dst, ?dst_live_ranges); if src_live_ranges.disjoint(dst_live_ranges) { - // We want to replace `src` by `dst`. - let mut orig_src = relevant.original[src]; - let mut orig_dst = relevant.original[dst]; + let is_required = |place: Place<'_>| { + is_local_required(place.local, body) || !place.projection.is_empty() + }; // The return place and function arguments are required and cannot be renamed. // This check cannot be made during candidate collection, as we may want to // unify the same non-required local with several required locals. - match (is_local_required(orig_src, body), is_local_required(orig_dst, body)) { + match (is_required(src_place), is_required(dst_place)) { // Renaming `src` is ok. (false, _) => {} // Renaming `src` is wrong, but renaming `dst` is ok. (true, false) => { std::mem::swap(&mut src, &mut dst); - std::mem::swap(&mut orig_src, &mut orig_dst); + std::mem::swap(&mut src_place, &mut dst_place); } // Neither local can be renamed, so skip this case. - (true, true) => continue, + (true, true) => { + debug!(?src_place, ?dst_place, "both required"); + continue; + } } + trace!(?src_place, ?dst_place); + + debug_assert!(src_place.projection.is_empty()); + let src_place = src_place.as_local().unwrap(); - trace!(?src, ?dst, "merge"); - merged_locals.insert(orig_src); - merged_locals.insert(orig_dst); + trace!(?src, ?dst, ?src_place, ?dst_place, "merge"); + storage_to_remove.insert(src_place); + storage_to_remove.insert(dst_place.local); // Replace `src` by `dst`. - let head = relevant.union(src, dst); + merged_targets[src_place] = dst_place; + let head = relevant.renames.unify(src, dst); live.union_rows(/* read */ src, /* write */ head); live.union_rows(/* read */ dst, /* write */ head); + if src_requires_bare || dst_requires_bare { + relevant.requires_bare_local.insert(head); + } } } - trace!(?merged_locals); + trace!(?storage_to_remove); trace!(?relevant.renames); + trace!(?merged_targets); - if merged_locals.is_empty() { + for local in merged_targets.indices() { + let _ = find_targets(&mut merged_targets, local); + } + + trace!(?merged_targets); + if storage_to_remove.is_empty() { return; } - apply_merges(body, tcx, relevant, merged_locals); + apply_merges(body, tcx, storage_to_remove, merged_targets); } fn is_required(&self) -> bool { @@ -246,17 +306,17 @@ impl<'tcx> crate::MirPass<'tcx> for DestinationPropagation { fn apply_merges<'tcx>( body: &mut Body<'tcx>, tcx: TyCtxt<'tcx>, - relevant: RelevantLocals, - merged_locals: DenseBitSet, + storage_to_remove: DenseBitSet, + merged_targets: IndexVec>, ) { - let mut merger = Merger { tcx, relevant, merged_locals }; + let mut merger = Merger { tcx, storage_to_remove, merged_targets }; merger.visit_body_preserves_cfg(body); } struct Merger<'tcx> { tcx: TyCtxt<'tcx>, - relevant: RelevantLocals, - merged_locals: DenseBitSet, + storage_to_remove: DenseBitSet, + merged_targets: IndexVec>, } impl<'tcx> MutVisitor<'tcx> for Merger<'tcx> { @@ -264,17 +324,30 @@ impl<'tcx> MutVisitor<'tcx> for Merger<'tcx> { self.tcx } + #[tracing::instrument(level = "trace", skip(self))] fn visit_local(&mut self, local: &mut Local, _: PlaceContext, _location: Location) { - if let Some(relevant) = self.relevant.find(*local) { - *local = self.relevant.original[relevant]; + let dest = self.merged_targets[*local]; + let Some(dest) = dest.as_local() else { + panic!("{local:?} merged with {dest:?} but used in indexing") + }; + *local = dest; + } + + #[tracing::instrument(level = "trace", skip(self))] + fn visit_place(&mut self, place: &mut Place<'tcx>, _: PlaceContext, location: Location) { + if let Some(new_projection) = self.process_projection(&place.projection, location) { + place.projection = self.tcx.mk_place_elems(&new_projection); } + let dest = self.merged_targets[place.local]; + *place = dest.project_deeper(place.projection, self.tcx); } + #[tracing::instrument(level = "trace", skip(self))] fn visit_statement(&mut self, statement: &mut Statement<'tcx>, location: Location) { match &statement.kind { // FIXME: Don't delete storage statements, but "merge" the storage ranges instead. StatementKind::StorageDead(local) | StatementKind::StorageLive(local) - if self.merged_locals.contains(*local) => + if self.storage_to_remove.contains(*local) => { statement.make_nop(true); } @@ -317,11 +390,12 @@ struct RelevantLocals { original: IndexVec, shrink: IndexVec>, renames: UnionFind, + requires_bare_local: DenseBitSet, } impl RelevantLocals { #[tracing::instrument(level = "trace", skip(candidates, num_locals), ret)] - fn compute(candidates: &Candidates, num_locals: usize) -> RelevantLocals { + fn compute(candidates: &Candidates<'_>, num_locals: usize) -> RelevantLocals { let mut original = IndexVec::with_capacity(candidates.c.len()); let mut shrink = IndexVec::from_elem_n(None, num_locals); @@ -332,11 +406,18 @@ impl RelevantLocals { for &(src, dest) in candidates.c.iter() { declare(src); - declare(dest) + declare(dest.local) + } + + let mut requires_bare_local = DenseBitSet::new_empty(original.len()); + for local in candidates.requires_bare_local.iter() { + if let Some(relevant) = shrink[local] { + requires_bare_local.insert(relevant); + } } let renames = UnionFind::new(original.len()); - RelevantLocals { original, shrink, renames } + RelevantLocals { original, shrink, renames, requires_bare_local } } fn find(&mut self, src: Local) -> Option { @@ -344,20 +425,13 @@ impl RelevantLocals { let src = self.renames.find(src); Some(src) } - - fn union(&mut self, lhs: RelevantLocal, rhs: RelevantLocal) -> RelevantLocal { - let head = self.renames.unify(lhs, rhs); - // We need to ensure we keep the original local of the RHS, as it may be a required local. - self.original[head] = self.original[rhs]; - head - } } ///////////////////////////////////////////////////// // Candidate accumulation -#[derive(Debug, Default)] -struct Candidates { +#[derive(Debug)] +struct Candidates<'tcx> { /// The set of candidates we are considering in this optimization. /// /// Whether a place ends up in the key or the value does not correspond to whether it appears as @@ -370,47 +444,134 @@ struct Candidates { /// /// We will still report that we would like to merge `_1` and `_2` in an attempt to allow us to /// remove that assignment. - c: Vec<(Local, Local)>, + c: Vec<(Local, Place<'tcx>)>, + /// Whether this local must syntactically appear unprojected in MIR. For instance in + /// `PlaceElem::Index`. If that happens, we cannot unify it with a place that has projections. + requires_bare_local: DenseBitSet, } // We first implement some utility functions which we will expose removing candidates according to // different needs. Throughout the liveness filtering, the `candidates` are only ever accessed // through these methods, and not directly. -impl Candidates { +impl<'tcx> Candidates<'tcx> { /// Collects the candidates for merging. /// /// This is responsible for enforcing the first and third bullet point. - fn find(body: &Body<'_>, borrowed: &DenseBitSet) -> Candidates { - let mut visitor = FindAssignments { body, candidates: Default::default(), borrowed }; + fn find( + tcx: TyCtxt<'tcx>, + body: &Body<'tcx>, + borrowed: &DenseBitSet, + ) -> Candidates<'tcx> { + let mut visitor = FindAssignments { + tcx, + body, + candidates: Default::default(), + borrowed, + requires_bare_local: DenseBitSet::new_empty(body.local_decls.len()), + }; visitor.visit_body(body); + let FindAssignments { mut candidates, requires_bare_local, .. } = visitor; + + // Allowing to merge with an arbitrary place creates a lot of candidates. + // Trim the set a little before trying to apply them. + candidates.retain(|&(s, d)| { + let s_required = is_local_required(s, body); + let d_required = is_local_required(d.local, body); + if s_required && d_required { + // We cannot merge locals if both are required. + return false; + } + if !d.projection.is_empty() && (s_required || requires_bare_local.contains(s)) { + // We cannot merge a projection with a local that needs to remain bare. + return false; + } + true + }); + + candidates.sort_by_key(|&(s, d)| (s, d.local, d.projection.len())); - Candidates { c: visitor.candidates } + Candidates { c: candidates, requires_bare_local } } } struct FindAssignments<'a, 'tcx> { + tcx: TyCtxt<'tcx>, body: &'a Body<'tcx>, - candidates: Vec<(Local, Local)>, + candidates: Vec<(Local, Place<'tcx>)>, borrowed: &'a DenseBitSet, + /// Whether this local must syntactically appear unprojected in MIR. For instance in + /// `PlaceElem::Index`. If that happens, we cannot unify it with a place that has projections. + requires_bare_local: DenseBitSet, } impl<'tcx> Visitor<'tcx> for FindAssignments<'_, 'tcx> { - fn visit_statement(&mut self, statement: &Statement<'tcx>, _: Location) { - if let StatementKind::Assign((lhs, Rvalue::Use(Operand::Copy(rhs) | Operand::Move(rhs), _))) = - &statement.kind - && let Some(src) = lhs.as_local() - && let Some(dest) = rhs.as_local() - { + fn visit_local(&mut self, local: Local, context: PlaceContext, _: Location) { + let requires_bare_local = match context { + // This local is the base of a place, with or without a projection. + PlaceContext::MutatingUse(MutatingUseContext::Projection) + | PlaceContext::NonMutatingUse(NonMutatingUseContext::Projection) => false, + // We remove those statements. + PlaceContext::NonUse(NonUseContext::StorageLive | NonUseContext::StorageDead) => false, + // For any other case, consider MIR syntactically requires a bare local. + // This can happen for indexing projections, async yield, return terminators... + _ => true, + }; + if requires_bare_local { + self.requires_bare_local.insert(local); + } + } + + fn visit_place(&mut self, place: &Place<'tcx>, context: PlaceContext, location: Location) { + self.visit_projection(place.as_ref(), context, location); + + // `Deref` can only happen as first projection. + if let Some(ProjectionElem::Deref) = place.projection.first() { + self.requires_bare_local.insert(place.local); + } + + let context = if context.is_mutating_use() { + PlaceContext::MutatingUse(MutatingUseContext::Projection) + } else { + PlaceContext::NonMutatingUse(NonMutatingUseContext::Projection) + }; + self.visit_local(place.local, context, location); + } + + fn visit_assign(&mut self, lhs: &Place<'tcx>, rvalue: &Rvalue<'tcx>, location: Location) { + self.super_assign(lhs, rvalue, location); + + if let Rvalue::Use(Operand::Copy(rhs) | Operand::Move(rhs), _) = rvalue { + let (src, dest) = + if lhs.is_indirect_first_projection() || rhs.is_indirect_first_projection() { + return; + } else if lhs.projection == rhs.projection { + (lhs.local, Place::from(rhs.local)) + } else if let Some(lhs) = lhs.as_local() { + (lhs, *rhs) + } else if let Some(rhs) = rhs.as_local() { + (rhs, *lhs) + } else { + return; + }; + + if !dest.projection.iter().all(|p| p.is_stable_offset() && p.can_use_in_debuginfo()) { + return; + } + // As described at the top of the file, we do not go near things that have // their address taken. - if self.borrowed.contains(src) || self.borrowed.contains(dest) { + if self.borrowed.contains(src) || self.borrowed.contains(dest.local) { + return; + } + + if most_packed_projection(self.tcx, &self.body.local_decls, dest).is_some() { return; } // As described at the top of this file, we do not touch locals which have // different types. let src_ty = self.body.local_decls()[src].ty; - let dest_ty = self.body.local_decls()[dest].ty; + let dest_ty = dest.ty(self.body, self.tcx).ty; if src_ty != dest_ty { // FIXME(#112651): This can be removed afterwards. Also update the module description. trace!("skipped `{src:?} = {dest:?}` due to subtyping: {src_ty} != {dest_ty}"); @@ -636,10 +797,9 @@ fn save_as_intervals<'tcx>( // as marking `_b` live here would prevent unification. let is_simple_assignment = match stmt.kind { StatementKind::Assign(( - lhs, - Rvalue::CopyForDeref(rhs) - | Rvalue::Use(Operand::Copy(rhs) | Operand::Move(rhs), _), - )) => lhs.projection == rhs.projection, + _, + Rvalue::CopyForDeref(_) | Rvalue::Use(Operand::Copy(_) | Operand::Move(_), _), + )) => true, _ => false, }; VisitPlacesWith(|place: Place<'tcx>, ctxt| { diff --git a/tests/codegen-llvm/scalar-pair-bool.rs b/tests/codegen-llvm/scalar-pair-bool.rs index def3b32f71aa4..71937fc5ace67 100644 --- a/tests/codegen-llvm/scalar-pair-bool.rs +++ b/tests/codegen-llvm/scalar-pair-bool.rs @@ -20,13 +20,12 @@ pub fn pair_i32_bool(pair: (i32, bool)) -> (i32, bool) { pair } -// CHECK: define{{.*}}{ i1, i1 } @pair_and_or(i1 noundef zeroext %_1.0, i1 noundef zeroext %_1.1) +// CHECK: define{{.*}}{ i1, i1 } @pair_and_or(i1 noundef zeroext %0, i1 noundef zeroext %1) #[no_mangle] pub fn pair_and_or((a, b): (bool, bool)) -> (bool, bool) { // Make sure it can operate directly on the unpacked args - // (but it might not be using simple and/or instructions) - // CHECK-DAG: %_1.0 - // CHECK-DAG: %_1.1 + // CHECK: or i1 %0, %1 + // CHECK: and i1 %0, %1 (a && b, a || b) } diff --git a/tests/mir-opt/debuginfo/dest_prop.remap_debuginfo_locals.DestinationPropagation.diff b/tests/mir-opt/debuginfo/dest_prop.remap_debuginfo_locals.DestinationPropagation.diff index fe00da67e8bb0..a5c10b69454e3 100644 --- a/tests/mir-opt/debuginfo/dest_prop.remap_debuginfo_locals.DestinationPropagation.diff +++ b/tests/mir-opt/debuginfo/dest_prop.remap_debuginfo_locals.DestinationPropagation.diff @@ -3,7 +3,7 @@ fn remap_debuginfo_locals(_1: bool, _2: &bool) -> &bool { - debug c => _3; -+ debug c => _2; ++ debug c => _0; let mut _0: &bool; let mut _3: &bool; let mut _4: bool; @@ -14,10 +14,10 @@ - _4 = copy _1; - _3 = copy _2; - switchInt(copy _4) -> [1: bb1, otherwise: bb2]; -+ // DBG: _2 = &_1; -+ nop; ++ // DBG: _0 = &_1; + nop; + nop; ++ _0 = copy _2; + switchInt(copy _1) -> [1: bb1, otherwise: bb2]; } @@ -29,7 +29,7 @@ - StorageDead(_4); - _0 = copy _3; + nop; -+ _0 = copy _2; ++ nop; return; } } diff --git a/tests/mir-opt/dest-prop/copy_propagation_arg.foo.DestinationPropagation.panic-abort.diff b/tests/mir-opt/dest-prop/copy_propagation_arg.foo.DestinationPropagation.panic-abort.diff index 0328fc6b745b2..072205208c1d6 100644 --- a/tests/mir-opt/dest-prop/copy_propagation_arg.foo.DestinationPropagation.panic-abort.diff +++ b/tests/mir-opt/dest-prop/copy_propagation_arg.foo.DestinationPropagation.panic-abort.diff @@ -8,20 +8,20 @@ let mut _3: u8; bb0: { - StorageLive(_2); -- StorageLive(_3); -- _3 = copy _1; -- _2 = dummy(move _3) -> [return: bb1, unwind unreachable]; -+ nop; +- StorageLive(_2); + nop; -+ _2 = dummy(move _1) -> [return: bb1, unwind unreachable]; + StorageLive(_3); + _3 = copy _1; +- _2 = dummy(move _3) -> [return: bb1, unwind unreachable]; ++ _1 = dummy(move _3) -> [return: bb1, unwind unreachable]; } bb1: { -- StorageDead(_3); + StorageDead(_3); +- _1 = move _2; +- StorageDead(_2); ++ nop; + nop; - _1 = move _2; - StorageDead(_2); _0 = const (); return; } diff --git a/tests/mir-opt/dest-prop/copy_propagation_arg.foo.DestinationPropagation.panic-unwind.diff b/tests/mir-opt/dest-prop/copy_propagation_arg.foo.DestinationPropagation.panic-unwind.diff index 30e2248db8205..2525593afbfb0 100644 --- a/tests/mir-opt/dest-prop/copy_propagation_arg.foo.DestinationPropagation.panic-unwind.diff +++ b/tests/mir-opt/dest-prop/copy_propagation_arg.foo.DestinationPropagation.panic-unwind.diff @@ -8,20 +8,20 @@ let mut _3: u8; bb0: { - StorageLive(_2); -- StorageLive(_3); -- _3 = copy _1; -- _2 = dummy(move _3) -> [return: bb1, unwind continue]; -+ nop; +- StorageLive(_2); + nop; -+ _2 = dummy(move _1) -> [return: bb1, unwind continue]; + StorageLive(_3); + _3 = copy _1; +- _2 = dummy(move _3) -> [return: bb1, unwind continue]; ++ _1 = dummy(move _3) -> [return: bb1, unwind continue]; } bb1: { -- StorageDead(_3); + StorageDead(_3); +- _1 = move _2; +- StorageDead(_2); ++ nop; + nop; - _1 = move _2; - StorageDead(_2); _0 = const (); return; } diff --git a/tests/mir-opt/dest-prop/copy_propagation_arg.rs b/tests/mir-opt/dest-prop/copy_propagation_arg.rs index ef531f4afa2b7..9f1181adf1a3f 100644 --- a/tests/mir-opt/dest-prop/copy_propagation_arg.rs +++ b/tests/mir-opt/dest-prop/copy_propagation_arg.rs @@ -10,8 +10,9 @@ fn dummy(x: u8) -> u8 { fn foo(mut x: u8) { // CHECK-LABEL: fn foo( // CHECK: debug x => [[x:_.*]]; - // CHECK: dummy(move [[x]]) - // CHECK: [[x]] = move {{_.*}}; + // CHECK: [[tmp:_.*]] = copy [[x]]; + // CHECK: [[x]] = dummy(move [[tmp]]) + // calling `dummy` to make a use of `x` that copyprop cannot eliminate x = dummy(x); // this will assign a local to `x` } diff --git a/tests/mir-opt/dest-prop/cycle.main.DestinationPropagation.panic-abort.diff b/tests/mir-opt/dest-prop/cycle.main.DestinationPropagation.panic-abort.diff index a2f10be31a9e8..eea479d89bbec 100644 --- a/tests/mir-opt/dest-prop/cycle.main.DestinationPropagation.panic-abort.diff +++ b/tests/mir-opt/dest-prop/cycle.main.DestinationPropagation.panic-abort.diff @@ -8,23 +8,25 @@ let _5: (); let mut _6: i32; scope 1 { - debug x => _1; +- debug x => _1; ++ debug x => _4; let _2: i32; scope 2 { - debug y => _2; -+ debug y => _1; ++ debug y => _4; let _3: i32; scope 3 { - debug z => _3; -+ debug z => _1; ++ debug z => _4; } } } bb0: { - StorageLive(_1); +- _1 = val() -> [return: bb1, unwind unreachable]; + nop; - _1 = val() -> [return: bb1, unwind unreachable]; ++ _4 = val() -> [return: bb1, unwind unreachable]; } bb1: { @@ -50,7 +52,7 @@ - _5 = std::mem::drop::(move _6) -> [return: bb2, unwind unreachable]; + nop; + nop; -+ _5 = std::mem::drop::(move _1) -> [return: bb2, unwind unreachable]; ++ _5 = std::mem::drop::(move _4) -> [return: bb2, unwind unreachable]; } bb2: { diff --git a/tests/mir-opt/dest-prop/cycle.main.DestinationPropagation.panic-unwind.diff b/tests/mir-opt/dest-prop/cycle.main.DestinationPropagation.panic-unwind.diff index a08488615b15a..755abee4f19fa 100644 --- a/tests/mir-opt/dest-prop/cycle.main.DestinationPropagation.panic-unwind.diff +++ b/tests/mir-opt/dest-prop/cycle.main.DestinationPropagation.panic-unwind.diff @@ -8,23 +8,25 @@ let _5: (); let mut _6: i32; scope 1 { - debug x => _1; +- debug x => _1; ++ debug x => _4; let _2: i32; scope 2 { - debug y => _2; -+ debug y => _1; ++ debug y => _4; let _3: i32; scope 3 { - debug z => _3; -+ debug z => _1; ++ debug z => _4; } } } bb0: { - StorageLive(_1); +- _1 = val() -> [return: bb1, unwind continue]; + nop; - _1 = val() -> [return: bb1, unwind continue]; ++ _4 = val() -> [return: bb1, unwind continue]; } bb1: { @@ -50,7 +52,7 @@ - _5 = std::mem::drop::(move _6) -> [return: bb2, unwind continue]; + nop; + nop; -+ _5 = std::mem::drop::(move _1) -> [return: bb2, unwind continue]; ++ _5 = std::mem::drop::(move _4) -> [return: bb2, unwind continue]; } bb2: { diff --git a/tests/mir-opt/dest-prop/dead_stores_79191.f.DestinationPropagation.after.panic-abort.mir b/tests/mir-opt/dest-prop/dead_stores_79191.f.DestinationPropagation.after.panic-abort.mir index 15061da812063..28cb868d7388e 100644 --- a/tests/mir-opt/dest-prop/dead_stores_79191.f.DestinationPropagation.after.panic-abort.mir +++ b/tests/mir-opt/dest-prop/dead_stores_79191.f.DestinationPropagation.after.panic-abort.mir @@ -11,12 +11,12 @@ fn f(_1: usize) -> usize { } bb0: { - nop; + StorageLive(_2); _2 = copy _1; _1 = const 5_usize; nop; + _1 = copy _2; nop; - _1 = move _2; nop; nop; nop; @@ -25,7 +25,7 @@ fn f(_1: usize) -> usize { bb1: { nop; - nop; + StorageDead(_2); return; } } diff --git a/tests/mir-opt/dest-prop/dead_stores_79191.f.DestinationPropagation.after.panic-unwind.mir b/tests/mir-opt/dest-prop/dead_stores_79191.f.DestinationPropagation.after.panic-unwind.mir index ddfe4dc5b3ebf..b589a198b7835 100644 --- a/tests/mir-opt/dest-prop/dead_stores_79191.f.DestinationPropagation.after.panic-unwind.mir +++ b/tests/mir-opt/dest-prop/dead_stores_79191.f.DestinationPropagation.after.panic-unwind.mir @@ -11,12 +11,12 @@ fn f(_1: usize) -> usize { } bb0: { - nop; + StorageLive(_2); _2 = copy _1; _1 = const 5_usize; nop; + _1 = copy _2; nop; - _1 = move _2; nop; nop; nop; @@ -25,7 +25,7 @@ fn f(_1: usize) -> usize { bb1: { nop; - nop; + StorageDead(_2); return; } } diff --git a/tests/mir-opt/dest-prop/dead_stores_79191.rs b/tests/mir-opt/dest-prop/dead_stores_79191.rs index d035de5ce0765..4c5a067a244d6 100644 --- a/tests/mir-opt/dest-prop/dead_stores_79191.rs +++ b/tests/mir-opt/dest-prop/dead_stores_79191.rs @@ -12,7 +12,7 @@ fn f(mut a: usize) -> usize { // CHECK: debug b => [[b:_.*]]; // CHECK: [[b]] = copy [[a]]; // CHECK: [[a]] = const 5_usize; - // CHECK: [[a]] = move [[b]]; + // CHECK: [[a]] = copy [[b]]; // CHECK: id::(move [[a]]) let b = a; a = 5; 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 15061da812063..28cb868d7388e 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 @@ -11,12 +11,12 @@ fn f(_1: usize) -> usize { } bb0: { - nop; + StorageLive(_2); _2 = copy _1; _1 = const 5_usize; nop; + _1 = copy _2; nop; - _1 = move _2; nop; nop; nop; @@ -25,7 +25,7 @@ fn f(_1: usize) -> usize { bb1: { nop; - nop; + StorageDead(_2); return; } } 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 ddfe4dc5b3ebf..b589a198b7835 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 @@ -11,12 +11,12 @@ fn f(_1: usize) -> usize { } bb0: { - nop; + StorageLive(_2); _2 = copy _1; _1 = const 5_usize; nop; + _1 = copy _2; nop; - _1 = move _2; nop; nop; nop; @@ -25,7 +25,7 @@ fn f(_1: usize) -> usize { bb1: { nop; - nop; + StorageDead(_2); return; } } diff --git a/tests/mir-opt/dest-prop/dead_stores_better.rs b/tests/mir-opt/dest-prop/dead_stores_better.rs index d4c297fd97a38..6c7d88e6836af 100644 --- a/tests/mir-opt/dest-prop/dead_stores_better.rs +++ b/tests/mir-opt/dest-prop/dead_stores_better.rs @@ -16,7 +16,7 @@ pub fn f(mut a: usize) -> usize { // CHECK: debug b => [[b:_.*]]; // CHECK: [[b]] = copy [[a]]; // CHECK: [[a]] = const 5_usize; - // CHECK: [[a]] = move [[b]]; + // CHECK: [[a]] = copy [[b]]; // CHECK: id::(move [[a]]) let b = a; a = 5; diff --git a/tests/mir-opt/gvn_copy_constant_projection.rs b/tests/mir-opt/gvn_copy_constant_projection.rs index a08ae0ac7c976..bb05961b2db37 100644 --- a/tests/mir-opt/gvn_copy_constant_projection.rs +++ b/tests/mir-opt/gvn_copy_constant_projection.rs @@ -3,11 +3,8 @@ use std::cmp::Ordering; fn compare_constant_index(x: [i32; 1], y: [i32; 1]) -> Ordering { // CHECK-LABEL: fn compare_constant_index( - // CHECK-NOT: (*{{_.*}}); - // CHECK: [[lhs:_.*]] = copy _1[0 of 1]; - // CHECK-NOT: (*{{_.*}}); - // CHECK: [[rhs:_.*]] = copy _2[0 of 1]; - // CHECK: _0 = Cmp(move [[lhs]], move [[rhs]]); + // CHECK: bb0: { + // CHECK-NEXT: _0 = Cmp(move _1[0 of 1], move _2[0 of 1]); Ord::cmp(&x[0], &y[0]) } diff --git a/tests/mir-opt/inline_coroutine_body.run2-{closure#0}.Inline.panic-abort.diff b/tests/mir-opt/inline_coroutine_body.run2-{closure#0}.Inline.panic-abort.diff index f8ef70bd6c9ce..0710a61395de8 100644 --- a/tests/mir-opt/inline_coroutine_body.run2-{closure#0}.Inline.panic-abort.diff +++ b/tests/mir-opt/inline_coroutine_body.run2-{closure#0}.Inline.panic-abort.diff @@ -50,30 +50,29 @@ + scope 12 (inlined Pin::<&mut std::future::Ready<()>>::new_unchecked) { + } + scope 13 (inlined as Future>::poll) { -+ let mut _34: (); -+ let mut _35: std::option::Option<()>; -+ let mut _36: &mut std::option::Option<()>; -+ let mut _37: &mut std::future::Ready<()>; -+ let mut _38: &mut std::pin::Pin<&mut std::future::Ready<()>>; ++ let mut _34: std::option::Option<()>; ++ let mut _35: &mut std::option::Option<()>; ++ let mut _36: &mut std::future::Ready<()>; ++ let mut _37: &mut std::pin::Pin<&mut std::future::Ready<()>>; + scope 14 (inlined > as DerefMut>::deref_mut) { -+ let mut _39: *mut std::pin::helper::PinHelper<&mut std::future::Ready<()>>; -+ let mut _40: *mut std::pin::Pin<&mut std::future::Ready<()>>; ++ let mut _38: *mut std::pin::helper::PinHelper<&mut std::future::Ready<()>>; ++ let mut _39: *mut std::pin::Pin<&mut std::future::Ready<()>>; + scope 15 (inlined > as pin::helper::PinDerefMutHelper>::deref_mut) { -+ let mut _41: &mut &mut std::future::Ready<()>; ++ let mut _40: &mut &mut std::future::Ready<()>; + scope 16 (inlined <&mut std::future::Ready<()> as DerefMut>::deref_mut) { + } + } + } + scope 17 (inlined Option::<()>::take) { -+ let mut _42: std::option::Option<()>; ++ let mut _41: std::option::Option<()>; + scope 18 (inlined std::mem::replace::>) { + scope 19 { + } + } + } + scope 20 (inlined #[track_caller] Option::<()>::expect) { -+ let mut _43: isize; -+ let mut _44: !; ++ let mut _42: isize; ++ let mut _43: !; + scope 21 { + } + } @@ -189,24 +188,23 @@ + _23 = move _24; + _22 = &mut (*_23); + StorageDead(_24); -+ StorageLive(_37); -+ StorageLive(_39); -+ StorageLive(_44); + StorageLive(_34); -+ StorageLive(_35); -+ StorageLive(_40); -+ _40 = &raw mut _19; -+ _39 = copy _40 as *mut std::pin::helper::PinHelper<&mut std::future::Ready<()>> (PtrToPtr); -+ StorageDead(_40); -+ _37 = no_retag copy ((*_39).0: &mut std::future::Ready<()>); -+ StorageLive(_42); -+ _42 = Option::<()>::None; -+ _35 = copy ((*_37).0: std::option::Option<()>); -+ ((*_37).0: std::option::Option<()>) = move _42; -+ StorageDead(_42); ++ StorageLive(_36); ++ StorageLive(_38); + StorageLive(_43); -+ _43 = discriminant(_35); -+ switchInt(move _43) -> [0: bb11, 1: bb12, otherwise: bb5]; ++ StorageLive(_39); ++ _39 = &raw mut _19; ++ _38 = copy _39 as *mut std::pin::helper::PinHelper<&mut std::future::Ready<()>> (PtrToPtr); ++ StorageDead(_39); ++ _36 = no_retag copy ((*_38).0: &mut std::future::Ready<()>); ++ StorageLive(_41); ++ _41 = Option::<()>::None; ++ _34 = copy ((*_36).0: std::option::Option<()>); ++ ((*_36).0: std::option::Option<()>) = move _41; ++ StorageDead(_41); ++ StorageLive(_42); ++ _42 = discriminant(_34); ++ switchInt(move _42) -> [0: bb11, 1: bb12, otherwise: bb5]; } + + bb5: { @@ -266,18 +264,16 @@ + } + + bb11: { -+ _44 = option::expect_failed(const "`Ready` polled after completion") -> unwind unreachable; ++ _43 = option::expect_failed(const "`Ready` polled after completion") -> unwind unreachable; + } + + bb12: { -+ _34 = move ((_35 as Some).0: ()); ++ StorageDead(_42); ++ _18 = Poll::<()>::Ready(move ((_34 as Some).0: ())); + StorageDead(_43); -+ StorageDead(_35); -+ _18 = Poll::<()>::Ready(move _34); ++ StorageDead(_38); ++ StorageDead(_36); + StorageDead(_34); -+ StorageDead(_44); -+ StorageDead(_39); -+ StorageDead(_37); + StorageDead(_22); + StorageDead(_19); + _25 = discriminant(_18); diff --git a/tests/mir-opt/inline_coroutine_body.run2-{closure#0}.Inline.panic-unwind.diff b/tests/mir-opt/inline_coroutine_body.run2-{closure#0}.Inline.panic-unwind.diff index 18be10c534ec4..9388605bbef6e 100644 --- a/tests/mir-opt/inline_coroutine_body.run2-{closure#0}.Inline.panic-unwind.diff +++ b/tests/mir-opt/inline_coroutine_body.run2-{closure#0}.Inline.panic-unwind.diff @@ -50,30 +50,29 @@ + scope 12 (inlined Pin::<&mut std::future::Ready<()>>::new_unchecked) { + } + scope 13 (inlined as Future>::poll) { -+ let mut _34: (); -+ let mut _35: std::option::Option<()>; -+ let mut _36: &mut std::option::Option<()>; -+ let mut _37: &mut std::future::Ready<()>; -+ let mut _38: &mut std::pin::Pin<&mut std::future::Ready<()>>; ++ let mut _34: std::option::Option<()>; ++ let mut _35: &mut std::option::Option<()>; ++ let mut _36: &mut std::future::Ready<()>; ++ let mut _37: &mut std::pin::Pin<&mut std::future::Ready<()>>; + scope 14 (inlined > as DerefMut>::deref_mut) { -+ let mut _39: *mut std::pin::helper::PinHelper<&mut std::future::Ready<()>>; -+ let mut _40: *mut std::pin::Pin<&mut std::future::Ready<()>>; ++ let mut _38: *mut std::pin::helper::PinHelper<&mut std::future::Ready<()>>; ++ let mut _39: *mut std::pin::Pin<&mut std::future::Ready<()>>; + scope 15 (inlined > as pin::helper::PinDerefMutHelper>::deref_mut) { -+ let mut _41: &mut &mut std::future::Ready<()>; ++ let mut _40: &mut &mut std::future::Ready<()>; + scope 16 (inlined <&mut std::future::Ready<()> as DerefMut>::deref_mut) { + } + } + } + scope 17 (inlined Option::<()>::take) { -+ let mut _42: std::option::Option<()>; ++ let mut _41: std::option::Option<()>; + scope 18 (inlined std::mem::replace::>) { + scope 19 { + } + } + } + scope 20 (inlined #[track_caller] Option::<()>::expect) { -+ let mut _43: isize; -+ let mut _44: !; ++ let mut _42: isize; ++ let mut _43: !; + scope 21 { + } + } @@ -200,24 +199,23 @@ + _23 = move _24; + _22 = &mut (*_23); + StorageDead(_24); -+ StorageLive(_37); -+ StorageLive(_39); -+ StorageLive(_44); + StorageLive(_34); -+ StorageLive(_35); -+ StorageLive(_40); -+ _40 = &raw mut _19; -+ _39 = copy _40 as *mut std::pin::helper::PinHelper<&mut std::future::Ready<()>> (PtrToPtr); -+ StorageDead(_40); -+ _37 = no_retag copy ((*_39).0: &mut std::future::Ready<()>); -+ StorageLive(_42); -+ _42 = Option::<()>::None; -+ _35 = copy ((*_37).0: std::option::Option<()>); -+ ((*_37).0: std::option::Option<()>) = move _42; -+ StorageDead(_42); ++ StorageLive(_36); ++ StorageLive(_38); + StorageLive(_43); -+ _43 = discriminant(_35); -+ switchInt(move _43) -> [0: bb16, 1: bb17, otherwise: bb7]; ++ StorageLive(_39); ++ _39 = &raw mut _19; ++ _38 = copy _39 as *mut std::pin::helper::PinHelper<&mut std::future::Ready<()>> (PtrToPtr); ++ StorageDead(_39); ++ _36 = no_retag copy ((*_38).0: &mut std::future::Ready<()>); ++ StorageLive(_41); ++ _41 = Option::<()>::None; ++ _34 = copy ((*_36).0: std::option::Option<()>); ++ ((*_36).0: std::option::Option<()>) = move _41; ++ StorageDead(_41); ++ StorageLive(_42); ++ _42 = discriminant(_34); ++ switchInt(move _42) -> [0: bb16, 1: bb17, otherwise: bb7]; } - bb6 (cleanup): { @@ -299,18 +297,16 @@ + } + + bb16: { -+ _44 = option::expect_failed(const "`Ready` polled after completion") -> bb11; ++ _43 = option::expect_failed(const "`Ready` polled after completion") -> bb11; + } + + bb17: { -+ _34 = move ((_35 as Some).0: ()); ++ StorageDead(_42); ++ _18 = Poll::<()>::Ready(move ((_34 as Some).0: ())); + StorageDead(_43); -+ StorageDead(_35); -+ _18 = Poll::<()>::Ready(move _34); ++ StorageDead(_38); ++ StorageDead(_36); + StorageDead(_34); -+ StorageDead(_44); -+ StorageDead(_39); -+ StorageDead(_37); + StorageDead(_22); + StorageDead(_19); + _25 = discriminant(_18); 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 ec4a93c9a4e17..db61651ebc8a3 100644 --- a/tests/mir-opt/jump_threading.identity.JumpThreading.panic-abort.diff +++ b/tests/mir-opt/jump_threading.identity.JumpThreading.panic-abort.diff @@ -12,14 +12,14 @@ let mut _7: !; let mut _8: std::result::Result; let _9: i32; + let mut _15: i32; scope 1 { debug residual => _6; scope 2 { scope 8 (inlined #[track_caller] as FromResidual>>::from_residual) { - let mut _14: isize; - let _15: i32; - let mut _16: i32; - let mut _17: bool; + let mut _12: isize; + let mut _13: i32; + let mut _14: bool; scope 9 { scope 10 (inlined >::from) { } @@ -34,9 +34,7 @@ } scope 5 (inlined as Try>::branch) { let mut _10: isize; - let _11: i32; - let _12: i32; - let mut _13: std::result::Result; + let mut _11: std::result::Result; scope 6 { } scope 7 { @@ -73,20 +71,20 @@ _6 = copy ((_3 as Break).0: std::result::Result); StorageLive(_8); _8 = copy _6; + StorageLive(_12); StorageLive(_14); - StorageLive(_17); - _14 = discriminant(_8); - _17 = Eq(copy _14, const 1_isize); - assume(move _17); + _12 = discriminant(_8); + _14 = Eq(copy _12, const 1_isize); + assume(move _14); + StorageLive(_13); StorageLive(_15); _15 = move ((_8 as Err).0: i32); - StorageLive(_16); - _16 = move _15; - _0 = Result::::Err(move _16); - StorageDead(_16); + _13 = move _15; StorageDead(_15); - StorageDead(_17); + _0 = Result::::Err(move _13); + StorageDead(_13); StorageDead(_14); + StorageDead(_12); StorageDead(_8); StorageDead(_6); StorageDead(_2); @@ -106,22 +104,16 @@ } 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); + StorageLive(_11); + _11 = Result::::Err(copy ((_4 as Err).0: i32)); + _3 = ControlFlow::, i32>::Break(move _11); + StorageDead(_11); - goto -> bb5; + goto -> bb8; } bb7: { - StorageLive(_11); - _11 = move ((_4 as Ok).0: i32); - _3 = ControlFlow::, i32>::Continue(copy _11); - StorageDead(_11); + _3 = ControlFlow::, i32>::Continue(copy ((_4 as Ok).0: i32)); - goto -> bb5; + goto -> bb9; + } 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 ec4a93c9a4e17..db61651ebc8a3 100644 --- a/tests/mir-opt/jump_threading.identity.JumpThreading.panic-unwind.diff +++ b/tests/mir-opt/jump_threading.identity.JumpThreading.panic-unwind.diff @@ -12,14 +12,14 @@ let mut _7: !; let mut _8: std::result::Result; let _9: i32; + let mut _15: i32; scope 1 { debug residual => _6; scope 2 { scope 8 (inlined #[track_caller] as FromResidual>>::from_residual) { - let mut _14: isize; - let _15: i32; - let mut _16: i32; - let mut _17: bool; + let mut _12: isize; + let mut _13: i32; + let mut _14: bool; scope 9 { scope 10 (inlined >::from) { } @@ -34,9 +34,7 @@ } scope 5 (inlined as Try>::branch) { let mut _10: isize; - let _11: i32; - let _12: i32; - let mut _13: std::result::Result; + let mut _11: std::result::Result; scope 6 { } scope 7 { @@ -73,20 +71,20 @@ _6 = copy ((_3 as Break).0: std::result::Result); StorageLive(_8); _8 = copy _6; + StorageLive(_12); StorageLive(_14); - StorageLive(_17); - _14 = discriminant(_8); - _17 = Eq(copy _14, const 1_isize); - assume(move _17); + _12 = discriminant(_8); + _14 = Eq(copy _12, const 1_isize); + assume(move _14); + StorageLive(_13); StorageLive(_15); _15 = move ((_8 as Err).0: i32); - StorageLive(_16); - _16 = move _15; - _0 = Result::::Err(move _16); - StorageDead(_16); + _13 = move _15; StorageDead(_15); - StorageDead(_17); + _0 = Result::::Err(move _13); + StorageDead(_13); StorageDead(_14); + StorageDead(_12); StorageDead(_8); StorageDead(_6); StorageDead(_2); @@ -106,22 +104,16 @@ } 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); + StorageLive(_11); + _11 = Result::::Err(copy ((_4 as Err).0: i32)); + _3 = ControlFlow::, i32>::Break(move _11); + StorageDead(_11); - goto -> bb5; + goto -> bb8; } bb7: { - StorageLive(_11); - _11 = move ((_4 as Ok).0: i32); - _3 = ControlFlow::, i32>::Continue(copy _11); - StorageDead(_11); + _3 = ControlFlow::, i32>::Continue(copy ((_4 as Ok).0: i32)); - goto -> bb5; + goto -> bb9; + } diff --git a/tests/mir-opt/jump_threading.rs b/tests/mir-opt/jump_threading.rs index e4942a5c173fd..4a4f084e33359 100644 --- a/tests/mir-opt/jump_threading.rs +++ b/tests/mir-opt/jump_threading.rs @@ -67,12 +67,11 @@ fn identity(x: Result) -> Result { // CHECK: bb5: { // CHECK: switchInt(move _5) -> [0: bb2, 1: bb3, otherwise: bb1]; // CHECK: bb6: { - // CHECK: {{_.*}} = move (([[x]] as Err).0: i32); - // CHECK: [[controlflow]] = ControlFlow::, i32>::Break( + // CHECK: [[tmperr:_.*]] = Result::::Err(copy (([[x]] as Err).0: i32)); + // CHECK: [[controlflow]] = ControlFlow::, i32>::Break(move [[tmperr]]); // CHECK: goto -> bb8; // CHECK: bb7: { - // CHECK: {{_.*}} = move (([[x]] as Ok).0: i32); - // CHECK: [[controlflow]] = ControlFlow::, i32>::Continue( + // CHECK: [[controlflow]] = ControlFlow::, i32>::Continue(copy (([[x]] as Ok).0: i32)); // CHECK: goto -> bb9; // CHECK: bb8: { // CHECK: goto -> bb3; diff --git a/tests/mir-opt/pre-codegen/checked_ops.rs b/tests/mir-opt/pre-codegen/checked_ops.rs index 690b35430c747..66c023b0a25a8 100644 --- a/tests/mir-opt/pre-codegen/checked_ops.rs +++ b/tests/mir-opt/pre-codegen/checked_ops.rs @@ -30,8 +30,7 @@ pub fn use_checked_sub(x: u32, rhs: u32) { // CHECK: inlined{{.+}}u32{{.+}}checked_sub // CHECK: [[DELTA:_[0-9]+]] = SubUnchecked(copy _1, copy _2) // CHECK: [[TEMP1:_.+]] = Option::::Some(move [[DELTA]]); - // CHECK: [[TEMP2:_.+]] = {{move|copy}} (([[TEMP1]] as Some).0: u32); - // CHECK: do_something({{move|copy}} [[TEMP2]]) + // CHECK: do_something(move (([[TEMP1]] as Some).0: u32)) if let Some(delta) = x.checked_sub(rhs) { do_something(delta); } diff --git a/tests/mir-opt/pre-codegen/checked_ops.step_forward.runtime-optimized.after.panic-abort.mir b/tests/mir-opt/pre-codegen/checked_ops.step_forward.runtime-optimized.after.panic-abort.mir index 073baaa75be92..8ee7af5c6851a 100644 --- a/tests/mir-opt/pre-codegen/checked_ops.step_forward.runtime-optimized.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/checked_ops.step_forward.runtime-optimized.after.panic-abort.mir @@ -5,16 +5,15 @@ fn step_forward(_1: u16, _2: usize) -> u16 { debug n => _2; let mut _0: u16; scope 1 (inlined ::forward) { - let mut _8: u16; + let mut _7: u16; scope 2 { } scope 3 (inlined ::forward_checked) { scope 4 { scope 6 (inlined core::num::::checked_add) { let mut _5: (u16, bool); - let mut _6: bool; scope 7 (inlined std::intrinsics::unlikely) { - let _7: (); + let _6: (); } } } @@ -43,26 +42,22 @@ fn step_forward(_1: u16, _2: usize) -> u16 { bb1: { _4 = copy _2 as u16 (IntToInt); StorageDead(_3); - StorageLive(_6); StorageLive(_5); _5 = AddWithOverflow(copy _1, copy _4); - _6 = copy (_5.1: bool); - switchInt(copy _6) -> [0: bb2, otherwise: bb3]; + switchInt(copy (_5.1: bool)) -> [0: bb2, otherwise: bb3]; } bb2: { StorageDead(_5); - StorageDead(_6); goto -> bb7; } bb3: { - _7 = std::intrinsics::cold_path() -> [return: bb4, unwind unreachable]; + _6 = std::intrinsics::cold_path() -> [return: bb4, unwind unreachable]; } bb4: { StorageDead(_5); - StorageDead(_6); goto -> bb6; } @@ -76,10 +71,10 @@ fn step_forward(_1: u16, _2: usize) -> u16 { } bb7: { - StorageLive(_8); - _8 = copy _2 as u16 (IntToInt); - _0 = Add(copy _1, copy _8); - StorageDead(_8); + StorageLive(_7); + _7 = copy _2 as u16 (IntToInt); + _0 = Add(copy _1, copy _7); + StorageDead(_7); StorageDead(_4); return; } diff --git a/tests/mir-opt/pre-codegen/checked_ops.step_forward.runtime-optimized.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/checked_ops.step_forward.runtime-optimized.after.panic-unwind.mir index 9ada3691f3a20..70a9dea57a645 100644 --- a/tests/mir-opt/pre-codegen/checked_ops.step_forward.runtime-optimized.after.panic-unwind.mir +++ b/tests/mir-opt/pre-codegen/checked_ops.step_forward.runtime-optimized.after.panic-unwind.mir @@ -5,16 +5,15 @@ fn step_forward(_1: u16, _2: usize) -> u16 { debug n => _2; let mut _0: u16; scope 1 (inlined ::forward) { - let mut _8: u16; + let mut _7: u16; scope 2 { } scope 3 (inlined ::forward_checked) { scope 4 { scope 6 (inlined core::num::::checked_add) { let mut _5: (u16, bool); - let mut _6: bool; scope 7 (inlined std::intrinsics::unlikely) { - let _7: (); + let _6: (); } } } @@ -43,26 +42,22 @@ fn step_forward(_1: u16, _2: usize) -> u16 { bb1: { _4 = copy _2 as u16 (IntToInt); StorageDead(_3); - StorageLive(_6); StorageLive(_5); _5 = AddWithOverflow(copy _1, copy _4); - _6 = copy (_5.1: bool); - switchInt(copy _6) -> [0: bb2, otherwise: bb3]; + switchInt(copy (_5.1: bool)) -> [0: bb2, otherwise: bb3]; } bb2: { StorageDead(_5); - StorageDead(_6); goto -> bb7; } bb3: { - _7 = std::intrinsics::cold_path() -> [return: bb4, unwind unreachable]; + _6 = std::intrinsics::cold_path() -> [return: bb4, unwind unreachable]; } bb4: { StorageDead(_5); - StorageDead(_6); goto -> bb6; } @@ -76,10 +71,10 @@ fn step_forward(_1: u16, _2: usize) -> u16 { } bb7: { - StorageLive(_8); - _8 = copy _2 as u16 (IntToInt); - _0 = Add(copy _1, copy _8); - StorageDead(_8); + StorageLive(_7); + _7 = copy _2 as u16 (IntToInt); + _0 = Add(copy _1, copy _7); + StorageDead(_7); StorageDead(_4); return; } diff --git a/tests/mir-opt/pre-codegen/checked_ops.use_checked_sub.runtime-optimized.after.panic-abort.mir b/tests/mir-opt/pre-codegen/checked_ops.use_checked_sub.runtime-optimized.after.panic-abort.mir index f24a8e41b7db5..9b33e870e4852 100644 --- a/tests/mir-opt/pre-codegen/checked_ops.use_checked_sub.runtime-optimized.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/checked_ops.use_checked_sub.runtime-optimized.after.panic-abort.mir @@ -5,10 +5,9 @@ fn use_checked_sub(_1: u32, _2: u32) -> () { debug rhs => _2; let mut _0: (); let mut _5: std::option::Option; - let _7: (); + let _6: (); scope 1 { - debug delta => _6; - let _6: u32; + debug delta => ((_5 as Some).0: u32); scope 2 (inlined core::num::::checked_sub) { let mut _3: bool; let mut _4: u32; @@ -16,7 +15,6 @@ fn use_checked_sub(_1: u32, _2: u32) -> () { } bb0: { - StorageLive(_5); StorageLive(_3); _3 = Lt(copy _1, copy _2); switchInt(move _3) -> [0: bb1, otherwise: bb3]; @@ -28,13 +26,10 @@ 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: bb2, unwind unreachable]; + _6 = do_something(move ((_5 as Some).0: u32)) -> [return: bb2, unwind unreachable]; } bb2: { - StorageDead(_6); goto -> bb4; } @@ -44,7 +39,6 @@ fn use_checked_sub(_1: u32, _2: u32) -> () { } bb4: { - StorageDead(_5); return; } } diff --git a/tests/mir-opt/pre-codegen/checked_ops.use_checked_sub.runtime-optimized.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/checked_ops.use_checked_sub.runtime-optimized.after.panic-unwind.mir index 6bcb730be7f14..7b5f8f5a55279 100644 --- a/tests/mir-opt/pre-codegen/checked_ops.use_checked_sub.runtime-optimized.after.panic-unwind.mir +++ b/tests/mir-opt/pre-codegen/checked_ops.use_checked_sub.runtime-optimized.after.panic-unwind.mir @@ -5,10 +5,9 @@ fn use_checked_sub(_1: u32, _2: u32) -> () { debug rhs => _2; let mut _0: (); let mut _5: std::option::Option; - let _7: (); + let _6: (); scope 1 { - debug delta => _6; - let _6: u32; + debug delta => ((_5 as Some).0: u32); scope 2 (inlined core::num::::checked_sub) { let mut _3: bool; let mut _4: u32; @@ -16,7 +15,6 @@ fn use_checked_sub(_1: u32, _2: u32) -> () { } bb0: { - StorageLive(_5); StorageLive(_3); _3 = Lt(copy _1, copy _2); switchInt(move _3) -> [0: bb1, otherwise: bb3]; @@ -28,13 +26,10 @@ 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: bb2, unwind continue]; + _6 = do_something(move ((_5 as Some).0: u32)) -> [return: bb2, unwind continue]; } bb2: { - StorageDead(_6); goto -> bb4; } @@ -44,7 +39,6 @@ fn use_checked_sub(_1: u32, _2: u32) -> () { } bb4: { - StorageDead(_5); return; } } diff --git a/tests/mir-opt/pre-codegen/derived_ord.demo_le.runtime-optimized.after.mir b/tests/mir-opt/pre-codegen/derived_ord.demo_le.runtime-optimized.after.mir index 928c987b3476e..a7cadcb6fa98d 100644 --- a/tests/mir-opt/pre-codegen/derived_ord.demo_le.runtime-optimized.after.mir +++ b/tests/mir-opt/pre-codegen/derived_ord.demo_le.runtime-optimized.after.mir @@ -7,11 +7,10 @@ fn demo_le(_1: &MultiField, _2: &MultiField) -> bool { scope 1 (inlined ::le) { let mut _6: std::option::Option; scope 2 (inlined Option::::is_some_and:: bool {std::cmp::Ordering::is_le}>) { - let _11: 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})) { scope 5 (inlined std::cmp::Ordering::is_le) { - let mut _12: i8; + let mut _11: i8; scope 6 (inlined std::cmp::Ordering::as_raw) { } } @@ -69,11 +68,8 @@ fn demo_le(_1: &MultiField, _2: &MultiField) -> bool { StorageDead(_7); StorageDead(_5); StorageLive(_11); - _11 = move ((_6 as Some).0: std::cmp::Ordering); - StorageLive(_12); - _12 = discriminant(_11); - _0 = Le(move _12, const 0_i8); - StorageDead(_12); + _11 = discriminant(((_6 as Some).0: std::cmp::Ordering)); + _0 = Le(move _11, const 0_i8); StorageDead(_11); StorageDead(_6); return; diff --git a/tests/mir-opt/pre-codegen/loops.filter_mapped.runtime-optimized.after.mir b/tests/mir-opt/pre-codegen/loops.filter_mapped.runtime-optimized.after.mir index b3d38472a6a72..28ab001c0e1b9 100644 --- a/tests/mir-opt/pre-codegen/loops.filter_mapped.runtime-optimized.after.mir +++ b/tests/mir-opt/pre-codegen/loops.filter_mapped.runtime-optimized.after.mir @@ -8,16 +8,15 @@ fn filter_mapped(_1: impl Iterator, _2: 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 _9: (); + let mut _10: &mut std::iter::FilterMap, impl Fn(T) -> Option>; scope 1 { debug iter => _4; - let _9: U; scope 2 { - debug x => _9; + debug x => ((_7 as Some).0: U); } scope 4 (inlined , impl Fn(T) -> Option> as Iterator>::next) { - debug self => _11; + debug self => _10; let mut _5: &mut impl Iterator; let mut _6: &mut impl Fn(T) -> Option; } @@ -37,8 +36,7 @@ fn filter_mapped(_1: impl Iterator, _2: impl Fn(T) -> Option) -> () } bb2: { - StorageLive(_7); - // DBG: _11 = &_4; + // DBG: _10 = &_4; StorageLive(_5); _5 = &mut (_4.0: impl Iterator); StorageLive(_6); @@ -54,7 +52,6 @@ fn filter_mapped(_1: impl Iterator, _2: impl Fn(T) -> Option) -> () } bb4: { - StorageDead(_7); drop(_4) -> [return: bb5, unwind continue]; } @@ -64,14 +61,10 @@ fn filter_mapped(_1: impl Iterator, _2: impl Fn(T) -> Option) -> () } bb6: { - StorageLive(_9); - _9 = move ((_7 as Some).0: U); - _10 = opaque::(move _9) -> [return: bb7, unwind: bb9]; + _9 = opaque::(move ((_7 as Some).0: U)) -> [return: bb7, unwind: bb9]; } bb7: { - StorageDead(_9); - StorageDead(_7); goto -> bb2; } diff --git a/tests/mir-opt/pre-codegen/loops.int_range.runtime-optimized.after.mir b/tests/mir-opt/pre-codegen/loops.int_range.runtime-optimized.after.mir index cd146079c6328..9df747b9b9a52 100644 --- a/tests/mir-opt/pre-codegen/loops.int_range.runtime-optimized.after.mir +++ b/tests/mir-opt/pre-codegen/loops.int_range.runtime-optimized.after.mir @@ -6,23 +6,22 @@ fn int_range(_1: usize, _2: usize) -> () { 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 _10: (); + let mut _11: &mut std::ops::Range; scope 1 { debug iter => _3; - let _10: usize; scope 2 { - debug i => _10; + debug i => ((_9 as Some).0: usize); } scope 4 (inlined iter::range::>::next) { - debug self => _12; + debug self => _11; scope 5 (inlined as iter::range::RangeIteratorImpl>::spec_next) { - debug self => _12; + debug self => _11; let mut _6: bool; let _7: usize; let mut _8: usize; + let mut _12: &usize; let mut _13: &usize; - let mut _14: &usize; scope 6 { debug old => _7; scope 8 (inlined ::forward_unchecked) { @@ -39,8 +38,8 @@ fn int_range(_1: usize, _2: usize) -> () { } } scope 7 (inlined std::cmp::impls::::lt) { - debug self => _13; - debug other => _14; + debug self => _12; + debug other => _13; let mut _4: usize; let mut _5: usize; } @@ -57,11 +56,10 @@ fn int_range(_1: usize, _2: usize) -> () { } bb1: { - StorageLive(_9); - // DBG: _12 = &_3; + // DBG: _11 = &_3; StorageLive(_6); - // DBG: _13 = &(_3.0: usize); - // DBG: _14 = &(_3.1: usize); + // DBG: _12 = &(_3.0: usize); + // DBG: _13 = &(_3.1: usize); StorageLive(_4); _4 = copy (_3.0: usize); StorageLive(_5); @@ -74,7 +72,6 @@ fn int_range(_1: usize, _2: usize) -> () { bb2: { StorageDead(_6); - StorageDead(_9); return; } @@ -88,14 +85,10 @@ fn int_range(_1: usize, _2: usize) -> () { _9 = Option::::Some(copy _7); StorageDead(_7); StorageDead(_6); - StorageLive(_10); - _10 = copy ((_9 as Some).0: usize); - _11 = opaque::(move _10) -> [return: bb4, unwind continue]; + _10 = opaque::(move ((_9 as Some).0: usize)) -> [return: bb4, unwind continue]; } bb4: { - StorageDead(_10); - StorageDead(_9); goto -> bb1; } } diff --git a/tests/mir-opt/pre-codegen/loops.mapped.runtime-optimized.after.mir b/tests/mir-opt/pre-codegen/loops.mapped.runtime-optimized.after.mir index f7c294bc1feb2..b7233a37faf9a 100644 --- a/tests/mir-opt/pre-codegen/loops.mapped.runtime-optimized.after.mir +++ b/tests/mir-opt/pre-codegen/loops.mapped.runtime-optimized.after.mir @@ -6,17 +6,16 @@ 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 _11: std::option::Option; + let _12: (); + let mut _13: &mut std::iter::Map, impl Fn(T) -> U>; scope 1 { debug iter => _4; - let _13: U; scope 2 { - debug x => _13; + debug x => ((_11 as Some).0: U); } scope 4 (inlined , impl Fn(T) -> U> as Iterator>::next) { - debug self => _15; + debug self => _13; let mut _5: &mut impl Iterator; let mut _6: std::option::Option; let mut _7: &mut impl Fn(T) -> U; @@ -24,14 +23,13 @@ fn mapped(_1: impl Iterator, _2: impl Fn(T) -> U) -> () { debug self => _6; debug f => _7; let mut _8: isize; - let _9: T; - let mut _10: (T,); - let mut _11: U; + let mut _9: (T,); + let mut _10: U; scope 6 { - debug x => _9; + debug x => ((_6 as Some).0: T); scope 7 (inlined ops::function::impls:: for &mut impl Fn(T) -> U>::call_once) { debug self => _7; - debug args => _10; + debug args => _9; } } } @@ -52,8 +50,7 @@ fn mapped(_1: impl Iterator, _2: impl Fn(T) -> U) -> () { } bb2: { - StorageLive(_12); - // DBG: _15 = &_4; + // DBG: _13 = &_4; StorageLive(_6); StorageLive(_5); _5 = &mut (_4.0: impl Iterator); @@ -73,7 +70,6 @@ fn mapped(_1: impl Iterator, _2: impl Fn(T) -> U) -> () { StorageDead(_8); StorageDead(_7); StorageDead(_6); - StorageDead(_12); drop(_4) -> [return: bb5, unwind continue]; } @@ -83,30 +79,23 @@ fn mapped(_1: impl Iterator, _2: impl Fn(T) -> U) -> () { } bb6: { - StorageLive(_9); - _9 = move ((_6 as Some).0: T); - StorageLive(_11); StorageLive(_10); - _10 = (copy _9,); - _11 = U as FnMut<(T,)>>::call_mut(move _7, move _10) -> [return: bb7, unwind: bb10]; + StorageLive(_9); + _9 = (copy ((_6 as Some).0: T),); + _10 = U as FnMut<(T,)>>::call_mut(move _7, move _9) -> [return: bb7, unwind: bb10]; } bb7: { - StorageDead(_10); - _12 = Option::::Some(move _11); - StorageDead(_11); StorageDead(_9); + _11 = Option::::Some(move _10); + StorageDead(_10); StorageDead(_8); StorageDead(_7); StorageDead(_6); - StorageLive(_13); - _13 = move ((_12 as Some).0: U); - _14 = opaque::(move _13) -> [return: bb8, unwind: bb10]; + _12 = opaque::(move ((_11 as Some).0: U)) -> [return: bb8, unwind: bb10]; } bb8: { - StorageDead(_13); - StorageDead(_12); goto -> bb2; } diff --git a/tests/mir-opt/pre-codegen/loops.vec_move.runtime-optimized.after.mir b/tests/mir-opt/pre-codegen/loops.vec_move.runtime-optimized.after.mir index a49688ae891de..746c0c21038e5 100644 --- a/tests/mir-opt/pre-codegen/loops.vec_move.runtime-optimized.after.mir +++ b/tests/mir-opt/pre-codegen/loops.vec_move.runtime-optimized.after.mir @@ -8,12 +8,11 @@ fn vec_move(_1: Vec) -> () { let mut _24: &mut std::vec::IntoIter; let mut _25: std::option::Option; let mut _26: isize; - let _28: (); + let _27: (); scope 1 { debug iter => _23; - let _27: impl Sized; scope 2 { - debug x => _27; + debug x => ((_25 as Some).0: impl Sized); } } scope 3 (inlined as IntoIterator>::into_iter) { @@ -24,16 +23,16 @@ fn vec_move(_1: Vec) -> () { let mut _10: *mut impl Sized; let mut _11: *const impl Sized; let mut _12: usize; - let _29: &std::vec::Vec; - let mut _30: &std::mem::ManuallyDrop>; - let mut _31: &alloc::raw_vec::RawVec; - let mut _32: &std::mem::ManuallyDrop>; - let _33: &std::vec::Vec; - let mut _34: &std::mem::ManuallyDrop>; - let _35: &std::vec::Vec; - let mut _36: &std::mem::ManuallyDrop>; - let mut _37: &alloc::raw_vec::RawVec; - let mut _38: &std::mem::ManuallyDrop>; + 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 => _3; scope 5 { @@ -51,17 +50,17 @@ fn vec_move(_1: Vec) -> () { debug cap => _20; } scope 45 (inlined > as Deref>::deref) { - debug self => _38; + debug self => _37; scope 46 (inlined MaybeDangling::>::as_ref) { } } scope 47 (inlined alloc::raw_vec::RawVec::::capacity) { - debug self => _37; - let mut _39: &alloc::raw_vec::RawVecInner; + debug self => _36; + let mut _38: &alloc::raw_vec::RawVecInner; scope 48 (inlined std::mem::size_of::) { } scope 49 (inlined alloc::raw_vec::RawVecInner::capacity) { - debug self => _39; + debug self => _38; debug elem_size => const ::SIZE; let mut _21: core::num::niche_types::UsizeNoHighBit; scope 50 (inlined core::num::niche_types::UsizeNoHighBit::as_inner) { @@ -71,12 +70,12 @@ fn vec_move(_1: Vec) -> () { } } scope 29 (inlined > as Deref>::deref) { - debug self => _34; + debug self => _33; scope 30 (inlined MaybeDangling::>::as_ref) { } } scope 31 (inlined Vec::::len) { - debug self => _33; + debug self => _32; let mut _13: bool; scope 32 { } @@ -112,12 +111,12 @@ fn vec_move(_1: Vec) -> () { } } scope 40 (inlined > as Deref>::deref) { - debug self => _36; + debug self => _35; scope 41 (inlined MaybeDangling::>::as_ref) { } } scope 42 (inlined Vec::::len) { - debug self => _35; + debug self => _34; let mut _9: bool; scope 43 { } @@ -132,12 +131,12 @@ fn vec_move(_1: Vec) -> () { } } scope 20 (inlined > as Deref>::deref) { - debug self => _32; + debug self => _31; scope 21 (inlined MaybeDangling::>::as_ref) { } } scope 22 (inlined alloc::raw_vec::RawVec::::non_null) { - debug self => _31; + debug self => _30; scope 23 (inlined alloc::raw_vec::RawVecInner::non_null::) { let mut _5: std::ptr::NonNull; scope 24 (inlined std::ptr::Unique::::cast::) { @@ -152,12 +151,12 @@ fn vec_move(_1: Vec) -> () { } } scope 12 (inlined > as Deref>::deref) { - debug self => _30; + debug self => _29; scope 13 (inlined MaybeDangling::>::as_ref) { } } scope 14 (inlined Vec::::allocator) { - debug self => _29; + debug self => _28; scope 15 (inlined alloc::raw_vec::RawVec::::allocator) { scope 16 (inlined alloc::raw_vec::RawVecInner::allocator) { } @@ -192,13 +191,13 @@ fn vec_move(_1: Vec) -> () { _3 = ManuallyDrop::> { value: move _2 }; StorageDead(_2); StorageLive(_4); - // DBG: _30 = &_3; - // DBG: _29 = &((_3.0: std::mem::MaybeDangling>).0: std::vec::Vec); + // DBG: _29 = &_3; + // DBG: _28 = &((_3.0: std::mem::MaybeDangling>).0: std::vec::Vec); _4 = &raw const (((((_3.0: std::mem::MaybeDangling>).0: std::vec::Vec).0: alloc::raw_vec::RawVec).0: alloc::raw_vec::RawVecInner).2: std::alloc::Global); StorageDead(_4); StorageLive(_6); - // DBG: _32 = &_3; - // DBG: _31 = &(((_3.0: std::mem::MaybeDangling>).0: std::vec::Vec).0: alloc::raw_vec::RawVec); + // DBG: _31 = &_3; + // DBG: _30 = &(((_3.0: std::mem::MaybeDangling>).0: std::vec::Vec).0: alloc::raw_vec::RawVec); _5 = copy ((((((_3.0: std::mem::MaybeDangling>).0: std::vec::Vec).0: alloc::raw_vec::RawVec).0: alloc::raw_vec::RawVecInner).0: std::ptr::Unique).0: std::ptr::NonNull); _6 = copy _5 as std::ptr::NonNull (Transmute); StorageLive(_7); @@ -209,8 +208,8 @@ fn vec_move(_1: Vec) -> () { bb1: { StorageLive(_10); StorageLive(_8); - // DBG: _36 = &_3; - // DBG: _35 = &((_3.0: std::mem::MaybeDangling>).0: std::vec::Vec); + // DBG: _35 = &_3; + // DBG: _34 = &((_3.0: std::mem::MaybeDangling>).0: std::vec::Vec); _8 = copy (((_3.0: std::mem::MaybeDangling>).0: std::vec::Vec).1: usize); StorageLive(_9); _9 = Le(copy _8, const ::MAX_SLICE_LEN); @@ -225,8 +224,8 @@ fn vec_move(_1: Vec) -> () { bb2: { StorageLive(_12); - // DBG: _34 = &_3; - // DBG: _33 = &((_3.0: std::mem::MaybeDangling>).0: std::vec::Vec); + // DBG: _33 = &_3; + // DBG: _32 = &((_3.0: std::mem::MaybeDangling>).0: std::vec::Vec); _12 = copy (((_3.0: std::mem::MaybeDangling>).0: std::vec::Vec).1: usize); StorageLive(_13); _13 = Le(copy _12, const ::MAX_SLICE_LEN); @@ -257,9 +256,9 @@ fn vec_move(_1: Vec) -> () { } bb4: { - // DBG: _38 = &_3; - // DBG: _37 = &(((_3.0: std::mem::MaybeDangling>).0: std::vec::Vec).0: alloc::raw_vec::RawVec); - // DBG: _39 = &((((_3.0: std::mem::MaybeDangling>).0: std::vec::Vec).0: alloc::raw_vec::RawVec).0: alloc::raw_vec::RawVecInner); + // DBG: _37 = &_3; + // DBG: _36 = &(((_3.0: std::mem::MaybeDangling>).0: std::vec::Vec).0: alloc::raw_vec::RawVec); + // DBG: _38 = &((((_3.0: std::mem::MaybeDangling>).0: std::vec::Vec).0: alloc::raw_vec::RawVec).0: alloc::raw_vec::RawVecInner); switchInt(const ::SIZE) -> [0: bb5, otherwise: bb6]; } @@ -291,7 +290,6 @@ fn vec_move(_1: Vec) -> () { } bb8: { - StorageLive(_25); StorageLive(_24); _24 = &mut _23; _25 = as Iterator>::next(move _24) -> [return: bb9, unwind: bb15]; @@ -304,7 +302,6 @@ fn vec_move(_1: Vec) -> () { bb10: { StorageDead(_24); - StorageDead(_25); drop(_23) -> [return: bb11, unwind continue]; } @@ -315,15 +312,11 @@ fn vec_move(_1: Vec) -> () { } bb12: { - StorageLive(_27); - _27 = move ((_25 as Some).0: impl Sized); - _28 = opaque::(move _27) -> [return: bb13, unwind: bb15]; + _27 = opaque::(move ((_25 as Some).0: impl Sized)) -> [return: bb13, unwind: bb15]; } bb13: { - StorageDead(_27); StorageDead(_24); - StorageDead(_25); goto -> bb8; } diff --git a/tests/mir-opt/pre-codegen/range_iter.forward_loop.runtime-optimized.after.panic-abort.mir b/tests/mir-opt/pre-codegen/range_iter.forward_loop.runtime-optimized.after.panic-abort.mir index 47c78d4e80138..8a6c32ded00c6 100644 --- a/tests/mir-opt/pre-codegen/range_iter.forward_loop.runtime-optimized.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/range_iter.forward_loop.runtime-optimized.after.panic-abort.mir @@ -6,15 +6,14 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { 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 _8: &impl Fn(u32); + let mut _9: (u32,); + let _10: (); scope 1 { debug ((iter: std::ops::Range).0: u32) => _1; debug ((iter: std::ops::Range).1: u32) => _2; - let _8: u32; scope 2 { - debug x => _8; + debug x => ((_7 as Some).0: u32); } scope 4 (inlined iter::range::>::next) { scope 5 (inlined as iter::range::RangeIteratorImpl>::spec_next) { @@ -44,7 +43,6 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { } bb1: { - StorageLive(_7); StorageLive(_5); StorageLive(_4); _4 = copy _1; @@ -55,7 +53,6 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { bb2: { StorageDead(_5); - StorageDead(_7); drop(_3) -> [return: bb3, unwind unreachable]; } @@ -71,19 +68,15 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { StorageDead(_6); StorageDead(_5); StorageLive(_8); - _8 = copy ((_7 as Some).0: u32); + _8 = &_3; StorageLive(_9); - _9 = &_3; - StorageLive(_10); - _10 = (copy _8,); - _11 = >::call(move _9, move _10) -> [return: bb5, unwind unreachable]; + _9 = (copy ((_7 as Some).0: u32),); + _10 = >::call(move _8, move _9) -> [return: bb5, unwind unreachable]; } bb5: { - StorageDead(_10); StorageDead(_9); StorageDead(_8); - StorageDead(_7); goto -> bb1; } } diff --git a/tests/mir-opt/pre-codegen/range_iter.forward_loop.runtime-optimized.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/range_iter.forward_loop.runtime-optimized.after.panic-unwind.mir index 5dfcba18be02f..9e2b99edad2de 100644 --- a/tests/mir-opt/pre-codegen/range_iter.forward_loop.runtime-optimized.after.panic-unwind.mir +++ b/tests/mir-opt/pre-codegen/range_iter.forward_loop.runtime-optimized.after.panic-unwind.mir @@ -6,15 +6,14 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { 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 _8: &impl Fn(u32); + let mut _9: (u32,); + let _10: (); scope 1 { debug ((iter: std::ops::Range).0: u32) => _1; debug ((iter: std::ops::Range).1: u32) => _2; - let _8: u32; scope 2 { - debug x => _8; + debug x => ((_7 as Some).0: u32); } scope 4 (inlined iter::range::>::next) { scope 5 (inlined as iter::range::RangeIteratorImpl>::spec_next) { @@ -44,7 +43,6 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { } bb1: { - StorageLive(_7); StorageLive(_5); StorageLive(_4); _4 = copy _1; @@ -55,7 +53,6 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { bb2: { StorageDead(_5); - StorageDead(_7); drop(_3) -> [return: bb3, unwind continue]; } @@ -71,19 +68,15 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { StorageDead(_6); StorageDead(_5); StorageLive(_8); - _8 = copy ((_7 as Some).0: u32); + _8 = &_3; StorageLive(_9); - _9 = &_3; - StorageLive(_10); - _10 = (copy _8,); - _11 = >::call(move _9, move _10) -> [return: bb5, unwind: bb6]; + _9 = (copy ((_7 as Some).0: u32),); + _10 = >::call(move _8, move _9) -> [return: bb5, unwind: bb6]; } bb5: { - StorageDead(_10); StorageDead(_9); StorageDead(_8); - StorageDead(_7); goto -> bb1; } diff --git a/tests/mir-opt/pre-codegen/range_iter.inclusive_loop.runtime-optimized.after.panic-abort.mir b/tests/mir-opt/pre-codegen/range_iter.inclusive_loop.runtime-optimized.after.panic-abort.mir index 5e1291f71663d..a0e3c9b166eb1 100644 --- a/tests/mir-opt/pre-codegen/range_iter.inclusive_loop.runtime-optimized.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/range_iter.inclusive_loop.runtime-optimized.after.panic-abort.mir @@ -10,14 +10,13 @@ fn inclusive_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { let mut _6: &mut std::ops::RangeInclusive; let mut _7: std::option::Option; let mut _8: isize; - let mut _10: &impl Fn(u32); - let mut _11: (u32,); - let _12: (); + let mut _9: &impl Fn(u32); + let mut _10: (u32,); + let _11: (); scope 1 { debug iter => _5; - let _9: u32; scope 2 { - debug x => _9; + debug x => ((_7 as Some).0: u32); } scope 5 (inlined iter::range::>::next) { } @@ -35,7 +34,6 @@ 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]; @@ -48,7 +46,6 @@ fn inclusive_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { bb3: { StorageDead(_6); - StorageDead(_7); StorageDead(_5); drop(_3) -> [return: bb4, unwind unreachable]; } @@ -59,20 +56,16 @@ fn inclusive_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { bb5: { StorageLive(_9); - _9 = copy ((_7 as Some).0: u32); + _9 = &_3; StorageLive(_10); - _10 = &_3; - StorageLive(_11); - _11 = (copy _9,); - _12 = >::call(move _10, move _11) -> [return: bb6, unwind unreachable]; + _10 = (copy ((_7 as Some).0: u32),); + _11 = >::call(move _9, move _10) -> [return: bb6, unwind unreachable]; } 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.runtime-optimized.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/range_iter.inclusive_loop.runtime-optimized.after.panic-unwind.mir index 2e82343e44431..3fb48307993c0 100644 --- a/tests/mir-opt/pre-codegen/range_iter.inclusive_loop.runtime-optimized.after.panic-unwind.mir +++ b/tests/mir-opt/pre-codegen/range_iter.inclusive_loop.runtime-optimized.after.panic-unwind.mir @@ -10,14 +10,13 @@ fn inclusive_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { let mut _6: &mut std::ops::RangeInclusive; let mut _7: std::option::Option; let mut _8: isize; - let mut _10: &impl Fn(u32); - let mut _11: (u32,); - let _12: (); + let mut _9: &impl Fn(u32); + let mut _10: (u32,); + let _11: (); scope 1 { debug iter => _5; - let _9: u32; scope 2 { - debug x => _9; + debug x => ((_7 as Some).0: u32); } scope 5 (inlined iter::range::>::next) { } @@ -35,7 +34,6 @@ 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]; @@ -48,7 +46,6 @@ fn inclusive_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { bb3: { StorageDead(_6); - StorageDead(_7); StorageDead(_5); drop(_3) -> [return: bb4, unwind continue]; } @@ -59,20 +56,16 @@ fn inclusive_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () { bb5: { StorageLive(_9); - _9 = copy ((_7 as Some).0: u32); + _9 = &_3; StorageLive(_10); - _10 = &_3; - StorageLive(_11); - _11 = (copy _9,); - _12 = >::call(move _10, move _11) -> [return: bb6, unwind: bb8]; + _10 = (copy ((_7 as Some).0: u32),); + _11 = >::call(move _9, move _10) -> [return: bb6, unwind: bb8]; } bb6: { - StorageDead(_11); StorageDead(_10); StorageDead(_9); StorageDead(_6); - StorageDead(_7); goto -> bb1; } diff --git a/tests/mir-opt/pre-codegen/simple_option_map.ezmap.runtime-optimized.after.mir b/tests/mir-opt/pre-codegen/simple_option_map.ezmap.runtime-optimized.after.mir index 273f7bfafa2c2..8cc4605e08e61 100644 --- a/tests/mir-opt/pre-codegen/simple_option_map.ezmap.runtime-optimized.after.mir +++ b/tests/mir-opt/pre-codegen/simple_option_map.ezmap.runtime-optimized.after.mir @@ -3,10 +3,9 @@ fn ezmap(_1: Option) -> Option { debug x => _1; let mut _0: std::option::Option; - scope 1 (inlined map::) { + scope 1 (inlined map::) { let mut _2: isize; - let _3: i32; - let mut _4: i32; + let mut _3: i32; scope 2 { scope 3 (inlined ezmap::{closure#0}) { } @@ -26,11 +25,8 @@ 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); + _3 = Add(copy ((_1 as Some).0: i32), const 1_i32); + _0 = Option::::Some(move _3); StorageDead(_3); goto -> bb3; } diff --git a/tests/mir-opt/pre-codegen/simple_option_map.map_via_question_mark.runtime-optimized.after.mir b/tests/mir-opt/pre-codegen/simple_option_map.map_via_question_mark.runtime-optimized.after.mir index 26648a3173d67..3562dc0629605 100644 --- a/tests/mir-opt/pre-codegen/simple_option_map.map_via_question_mark.runtime-optimized.after.mir +++ b/tests/mir-opt/pre-codegen/simple_option_map.map_via_question_mark.runtime-optimized.after.mir @@ -4,9 +4,8 @@ fn map_via_question_mark(_1: Option) -> Option { debug x => _1; let mut _0: std::option::Option; let mut _4: std::option::Option; - let mut _7: std::ops::ControlFlow, i32>; - let _8: i32; - let mut _9: i32; + let mut _6: std::ops::ControlFlow, i32>; + let mut _7: i32; scope 1 { debug residual => const Option::::None; scope 2 { @@ -17,19 +16,17 @@ fn map_via_question_mark(_1: Option) -> Option { } } scope 3 { - debug val => _8; + debug val => ((_6 as Continue).0: i32); scope 4 { } } scope 5 (inlined as Try>::branch) { let mut _2: isize; - let _6: i32; scope 6 { } } bb0: { - StorageLive(_9); StorageLive(_7); StorageLive(_2); _2 = discriminant(_1); @@ -46,21 +43,15 @@ fn map_via_question_mark(_1: Option) -> Option { _0 = const Option::::None; StorageDead(_5); StorageDead(_3); - StorageDead(_9); StorageDead(_7); goto -> bb3; } bb2: { - StorageLive(_6); - _6 = copy ((_1 as Some).0: i32); - _7 = ControlFlow::, i32>::Continue(copy _6); - StorageDead(_6); + _6 = ControlFlow::, i32>::Continue(copy ((_1 as Some).0: i32)); StorageDead(_2); - _8 = copy ((_7 as Continue).0: i32); - _9 = Add(copy _8, const 1_i32); - _0 = Option::::Some(move _9); - StorageDead(_9); + _7 = Add(copy ((_6 as Continue).0: i32), const 1_i32); + _0 = Option::::Some(move _7); StorageDead(_7); goto -> bb3; } diff --git a/tests/mir-opt/pre-codegen/simple_option_map.rs b/tests/mir-opt/pre-codegen/simple_option_map.rs index 8f3ea6f0ae280..d75ce2eca13db 100644 --- a/tests/mir-opt/pre-codegen/simple_option_map.rs +++ b/tests/mir-opt/pre-codegen/simple_option_map.rs @@ -17,8 +17,7 @@ pub fn ezmap(x: Option) -> Option { // combinator and without the closure, using just a plain match. // CHECK-LABEL: fn ezmap - // CHECK: [[INNER:_.+]] = copy ((_1 as Some).0: i32); - // CHECK: [[SUCC:_.+]] = Add({{copy|move}} [[INNER]], const 1_i32); + // CHECK: [[SUCC:_.+]] = Add(copy ((_1 as Some).0: i32), const 1_i32); // CHECK: _0 = Option::::Some({{copy|move}} [[SUCC]]); map(x, |n| n + 1) } @@ -28,10 +27,8 @@ pub fn map_via_question_mark(x: Option) -> Option { // FIXME(#138544): Ideally this would optimize out the `ControlFlow` local. // CHECK-LABEL: fn map_via_question_mark - // CHECK: [[INNER:_.+]] = copy ((_1 as Some).0: i32); - // CHECK: [[TEMP1:_.+]] = ControlFlow::, i32>::Continue(copy [[INNER]]); - // CHECK: [[TEMP2:_.+]] = copy (([[TEMP1]] as Continue).0: i32); - // CHECK: [[SUCC:_.+]] = Add({{copy|move}} [[TEMP2]], const 1_i32); + // CHECK: [[TEMP1:_.+]] = ControlFlow::, i32>::Continue(copy ((_1 as Some).0: i32)); + // CHECK: [[SUCC:_.+]] = Add(copy (([[TEMP1]] as Continue).0: i32), const 1_i32); // CHECK: _0 = Option::::Some({{copy|move}} [[SUCC]]); Some(x? + 1) } diff --git a/tests/mir-opt/pre-codegen/slice_index.rs b/tests/mir-opt/pre-codegen/slice_index.rs index 52bdd0f67825b..b60ee79051666 100644 --- a/tests/mir-opt/pre-codegen/slice_index.rs +++ b/tests/mir-opt/pre-codegen/slice_index.rs @@ -35,9 +35,8 @@ pub fn slice_index_range(slice: &[u32], index: Range) -> &[u32] { pub unsafe fn slice_get_unchecked_mut_range(slice: &mut [u32], index: Range) -> &mut [u32] { // CHECK-LABEL: slice_get_unchecked_mut_range // CHECK: [[START:_[0-9]+]] = move (_2.0: usize); - // CHECK: [[END:_[0-9]+]] = move (_2.1: usize); // CHECK: precondition_check - // CHECK: [[LEN:_[0-9]+]] = SubUnchecked(copy [[END]], copy [[START]]); + // CHECK: [[LEN:_[0-9]+]] = SubUnchecked(copy (_2.1: usize), copy [[START]]); // CHECK: [[PTR:_[0-9]+]] = Offset(copy {{_[0-9]+}}, copy [[START]]); // CHECK: [[SLICE:_[0-9]+]] = *mut [u32] from (copy [[PTR]], copy [[LEN]]) // CHECK: _0 = &mut (*[[SLICE]]); @@ -51,9 +50,8 @@ pub unsafe fn slice_ptr_get_unchecked_range( ) -> *const [u32] { // CHECK-LABEL: slice_ptr_get_unchecked_range // CHECK: [[START:_[0-9]+]] = move (_2.0: usize); - // CHECK: [[END:_[0-9]+]] = move (_2.1: usize); // CHECK: precondition_check - // CHECK: [[LEN:_[0-9]+]] = SubUnchecked(copy [[END]], copy [[START]]); + // CHECK: [[LEN:_[0-9]+]] = SubUnchecked(copy (_2.1: usize), copy [[START]]); // CHECK: [[PTR:_[0-9]+]] = Offset(copy {{_[0-9]+}}, copy [[START]]); // CHECK: _0 = *const [u32] from (copy [[PTR]], copy [[LEN]]) slice.get_unchecked(index) diff --git a/tests/mir-opt/pre-codegen/slice_index.slice_get_unchecked_mut_range.runtime-optimized.after.panic-abort.mir b/tests/mir-opt/pre-codegen/slice_index.slice_get_unchecked_mut_range.runtime-optimized.after.panic-abort.mir index 9ce88f4bd299a..3d12307bc6486 100644 --- a/tests/mir-opt/pre-codegen/slice_index.slice_get_unchecked_mut_range.runtime-optimized.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/slice_index.slice_get_unchecked_mut_range.runtime-optimized.after.panic-abort.mir @@ -5,19 +5,18 @@ fn slice_get_unchecked_mut_range(_1: &mut [u32], _2: std::ops::Range) -> debug index => _2; let mut _0: &mut [u32]; let mut _3: usize; - let mut _4: usize; scope 1 (inlined #[track_caller] core::slice::::get_unchecked_mut::>) { - let mut _5: *mut [u32]; - let mut _11: *mut [u32]; + let mut _4: *mut [u32]; + let mut _10: *mut [u32]; scope 2 (inlined #[track_caller] as SliceIndex<[u32]>>::get_unchecked_mut) { - let mut _6: usize; - let _7: (); - let _8: usize; + let mut _5: usize; + let _6: (); + let _7: usize; scope 3 { scope 6 (inlined core::slice::index::get_offset_len_mut_noubcheck::) { - let mut _9: *mut u32; + let mut _8: *mut u32; scope 7 { - let _10: *mut u32; + let _9: *mut u32; scope 8 { } } @@ -32,34 +31,31 @@ 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); + StorageLive(_10); + StorageLive(_4); + _4 = &raw mut (*_1); StorageLive(_5); - _5 = &raw mut (*_1); - 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]; + _5 = PtrMetadata(copy _1); + _6 = as SliceIndex<[T]>>::get_unchecked_mut::precondition_check(copy _3, copy (_2.1: usize), move _5) -> [return: bb1, unwind unreachable]; } bb1: { - StorageDead(_6); + StorageDead(_5); + StorageLive(_7); + _7 = SubUnchecked(copy (_2.1: usize), copy _3); StorageLive(_8); - _8 = SubUnchecked(copy _4, copy _3); + _8 = copy _4 as *mut u32 (PtrToPtr); StorageLive(_9); - _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); + _9 = Offset(copy _8, copy _3); + _10 = *mut [u32] from (copy _9, copy _7); StorageDead(_9); StorageDead(_8); - StorageDead(_5); - _0 = &mut (*_11); - StorageDead(_11); - StorageDead(_3); + StorageDead(_7); StorageDead(_4); + _0 = &mut (*_10); + StorageDead(_10); + StorageDead(_3); return; } } diff --git a/tests/mir-opt/pre-codegen/slice_index.slice_get_unchecked_mut_range.runtime-optimized.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/slice_index.slice_get_unchecked_mut_range.runtime-optimized.after.panic-unwind.mir index 9ce88f4bd299a..3d12307bc6486 100644 --- a/tests/mir-opt/pre-codegen/slice_index.slice_get_unchecked_mut_range.runtime-optimized.after.panic-unwind.mir +++ b/tests/mir-opt/pre-codegen/slice_index.slice_get_unchecked_mut_range.runtime-optimized.after.panic-unwind.mir @@ -5,19 +5,18 @@ fn slice_get_unchecked_mut_range(_1: &mut [u32], _2: std::ops::Range) -> debug index => _2; let mut _0: &mut [u32]; let mut _3: usize; - let mut _4: usize; scope 1 (inlined #[track_caller] core::slice::::get_unchecked_mut::>) { - let mut _5: *mut [u32]; - let mut _11: *mut [u32]; + let mut _4: *mut [u32]; + let mut _10: *mut [u32]; scope 2 (inlined #[track_caller] as SliceIndex<[u32]>>::get_unchecked_mut) { - let mut _6: usize; - let _7: (); - let _8: usize; + let mut _5: usize; + let _6: (); + let _7: usize; scope 3 { scope 6 (inlined core::slice::index::get_offset_len_mut_noubcheck::) { - let mut _9: *mut u32; + let mut _8: *mut u32; scope 7 { - let _10: *mut u32; + let _9: *mut u32; scope 8 { } } @@ -32,34 +31,31 @@ 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); + StorageLive(_10); + StorageLive(_4); + _4 = &raw mut (*_1); StorageLive(_5); - _5 = &raw mut (*_1); - 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]; + _5 = PtrMetadata(copy _1); + _6 = as SliceIndex<[T]>>::get_unchecked_mut::precondition_check(copy _3, copy (_2.1: usize), move _5) -> [return: bb1, unwind unreachable]; } bb1: { - StorageDead(_6); + StorageDead(_5); + StorageLive(_7); + _7 = SubUnchecked(copy (_2.1: usize), copy _3); StorageLive(_8); - _8 = SubUnchecked(copy _4, copy _3); + _8 = copy _4 as *mut u32 (PtrToPtr); StorageLive(_9); - _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); + _9 = Offset(copy _8, copy _3); + _10 = *mut [u32] from (copy _9, copy _7); StorageDead(_9); StorageDead(_8); - StorageDead(_5); - _0 = &mut (*_11); - StorageDead(_11); - StorageDead(_3); + StorageDead(_7); StorageDead(_4); + _0 = &mut (*_10); + StorageDead(_10); + StorageDead(_3); return; } } diff --git a/tests/mir-opt/pre-codegen/slice_index.slice_index_range.runtime-optimized.after.panic-abort.mir b/tests/mir-opt/pre-codegen/slice_index.slice_index_range.runtime-optimized.after.panic-abort.mir index 1d8c44fa4e2a5..03447d8064b00 100644 --- a/tests/mir-opt/pre-codegen/slice_index.slice_index_range.runtime-optimized.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/slice_index.slice_index_range.runtime-optimized.after.panic-abort.mir @@ -5,23 +5,22 @@ fn slice_index_range(_1: &[u32], _2: std::ops::Range) -> &[u32] { debug index => _2; let mut _0: &[u32]; let mut _3: usize; - let mut _4: usize; scope 1 (inlined #[track_caller] core::slice::index::> for [u32]>::index) { scope 2 (inlined #[track_caller] as SliceIndex<[u32]>>::index) { - let mut _7: usize; - let mut _8: bool; - let mut _9: *const [u32]; - let _12: *const [u32]; - let mut _13: usize; - let mut _14: !; + let mut _6: usize; + let mut _7: bool; + let mut _8: *const [u32]; + let _11: *const [u32]; + let mut _12: usize; + let mut _13: !; scope 3 (inlined core::num::::checked_sub) { - let mut _5: bool; - let mut _6: usize; + let mut _4: bool; + let mut _5: usize; } scope 4 (inlined core::slice::index::get_offset_len_noubcheck::) { - let mut _10: *const u32; + let mut _9: *const u32; scope 5 { - let _11: *const u32; + let _10: *const u32; scope 6 { } } @@ -31,58 +30,55 @@ 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); - _5 = Lt(copy _4, copy _3); - switchInt(move _5) -> [0: bb1, otherwise: bb4]; + StorageLive(_4); + _4 = Lt(copy (_2.1: usize), copy _3); + switchInt(move _4) -> [0: bb1, otherwise: bb4]; } bb1: { - _6 = SubUnchecked(copy _4, copy _3); - StorageDead(_5); - StorageLive(_8); + _5 = SubUnchecked(copy (_2.1: usize), copy _3); + StorageDead(_4); StorageLive(_7); - _7 = PtrMetadata(copy _1); - _8 = Le(copy _4, move _7); - switchInt(move _8) -> [0: bb2, otherwise: bb3]; + StorageLive(_6); + _6 = PtrMetadata(copy _1); + _7 = Le(copy (_2.1: usize), move _6); + switchInt(move _7) -> [0: bb2, otherwise: bb3]; } bb2: { - StorageDead(_7); + StorageDead(_6); goto -> bb5; } bb3: { - StorageDead(_7); - StorageLive(_12); + StorageDead(_6); + StorageLive(_11); + StorageLive(_8); + _8 = &raw const (*_1); StorageLive(_9); - _9 = &raw const (*_1); + _9 = copy _8 as *const u32 (PtrToPtr); StorageLive(_10); - _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); + _10 = Offset(copy _9, copy _3); + _11 = *const [u32] from (copy _10, copy _5); StorageDead(_10); StorageDead(_9); - _0 = &(*_12); - StorageDead(_12); StorageDead(_8); + _0 = &(*_11); + StorageDead(_11); + StorageDead(_7); StorageDead(_3); - StorageDead(_4); return; } bb4: { - StorageDead(_5); + StorageDead(_4); goto -> bb5; } bb5: { - StorageLive(_13); - _13 = PtrMetadata(copy _1); - _14 = core::slice::index::slice_index_fail(move _3, move _4, move _13) -> unwind unreachable; + StorageLive(_12); + _12 = PtrMetadata(copy _1); + _13 = core::slice::index::slice_index_fail(move _3, move (_2.1: usize), move _12) -> unwind unreachable; } } diff --git a/tests/mir-opt/pre-codegen/slice_index.slice_index_range.runtime-optimized.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/slice_index.slice_index_range.runtime-optimized.after.panic-unwind.mir index e66ee3581da27..06563fcd870b4 100644 --- a/tests/mir-opt/pre-codegen/slice_index.slice_index_range.runtime-optimized.after.panic-unwind.mir +++ b/tests/mir-opt/pre-codegen/slice_index.slice_index_range.runtime-optimized.after.panic-unwind.mir @@ -5,23 +5,22 @@ fn slice_index_range(_1: &[u32], _2: std::ops::Range) -> &[u32] { debug index => _2; let mut _0: &[u32]; let mut _3: usize; - let mut _4: usize; scope 1 (inlined #[track_caller] core::slice::index::> for [u32]>::index) { scope 2 (inlined #[track_caller] as SliceIndex<[u32]>>::index) { - let mut _7: usize; - let mut _8: bool; - let mut _9: *const [u32]; - let _12: *const [u32]; - let mut _13: usize; - let mut _14: !; + let mut _6: usize; + let mut _7: bool; + let mut _8: *const [u32]; + let _11: *const [u32]; + let mut _12: usize; + let mut _13: !; scope 3 (inlined core::num::::checked_sub) { - let mut _5: bool; - let mut _6: usize; + let mut _4: bool; + let mut _5: usize; } scope 4 (inlined core::slice::index::get_offset_len_noubcheck::) { - let mut _10: *const u32; + let mut _9: *const u32; scope 5 { - let _11: *const u32; + let _10: *const u32; scope 6 { } } @@ -31,58 +30,55 @@ 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); - _5 = Lt(copy _4, copy _3); - switchInt(move _5) -> [0: bb1, otherwise: bb4]; + StorageLive(_4); + _4 = Lt(copy (_2.1: usize), copy _3); + switchInt(move _4) -> [0: bb1, otherwise: bb4]; } bb1: { - _6 = SubUnchecked(copy _4, copy _3); - StorageDead(_5); - StorageLive(_8); + _5 = SubUnchecked(copy (_2.1: usize), copy _3); + StorageDead(_4); StorageLive(_7); - _7 = PtrMetadata(copy _1); - _8 = Le(copy _4, move _7); - switchInt(move _8) -> [0: bb2, otherwise: bb3]; + StorageLive(_6); + _6 = PtrMetadata(copy _1); + _7 = Le(copy (_2.1: usize), move _6); + switchInt(move _7) -> [0: bb2, otherwise: bb3]; } bb2: { - StorageDead(_7); + StorageDead(_6); goto -> bb5; } bb3: { - StorageDead(_7); - StorageLive(_12); + StorageDead(_6); + StorageLive(_11); + StorageLive(_8); + _8 = &raw const (*_1); StorageLive(_9); - _9 = &raw const (*_1); + _9 = copy _8 as *const u32 (PtrToPtr); StorageLive(_10); - _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); + _10 = Offset(copy _9, copy _3); + _11 = *const [u32] from (copy _10, copy _5); StorageDead(_10); StorageDead(_9); - _0 = &(*_12); - StorageDead(_12); StorageDead(_8); + _0 = &(*_11); + StorageDead(_11); + StorageDead(_7); StorageDead(_3); - StorageDead(_4); return; } bb4: { - StorageDead(_5); + StorageDead(_4); goto -> bb5; } bb5: { - StorageLive(_13); - _13 = PtrMetadata(copy _1); - _14 = core::slice::index::slice_index_fail(move _3, move _4, move _13) -> unwind continue; + StorageLive(_12); + _12 = PtrMetadata(copy _1); + _13 = core::slice::index::slice_index_fail(move _3, move (_2.1: usize), move _12) -> unwind continue; } } diff --git a/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.runtime-optimized.after.panic-abort.mir b/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.runtime-optimized.after.panic-abort.mir index 276fe6a9f6791..d1172af80439b 100644 --- a/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.runtime-optimized.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.runtime-optimized.after.panic-abort.mir @@ -5,17 +5,16 @@ fn slice_ptr_get_unchecked_range(_1: *const [u32], _2: std::ops::Range) - debug index => _2; let mut _0: *const [u32]; let mut _3: usize; - let mut _4: usize; scope 1 (inlined std::ptr::const_ptr::::get_unchecked::>) { scope 2 (inlined #[track_caller] as SliceIndex<[u32]>>::get_unchecked) { - let mut _5: usize; - let _6: (); - let _7: usize; + let mut _4: usize; + let _5: (); + let _6: usize; scope 3 { scope 6 (inlined core::slice::index::get_offset_len_noubcheck::) { - let mut _8: *const u32; + let mut _7: *const u32; scope 7 { - let _9: *const u32; + let _8: *const u32; scope 8 { } } @@ -30,28 +29,25 @@ 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(_5); - _5 = PtrMetadata(copy _1); - _6 = as SliceIndex<[T]>>::get_unchecked::precondition_check(copy _3, copy _4, move _5) -> [return: bb1, unwind unreachable]; + StorageLive(_4); + _4 = PtrMetadata(copy _1); + _5 = as SliceIndex<[T]>>::get_unchecked::precondition_check(copy _3, copy (_2.1: usize), move _4) -> [return: bb1, unwind unreachable]; } bb1: { - StorageDead(_5); + StorageDead(_4); + StorageLive(_6); + _6 = SubUnchecked(copy (_2.1: usize), copy _3); StorageLive(_7); - _7 = SubUnchecked(copy _4, copy _3); + _7 = copy _1 as *const u32 (PtrToPtr); StorageLive(_8); - _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); + _8 = Offset(copy _7, copy _3); + _0 = *const [u32] from (copy _8, copy _6); StorageDead(_8); StorageDead(_7); + StorageDead(_6); StorageDead(_3); - StorageDead(_4); return; } } diff --git a/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.runtime-optimized.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.runtime-optimized.after.panic-unwind.mir index 276fe6a9f6791..d1172af80439b 100644 --- a/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.runtime-optimized.after.panic-unwind.mir +++ b/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.runtime-optimized.after.panic-unwind.mir @@ -5,17 +5,16 @@ fn slice_ptr_get_unchecked_range(_1: *const [u32], _2: std::ops::Range) - debug index => _2; let mut _0: *const [u32]; let mut _3: usize; - let mut _4: usize; scope 1 (inlined std::ptr::const_ptr::::get_unchecked::>) { scope 2 (inlined #[track_caller] as SliceIndex<[u32]>>::get_unchecked) { - let mut _5: usize; - let _6: (); - let _7: usize; + let mut _4: usize; + let _5: (); + let _6: usize; scope 3 { scope 6 (inlined core::slice::index::get_offset_len_noubcheck::) { - let mut _8: *const u32; + let mut _7: *const u32; scope 7 { - let _9: *const u32; + let _8: *const u32; scope 8 { } } @@ -30,28 +29,25 @@ 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(_5); - _5 = PtrMetadata(copy _1); - _6 = as SliceIndex<[T]>>::get_unchecked::precondition_check(copy _3, copy _4, move _5) -> [return: bb1, unwind unreachable]; + StorageLive(_4); + _4 = PtrMetadata(copy _1); + _5 = as SliceIndex<[T]>>::get_unchecked::precondition_check(copy _3, copy (_2.1: usize), move _4) -> [return: bb1, unwind unreachable]; } bb1: { - StorageDead(_5); + StorageDead(_4); + StorageLive(_6); + _6 = SubUnchecked(copy (_2.1: usize), copy _3); StorageLive(_7); - _7 = SubUnchecked(copy _4, copy _3); + _7 = copy _1 as *const u32 (PtrToPtr); StorageLive(_8); - _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); + _8 = Offset(copy _7, copy _3); + _0 = *const [u32] from (copy _8, copy _6); StorageDead(_8); StorageDead(_7); + StorageDead(_6); StorageDead(_3); - StorageDead(_4); return; } } diff --git a/tests/mir-opt/pre-codegen/slice_iter.enumerated_loop.runtime-optimized.after.panic-abort.mir b/tests/mir-opt/pre-codegen/slice_iter.enumerated_loop.runtime-optimized.after.panic-abort.mir index fc254be264748..2e607e7ca923e 100644 --- a/tests/mir-opt/pre-codegen/slice_iter.enumerated_loop.runtime-optimized.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/slice_iter.enumerated_loop.runtime-optimized.after.panic-abort.mir @@ -6,23 +6,23 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () { let mut _0: (); let mut _12: usize; let mut _32: std::option::Option<(usize, &T)>; - let mut _35: &impl Fn(usize, &T); - let mut _36: (usize, &T); - let _37: (); + let mut _34: &impl Fn(usize, &T); + let mut _35: (usize, &T); + let _36: (); scope 1 { debug (((iter: Enumerate>).0: std::slice::Iter<'_, T>).0: std::ptr::NonNull) => _8; debug (((iter: Enumerate>).0: std::slice::Iter<'_, T>).1: *const T) => _11; debug (((iter: Enumerate>).0: std::slice::Iter<'_, T>).2: std::marker::PhantomData<&T>) => const ZeroSized: PhantomData<&T>; debug ((iter: Enumerate>).1: usize) => _12; let _33: usize; - let _34: &T; scope 2 { debug i => _33; - debug x => _34; + debug x => (((_32 as Some).0: (usize, &T)).1: &T); } scope 18 (inlined > as Iterator>::next) { let mut _22: std::option::Option; let mut _27: std::option::Option<&T>; + let mut _28: std::ops::ControlFlow, &T>; let mut _30: (usize, bool); let mut _31: (usize, &T); scope 19 { @@ -43,7 +43,6 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () { } } scope 25 (inlined as Try>::branch) { - let _28: &T; scope 26 { } } @@ -179,7 +178,7 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () { } bb4: { - StorageLive(_32); + StorageLive(_28); StorageLive(_30); StorageLive(_27); StorageLive(_24); @@ -244,7 +243,7 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () { StorageDead(_23); StorageDead(_21); StorageDead(_30); - StorageDead(_32); + StorageDead(_28); StorageDead(_12); drop(_2) -> [return: bb11, unwind unreachable]; } @@ -272,7 +271,7 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () { StorageDead(_13); StorageDead(_16); StorageDead(_24); - _28 = copy ((_27 as Some).0: &T); + _28 = ControlFlow::, &T>::Continue(copy ((_27 as Some).0: &T)); StorageDead(_27); StorageLive(_29); _29 = copy _12; @@ -283,28 +282,25 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () { bb14: { _12 = move (_30.0: usize); StorageLive(_31); - _31 = (copy _29, copy _28); + _31 = (copy _29, copy ((_28 as Continue).0: &T)); _32 = Option::<(usize, &T)>::Some(move _31); StorageDead(_31); StorageDead(_29); StorageDead(_30); + StorageDead(_28); StorageLive(_33); _33 = copy (((_32 as Some).0: (usize, &T)).0: usize); StorageLive(_34); - _34 = copy (((_32 as Some).0: (usize, &T)).1: &T); + _34 = &_2; StorageLive(_35); - _35 = &_2; - StorageLive(_36); - _36 = (copy _33, copy _34); - _37 = >::call(move _35, move _36) -> [return: bb15, unwind unreachable]; + _35 = (copy _33, copy (((_32 as Some).0: (usize, &T)).1: &T)); + _36 = >::call(move _34, move _35) -> [return: bb15, unwind unreachable]; } bb15: { - StorageDead(_36); StorageDead(_35); StorageDead(_34); StorageDead(_33); - StorageDead(_32); goto -> bb4; } } diff --git a/tests/mir-opt/pre-codegen/slice_iter.enumerated_loop.runtime-optimized.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/slice_iter.enumerated_loop.runtime-optimized.after.panic-unwind.mir index 034416c173b49..f11a4e998d952 100644 --- a/tests/mir-opt/pre-codegen/slice_iter.enumerated_loop.runtime-optimized.after.panic-unwind.mir +++ b/tests/mir-opt/pre-codegen/slice_iter.enumerated_loop.runtime-optimized.after.panic-unwind.mir @@ -11,8 +11,7 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () { let mut _16: std::option::Option<(usize, &T)>; let mut _17: isize; let mut _20: &impl Fn(usize, &T); - let mut _21: (usize, &T); - let _22: (); + let _21: (); scope 1 { debug iter => _14; let _18: usize; @@ -113,7 +112,6 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () { } bb4: { - StorageLive(_16); StorageLive(_15); _15 = &mut _14; _16 = > as Iterator>::next(move _15) -> [return: bb5, unwind: bb11]; @@ -126,7 +124,6 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () { bb6: { StorageDead(_15); - StorageDead(_16); StorageDead(_14); drop(_2) -> [return: bb7, unwind continue]; } @@ -142,18 +139,14 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () { _19 = copy (((_16 as Some).0: (usize, &T)).1: &T); StorageLive(_20); _20 = &_2; - StorageLive(_21); - _21 = copy ((_16 as Some).0: (usize, &T)); - _22 = >::call(move _20, move _21) -> [return: bb9, unwind: bb11]; + _21 = >::call(move _20, move ((_16 as Some).0: (usize, &T))) -> [return: bb9, unwind: bb11]; } bb9: { - StorageDead(_21); StorageDead(_20); StorageDead(_19); StorageDead(_18); StorageDead(_15); - StorageDead(_16); goto -> bb4; } diff --git a/tests/mir-opt/pre-codegen/slice_iter.forward_loop.runtime-optimized.after.panic-abort.mir b/tests/mir-opt/pre-codegen/slice_iter.forward_loop.runtime-optimized.after.panic-abort.mir index 5f8fefc57c412..48eb306bd2d34 100644 --- a/tests/mir-opt/pre-codegen/slice_iter.forward_loop.runtime-optimized.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/slice_iter.forward_loop.runtime-optimized.after.panic-abort.mir @@ -5,16 +5,15 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () { debug f => _2; let mut _0: (); let mut _23: std::option::Option<&T>; - let mut _25: &impl Fn(&T); - let mut _26: (&T,); - let _27: (); + let mut _24: &impl Fn(&T); + let mut _25: (&T,); + let _26: (); scope 1 { debug ((iter: std::slice::Iter<'_, T>).0: std::ptr::NonNull) => _8; debug ((iter: std::slice::Iter<'_, T>).1: *const T) => _11; debug ((iter: std::slice::Iter<'_, T>).2: std::marker::PhantomData<&T>) => const ZeroSized: PhantomData<&T>; - let _24: &T; scope 2 { - debug x => _24; + debug x => ((_23 as Some).0: &T); } scope 16 (inlined as Iterator>::next) { let mut _8: std::ptr::NonNull; @@ -141,7 +140,6 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () { } bb4: { - StorageLive(_23); StorageLive(_20); StorageLive(_15); StorageLive(_12); @@ -195,7 +193,6 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () { StorageDead(_12); StorageDead(_15); StorageDead(_20); - StorageDead(_23); drop(_2) -> [return: bb11, unwind unreachable]; } @@ -223,19 +220,15 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () { StorageDead(_15); StorageDead(_20); StorageLive(_24); - _24 = copy ((_23 as Some).0: &T); + _24 = &_2; StorageLive(_25); - _25 = &_2; - StorageLive(_26); - _26 = (copy _24,); - _27 = >::call(move _25, move _26) -> [return: bb14, unwind unreachable]; + _25 = (copy ((_23 as Some).0: &T),); + _26 = >::call(move _24, move _25) -> [return: bb14, unwind unreachable]; } bb14: { - StorageDead(_26); StorageDead(_25); StorageDead(_24); - StorageDead(_23); goto -> bb4; } } diff --git a/tests/mir-opt/pre-codegen/slice_iter.forward_loop.runtime-optimized.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/slice_iter.forward_loop.runtime-optimized.after.panic-unwind.mir index 3bcd93396f614..04461cb9ebd76 100644 --- a/tests/mir-opt/pre-codegen/slice_iter.forward_loop.runtime-optimized.after.panic-unwind.mir +++ b/tests/mir-opt/pre-codegen/slice_iter.forward_loop.runtime-optimized.after.panic-unwind.mir @@ -5,16 +5,15 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () { debug f => _2; let mut _0: (); let mut _23: std::option::Option<&T>; - let mut _25: &impl Fn(&T); - let mut _26: (&T,); - let _27: (); + let mut _24: &impl Fn(&T); + let mut _25: (&T,); + let _26: (); scope 1 { debug ((iter: std::slice::Iter<'_, T>).0: std::ptr::NonNull) => _8; debug ((iter: std::slice::Iter<'_, T>).1: *const T) => _11; debug ((iter: std::slice::Iter<'_, T>).2: std::marker::PhantomData<&T>) => const ZeroSized: PhantomData<&T>; - let _24: &T; scope 2 { - debug x => _24; + debug x => ((_23 as Some).0: &T); } scope 16 (inlined as Iterator>::next) { let mut _8: std::ptr::NonNull; @@ -141,7 +140,6 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () { } bb4: { - StorageLive(_23); StorageLive(_20); StorageLive(_15); StorageLive(_12); @@ -195,7 +193,6 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () { StorageDead(_12); StorageDead(_15); StorageDead(_20); - StorageDead(_23); drop(_2) -> [return: bb11, unwind continue]; } @@ -223,19 +220,15 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () { StorageDead(_15); StorageDead(_20); StorageLive(_24); - _24 = copy ((_23 as Some).0: &T); + _24 = &_2; StorageLive(_25); - _25 = &_2; - StorageLive(_26); - _26 = (copy _24,); - _27 = >::call(move _25, move _26) -> [return: bb14, unwind: bb15]; + _25 = (copy ((_23 as Some).0: &T),); + _26 = >::call(move _24, move _25) -> [return: bb14, unwind: bb15]; } bb14: { - StorageDead(_26); StorageDead(_25); StorageDead(_24); - StorageDead(_23); goto -> bb4; } diff --git a/tests/mir-opt/pre-codegen/slice_iter.reverse_loop.runtime-optimized.after.panic-abort.mir b/tests/mir-opt/pre-codegen/slice_iter.reverse_loop.runtime-optimized.after.panic-abort.mir index bd0e3a025f425..6f638ac0b6d91 100644 --- a/tests/mir-opt/pre-codegen/slice_iter.reverse_loop.runtime-optimized.after.panic-abort.mir +++ b/tests/mir-opt/pre-codegen/slice_iter.reverse_loop.runtime-optimized.after.panic-abort.mir @@ -8,14 +8,13 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () { let mut _13: std::iter::Rev>; let mut _14: std::iter::Rev>; let mut _35: std::option::Option<&T>; - let mut _37: &impl Fn(&T); - let mut _38: (&T,); - let _39: (); + let mut _36: &impl Fn(&T); + let mut _37: (&T,); + let _38: (); scope 1 { debug iter => _14; - let _36: &T; scope 2 { - debug x => _36; + debug x => ((_35 as Some).0: &T); } scope 18 (inlined > as Iterator>::next) { scope 19 (inlined as DoubleEndedIterator>::next_back) { @@ -181,7 +180,6 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () { } bb4: { - StorageLive(_35); StorageLive(_20); switchInt(const ::IS_ZST) -> [0: bb5, otherwise: bb6]; } @@ -285,25 +283,20 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () { StorageDead(_34); StorageDead(_20); StorageLive(_36); - _36 = copy ((_35 as Some).0: &T); + _36 = &_2; StorageLive(_37); - _37 = &_2; - StorageLive(_38); - _38 = (copy _36,); - _39 = >::call(move _37, move _38) -> [return: bb14, unwind unreachable]; + _37 = (copy ((_35 as Some).0: &T),); + _38 = >::call(move _36, move _37) -> [return: bb14, unwind unreachable]; } bb14: { - StorageDead(_38); StorageDead(_37); StorageDead(_36); - StorageDead(_35); goto -> bb4; } bb15: { StorageDead(_20); - StorageDead(_35); StorageDead(_14); drop(_2) -> [return: bb16, unwind unreachable]; } diff --git a/tests/mir-opt/pre-codegen/slice_iter.reverse_loop.runtime-optimized.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/slice_iter.reverse_loop.runtime-optimized.after.panic-unwind.mir index d0b125be28d4f..084ba71778036 100644 --- a/tests/mir-opt/pre-codegen/slice_iter.reverse_loop.runtime-optimized.after.panic-unwind.mir +++ b/tests/mir-opt/pre-codegen/slice_iter.reverse_loop.runtime-optimized.after.panic-unwind.mir @@ -8,14 +8,13 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () { let mut _13: std::iter::Rev>; let mut _14: std::iter::Rev>; let mut _35: std::option::Option<&T>; - let mut _37: &impl Fn(&T); - let mut _38: (&T,); - let _39: (); + let mut _36: &impl Fn(&T); + let mut _37: (&T,); + let _38: (); scope 1 { debug iter => _14; - let _36: &T; scope 2 { - debug x => _36; + debug x => ((_35 as Some).0: &T); } scope 18 (inlined > as Iterator>::next) { scope 19 (inlined as DoubleEndedIterator>::next_back) { @@ -181,7 +180,6 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () { } bb4: { - StorageLive(_35); StorageLive(_20); switchInt(const ::IS_ZST) -> [0: bb5, otherwise: bb6]; } @@ -285,19 +283,15 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () { StorageDead(_34); StorageDead(_20); StorageLive(_36); - _36 = copy ((_35 as Some).0: &T); + _36 = &_2; StorageLive(_37); - _37 = &_2; - StorageLive(_38); - _38 = (copy _36,); - _39 = >::call(move _37, move _38) -> [return: bb14, unwind: bb15]; + _37 = (copy ((_35 as Some).0: &T),); + _38 = >::call(move _36, move _37) -> [return: bb14, unwind: bb15]; } bb14: { - StorageDead(_38); StorageDead(_37); StorageDead(_36); - StorageDead(_35); goto -> bb4; } @@ -311,7 +305,6 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () { bb17: { StorageDead(_20); - StorageDead(_35); StorageDead(_14); drop(_2) -> [return: bb18, unwind continue]; } diff --git a/tests/mir-opt/pre-codegen/transmutes.prefix_of_array.runtime-optimized.after.mir b/tests/mir-opt/pre-codegen/transmutes.prefix_of_array.runtime-optimized.after.mir index 44eb659b39b44..d966eabc7c815 100644 --- a/tests/mir-opt/pre-codegen/transmutes.prefix_of_array.runtime-optimized.after.mir +++ b/tests/mir-opt/pre-codegen/transmutes.prefix_of_array.runtime-optimized.after.mir @@ -5,7 +5,6 @@ fn prefix_of_array(_1: [u32; 4]) -> [u32; 2] { let mut _0: [u32; 2]; scope 1 (inlined transmute_prefix::<[u32; 4], [u32; 2]>) { let _2: std::mem::transmute_prefix::Transmute<[u32; 4], [u32; 2]>; - let mut _3: std::mem::ManuallyDrop<[u32; 2]>; scope 2 { } scope 3 { @@ -19,10 +18,7 @@ fn prefix_of_array(_1: [u32; 4]) -> [u32; 2] { bb0: { StorageLive(_2); _2 = copy _1 as std::mem::transmute_prefix::Transmute<[u32; 4], [u32; 2]> (Transmute); - StorageLive(_3); - _3 = move (_2.1: std::mem::ManuallyDrop<[u32; 2]>); - _0 = copy _3 as [u32; 2] (Transmute); - StorageDead(_3); + _0 = copy (_2.1: std::mem::ManuallyDrop<[u32; 2]>) as [u32; 2] (Transmute); StorageDead(_2); return; } diff --git a/tests/mir-opt/pre-codegen/transmutes.rs b/tests/mir-opt/pre-codegen/transmutes.rs index d8369e839b6ba..e765c62e922cf 100644 --- a/tests/mir-opt/pre-codegen/transmutes.rs +++ b/tests/mir-opt/pre-codegen/transmutes.rs @@ -24,8 +24,7 @@ pub fn prefix_to_cast(x: f32) -> i32 { pub fn prefix_of_array(x: [u32; 4]) -> [u32; 2] { // CHECK-LABEL: fn prefix_of_array // CHECK: _2 = copy _1 as {{.+}}::Transmute<[u32; 4], [u32; 2]> (Transmute); - // CHECK: _3 = move (_2.1: {{.+}}::ManuallyDrop<[u32; 2]>); - // CHECK: _0 = copy _3 as [u32; 2] (Transmute); + // CHECK: _0 = copy (_2.1: {{.+}}::ManuallyDrop<[u32; 2]>) as [u32; 2] (Transmute); unsafe { transmute_prefix(x) } } diff --git a/tests/mir-opt/pre-codegen/try_identity.new.runtime-optimized.after.mir b/tests/mir-opt/pre-codegen/try_identity.new.runtime-optimized.after.mir index 6780fa4d3ea29..b00c5978c9ba3 100644 --- a/tests/mir-opt/pre-codegen/try_identity.new.runtime-optimized.after.mir +++ b/tests/mir-opt/pre-codegen/try_identity.new.runtime-optimized.after.mir @@ -4,51 +4,34 @@ fn new(_1: Result) -> Result { debug x => _1; let mut _0: std::result::Result; let mut _2: isize; - let _3: T; - let mut _4: std::ops::ControlFlow; - let _5: T; - let _6: E; - let _7: E; + let mut _3: std::ops::ControlFlow; scope 1 { - debug v => _3; + debug v => ((_1 as Ok).0: T); } scope 2 { - debug e => _6; + debug e => ((_1 as Err).0: E); } scope 3 { - debug v => _5; + debug v => ((_3 as Continue).0: T); } scope 4 { - debug e => _7; + debug e => ((_3 as Break).0: E); } bb0: { - StorageLive(_4); _2 = discriminant(_1); switchInt(move _2) -> [0: bb1, 1: bb2, otherwise: bb4]; } 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); + _3 = ControlFlow::::Continue(copy ((_1 as Ok).0: T)); + _0 = Result::::Ok(copy ((_3 as Continue).0: T)); goto -> bb3; } 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); + _3 = ControlFlow::::Break(copy ((_1 as Err).0: E)); + _0 = Result::::Err(copy ((_3 as Break).0: E)); goto -> bb3; } diff --git a/tests/mir-opt/pre-codegen/two_unwrap_unchecked.rs b/tests/mir-opt/pre-codegen/two_unwrap_unchecked.rs index 7b7d7b44d0f2b..f10c120600714 100644 --- a/tests/mir-opt/pre-codegen/two_unwrap_unchecked.rs +++ b/tests/mir-opt/pre-codegen/two_unwrap_unchecked.rs @@ -7,8 +7,7 @@ pub fn two_unwrap_unchecked(v: &Option) -> i32 { // CHECK-LABEL: fn two_unwrap_unchecked( // CHECK: [[DEREF_V:_.*]] = copy (*_1); - // CHECK: [[V1V2:_.*]] = copy (([[DEREF_V]] as Some).0: i32); - // CHECK: _0 = Add(copy [[V1V2]], copy [[V1V2]]); + // CHECK: _0 = Add(copy (([[DEREF_V]] as Some).0: i32), copy (([[DEREF_V]] as Some).0: i32)); let v1 = unsafe { v.unwrap_unchecked() }; let v2 = unsafe { v.unwrap_unchecked() }; v1 + v2 diff --git a/tests/mir-opt/pre-codegen/two_unwrap_unchecked.two_unwrap_unchecked.runtime-optimized.after.mir b/tests/mir-opt/pre-codegen/two_unwrap_unchecked.two_unwrap_unchecked.runtime-optimized.after.mir index 9853713df439b..8f3a12dc8dda3 100644 --- a/tests/mir-opt/pre-codegen/two_unwrap_unchecked.two_unwrap_unchecked.runtime-optimized.after.mir +++ b/tests/mir-opt/pre-codegen/two_unwrap_unchecked.two_unwrap_unchecked.runtime-optimized.after.mir @@ -5,11 +5,10 @@ fn two_unwrap_unchecked(_1: &Option) -> i32 { let mut _0: i32; let mut _2: std::option::Option; let mut _4: bool; - let _5: i32; scope 1 { - debug v1 => _5; + debug v1 => ((_2 as Some).0: i32); scope 2 { - debug v2 => _5; + debug v2 => ((_2 as Some).0: i32); } scope 8 (inlined #[track_caller] Option::::unwrap_unchecked) { scope 9 { @@ -35,14 +34,11 @@ fn two_unwrap_unchecked(_1: &Option) -> i32 { } bb0: { - StorageLive(_5); _2 = copy (*_1); _3 = discriminant(_2); _4 = Eq(copy _3, const 1_isize); assume(move _4); - _5 = copy ((_2 as Some).0: i32); - _0 = Add(copy _5, copy _5); - StorageDead(_5); + _0 = Add(copy ((_2 as Some).0: i32), copy ((_2 as Some).0: i32)); return; } } diff --git a/tests/mir-opt/separate_const_switch.identity.JumpThreading.diff b/tests/mir-opt/separate_const_switch.identity.JumpThreading.diff index 5bc79f76b3706..aff81e896eb1b 100644 --- a/tests/mir-opt/separate_const_switch.identity.JumpThreading.diff +++ b/tests/mir-opt/separate_const_switch.identity.JumpThreading.diff @@ -8,13 +8,13 @@ let mut _3: isize; let _4: std::result::Result; let _5: i32; + let mut _10: i32; scope 1 { debug residual => _4; scope 2 { scope 8 (inlined #[track_caller] as FromResidual>>::from_residual) { - let mut _10: isize; - let _11: i32; - let mut _12: bool; + let mut _8: isize; + let mut _9: bool; scope 9 { scope 10 (inlined >::from) { } @@ -29,9 +29,7 @@ } scope 5 (inlined as Try>::branch) { let mut _6: isize; - let _7: i32; - let _8: i32; - let mut _9: std::result::Result; + let mut _7: std::result::Result; scope 6 { } scope 7 { @@ -59,17 +57,15 @@ bb3: { StorageLive(_4); _4 = copy ((_2 as Break).0: std::result::Result); - StorageLive(_10); - StorageLive(_12); - _10 = discriminant(_4); - _12 = Eq(copy _10, const 1_isize); - assume(move _12); - StorageLive(_11); - _11 = copy ((_4 as Err).0: i32); - _0 = Result::::Err(copy _11); - StorageDead(_11); - StorageDead(_12); - StorageDead(_10); + StorageLive(_8); + StorageLive(_9); + _8 = discriminant(_4); + _9 = Eq(copy _8, const 1_isize); + assume(move _9); + _10 = copy ((_4 as Err).0: i32); + _0 = Result::::Err(copy _10); + StorageDead(_9); + StorageDead(_8); StorageDead(_4); StorageDead(_2); return; @@ -82,22 +78,16 @@ } 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); + StorageLive(_7); + _7 = Result::::Err(copy ((_1 as Err).0: i32)); + _2 = ControlFlow::, i32>::Break(move _7); + StorageDead(_7); - goto -> bb4; + goto -> bb7; } bb6: { - StorageLive(_7); - _7 = copy ((_1 as Ok).0: i32); - _2 = ControlFlow::, i32>::Continue(copy _7); - StorageDead(_7); + _2 = ControlFlow::, i32>::Continue(copy ((_1 as Ok).0: i32)); - goto -> bb4; + goto -> bb8; + }