Rollup merge of #129720 - nnethercote:simplify-dest_prop-mm, r=cjgillot

Simplify DestProp memory management
The DestProp MIR pass has some convoluted memory management. This PR simplifies it.
r? ```@davidtwco```

Author: matthiaskrgr

compiler/rustc_mir_transform/src/dest_prop.rs

@@ -163,7 +163,8 @@ impl<'tcx> crate::MirPass<'tcx> for DestinationPropagation {
 
 fnrun_pass(&self,tcx:TyCtxt<'tcx>,body:&mutBody<'tcx>){
 let def_id = body.source.def_id();
-letmut allocations = Allocations::default();
+letmut candidates = Candidates::default();
+letmut write_info = WriteInfo::default();
 trace!(func = ?tcx.def_path_str(def_id));
 
 let borrowed = rustc_mir_dataflow::impls::borrowed_locals(body);
@@ -191,20 +192,15 @@ impl<'tcx> crate::MirPass<'tcx> for DestinationPropagation {
 loop{
 // PERF: Can we do something smarter than recalculating the candidates and liveness
 // results?
-letmut candidates = find_candidates(
- body,
-&borrowed,
-&mut allocations.candidates,
-&mut allocations.candidates_reverse,
-);
+ candidates.reset_and_find(body,&borrowed);
 trace!(?candidates);
 dest_prop_mir_dump(tcx, body,&points,&live, round_count);
 
 FilterInformation::filter_liveness(
 &mut candidates,
 &points,
 &live,
-&mutallocations.write_info,
+&mut write_info,
  body,
 );
 
@@ -253,20 +249,8 @@ impl<'tcx> crate::MirPass<'tcx> for DestinationPropagation {
 }
 }
 
-/// Container for the various allocations that we need.
-///
-/// We store these here and hand out `&mut` access to them, instead of dropping and recreating them
-/// frequently. Everything with a `&'alloc` lifetime points into here.
-#[derive(Default)]
-structAllocations{
-candidates:FxIndexMap<Local,Vec<Local>>,
-candidates_reverse:FxIndexMap<Local,Vec<Local>>,
-write_info:WriteInfo,
-// PERF: Do this for `MaybeLiveLocals` allocations too.
-}
-
-#[derive(Debug)]
-structCandidates<'alloc>{
+#[derive(Debug,Default)]
+structCandidates{
 /// The set of candidates we are considering in this optimization.
 ///
 /// We will always merge the key into at most one of its values.
@@ -281,11 +265,12 @@ struct Candidates<'alloc> {
 ///
 /// We will still report that we would like to merge `_1` and `_2` in an attempt to allow us to
 /// remove that assignment.
-c:&'allocmutFxIndexMap<Local,Vec<Local>>,
+c:FxIndexMap<Local,Vec<Local>>,
+
 /// A reverse index of the `c` set; if the `c` set contains `a => Place { local: b, proj }`,
 /// then this contains `b => a`.
 // PERF: Possibly these should be `SmallVec`s?
-reverse:&'allocmutFxIndexMap<Local,Vec<Local>>,
+reverse:FxIndexMap<Local,Vec<Local>>,
 }
 
 //////////////////////////////////////////////////////////
@@ -358,19 +343,40 @@ impl<'a, 'tcx> MutVisitor<'tcx> for Merger<'a, 'tcx> {
 //
 // This section enforces bullet point 2
 
-structFilterInformation<'a,'body,'alloc,'tcx>{
-body:&'bodyBody<'tcx>,
+structFilterInformation<'a,'tcx>{
+body:&'aBody<'tcx>,
 points:&'aDenseLocationMap,
 live:&'aSparseIntervalMatrix<Local,PointIndex>,
-candidates:&'amutCandidates<'alloc>,
-write_info:&'allocmutWriteInfo,
+candidates:&'amutCandidates,
+write_info:&'amutWriteInfo,
 at:Location,
 }
 
 // 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<'alloc>Candidates<'alloc>{
+implCandidates{
+/// Collects the candidates for merging.
+///
+/// This is responsible for enforcing the first and third bullet point.
+fnreset_and_find<'tcx>(&mutself,body:&Body<'tcx>,borrowed:&BitSet<Local>){
+self.c.clear();
+self.reverse.clear();
+letmut visitor = FindAssignments{ body,candidates:&mutself.c, borrowed };
+ visitor.visit_body(body);
+// Deduplicate candidates.
+for(_, cands)inself.c.iter_mut(){
+ cands.sort();
+ cands.dedup();
+}
+// Generate the reverse map.
+for(src, cands)inself.c.iter(){
+for dest in cands.iter().copied(){
+self.reverse.entry(dest).or_default().push(*src);
+}
+}
+}
+
 /// Just `Vec::retain`, but the condition is inverted and we add debugging output
 fnvec_filter_candidates(
 src:Local,
@@ -445,7 +451,7 @@ enum CandidateFilter {
 Remove,
 }
 
-impl<'a,'body,'alloc,'tcx>FilterInformation<'a,'body,'alloc,'tcx>{
+impl<'a,'tcx>FilterInformation<'a,'tcx>{
 /// Filters the set of candidates to remove those that conflict.
 ///
 /// The steps we take are exactly those that are outlined at the top of the file. For each
@@ -463,12 +469,12 @@ impl<'a, 'body, 'alloc, 'tcx> FilterInformation<'a, 'body, 'alloc, 'tcx> {
 /// before the statement/terminator will correctly report locals that are read in the
 /// statement/terminator to be live. We are additionally conservative by treating all written to
 /// locals as also being read from.
-fnfilter_liveness<'b>(
-candidates:&mutCandidates<'alloc>,
+fnfilter_liveness(
+candidates:&mutCandidates,
 points:&DenseLocationMap,
 live:&SparseIntervalMatrix<Local,PointIndex>,
-write_info_alloc:&'allocmutWriteInfo,
-body:&'bBody<'tcx>,
+write_info:&mutWriteInfo,
+body:&Body<'tcx>,
 ){
 letmut this = FilterInformation{
  body,
@@ -477,7 +483,7 @@ impl<'a, 'body, 'alloc, 'tcx> FilterInformation<'a, 'body, 'alloc, 'tcx> {
  candidates,
 // We don't actually store anything at this scope, we just keep things here to be able
 // to reuse the allocation.
-write_info: write_info_alloc,
+ write_info,
 // Doesn't matter what we put here, will be overwritten before being used
 at:Location::START,
 };
@@ -734,40 +740,13 @@ fn places_to_candidate_pair<'tcx>(
 Some((a, b))
 }
 
-/// Collects the candidates for merging
-///
-/// This is responsible for enforcing the first and third bullet point.
-fnfind_candidates<'alloc,'tcx>(
-body:&Body<'tcx>,
-borrowed:&BitSet<Local>,
-candidates:&'allocmutFxIndexMap<Local,Vec<Local>>,
-candidates_reverse:&'allocmutFxIndexMap<Local,Vec<Local>>,
-) -> Candidates<'alloc>{
- candidates.clear();
- candidates_reverse.clear();
-letmut visitor = FindAssignments{ body, candidates, borrowed };
- visitor.visit_body(body);
-// Deduplicate candidates
-for(_, cands)in candidates.iter_mut(){
- cands.sort();
- cands.dedup();
-}
-// Generate the reverse map
-for(src, cands)in candidates.iter(){
-for dest in cands.iter().copied(){
- candidates_reverse.entry(dest).or_default().push(*src);
-}
-}
-Candidates{c: candidates,reverse: candidates_reverse }
-}
-
-structFindAssignments<'a,'alloc,'tcx>{
+structFindAssignments<'a,'tcx>{
 body:&'aBody<'tcx>,
-candidates:&'allocmutFxIndexMap<Local,Vec<Local>>,
+candidates:&'amutFxIndexMap<Local,Vec<Local>>,
 borrowed:&'aBitSet<Local>,
 }
 
-impl<'tcx>Visitor<'tcx>forFindAssignments<'_,'_,'tcx>{
+impl<'tcx>Visitor<'tcx>forFindAssignments<'_,'tcx>{
 fnvisit_statement(&mutself,statement:&Statement<'tcx>, _:Location){
 ifletStatementKind::Assign(box (
  lhs,
@@ -819,9 +798,9 @@ fn is_local_required(local: Local, body: &Body<'_>) -> bool {
 /////////////////////////////////////////////////////////
 // MIR Dump
 
-fndest_prop_mir_dump<'body,'tcx>(
+fndest_prop_mir_dump<'tcx>(
 tcx:TyCtxt<'tcx>,
-body:&'bodyBody<'tcx>,
+body:&Body<'tcx>,
 points:&DenseLocationMap,
 live:&SparseIntervalMatrix<Local,PointIndex>,
 round:usize,