Try MaybeLiveLocals for borrows

Author: dianqk

compiler/rustc_mir_transform/src/gvn.rs

@@ -86,6 +86,7 @@
 
 use std::borrow::Cow;
 use std::hash::{Hash, Hasher};
+use std::ops::Range;
 
 use either::Either;
 use hashbrown::hash_table::{Entry, HashTable};
@@ -108,6 +109,8 @@ use rustc_middle::mir::visit::*;
 use rustc_middle::mir::*;
 use rustc_middle::ty::layout::HasTypingEnv;
 use rustc_middle::ty::{self, Ty, TyCtxt};
+use rustc_mir_dataflow::impls::MaybeLiveLocals;
+use rustc_mir_dataflow::{Analysis as _, ResultsCursor};
 use rustc_span::DUMMY_SP;
 use smallvec::SmallVec;
 use tracing::{debug, instrument, trace};
@@ -130,8 +133,37 @@ impl<'tcx> crate::MirPass<'tcx> for GVN {
         // Clone dominators because we need them while mutating the body.
         let dominators = body.basic_blocks.dominators().clone();
 
+        let mut borrow_liveness: IndexVec<
+            Local,
+            Option<IndexVec<BasicBlock, Option<Range<usize>>>>,
+        > = IndexVec::from_elem(None, body.local_decls());
+
         let immutable_borrows = ImmutableBorrows::new(tcx, body, typing_env, &ssa);
 
+        for (local, _) in body.local_decls.iter_enumerated() {
+            if !immutable_borrows.locals.contains(local) {
+                continue;
+            }
+            if immutable_borrows.always_live.contains(local) {
+                continue;
+            }
+            borrow_liveness[local] = Some(IndexVec::from_elem(None, &body.basic_blocks));
+        }
+
+        let mut liveness = MaybeLiveLocals
+            .iterate_to_fixpoint(tcx, body, Some("MaybeLiveLocals-GVN"))
+            .into_results_cursor(body);
+
+        for (bb, bb_data) in traversal::preorder(body) {
+            liveness.seek_to_block_end(bb);
+            let live_locals = liveness.get();
+            for local in live_locals.iter() {
+                if let Some(ref mut liveness) = borrow_liveness[local] {
+                    liveness[bb] = Some(0..bb_data.statements.len());
+                }
+            }
+        }
+
         let arena = DroplessArena::default();
         let mut state = VnState::new(
             tcx,
@@ -141,7 +173,7 @@ impl<'tcx> crate::MirPass<'tcx> for GVN {
             dominators,
             &body.local_decls,
             &arena,
-            immutable_borrows,
+            borrow_liveness,
         );
 
         for local in body.args_iter().filter(|&local| ssa.is_ssa(local)) {
@@ -382,7 +414,7 @@ struct VnState<'body, 'a, 'tcx> {
     dominators: Dominators<BasicBlock>,
     reused_locals: DenseBitSet<Local>,
     arena: &'a DroplessArena,
-    immutable_borrows: ImmutableBorrows,
+    borrow_liveness: IndexVec<Local, Option<IndexVec<BasicBlock, Option<Range<usize>>>>>,
 }
 
 impl<'body, 'a, 'tcx> VnState<'body, 'a, 'tcx> {
@@ -394,7 +426,7 @@ impl<'body, 'a, 'tcx> VnState<'body, 'a, 'tcx> {
         dominators: Dominators<BasicBlock>,
         local_decls: &'body LocalDecls<'tcx>,
         arena: &'a DroplessArena,
-        immutable_borrows: ImmutableBorrows,
+        borrow_liveness: IndexVec<Local, Option<IndexVec<BasicBlock, Option<Range<usize>>>>>,
     ) -> Self {
         // Compute a rough estimate of the number of values in the body from the number of
         // statements. This is meant to reduce the number of allocations, but it's all right if
@@ -416,7 +448,7 @@ impl<'body, 'a, 'tcx> VnState<'body, 'a, 'tcx> {
             dominators,
             reused_locals: DenseBitSet::new_empty(local_decls.len()),
             arena,
-            immutable_borrows,
+            borrow_liveness,
         }
     }
 
@@ -1870,10 +1902,11 @@ impl<'tcx> VnState<'_, '_, 'tcx> {
                 if !self.ssa.assignment_dominates(&self.dominators, other, loc) {
                     return false;
                 }
-                if self.immutable_borrows.locals.contains(other)
-                    && !self.immutable_borrows.always_live.contains(other)
-                {
-                    return false;
+                if let Some(ref liveness) = self.borrow_liveness[other] {
+                    return liveness[loc.block]
+                        .as_ref()
+                        .map(|range| range.contains(&loc.statement_index))
+                        .unwrap_or(false);
                 }
                 return true;
             })