use new analysis in generator transform

Author: b-naber

compiler/rustc_mir_transform/src/generator.rs

@@ -67,8 +67,8 @@ use rustc_middle::mir::*;
 use rustc_middle::ty::{self, AdtDef, Ty, TyCtxt};
 use rustc_middle::ty::{GeneratorSubsts, SubstsRef};
 use rustc_mir_dataflow::impls::{
-    get_borrowed_locals_results, MaybeBorrowedLocals, MaybeLiveLocals, MaybeRequiresStorage,
-    MaybeStorageLive,
+    get_borrowed_locals_results, BorrowedLocalsResultsCursor, MaybeLiveLocals,
+    MaybeRequiresStorage, MaybeStorageLive,
 };
 use rustc_mir_dataflow::storage::always_storage_live_locals;
 use rustc_mir_dataflow::{self, Analysis};
@@ -593,22 +593,18 @@ fn locals_live_across_suspend_points<'tcx>(
         .iterate_to_fixpoint()
         .into_results_cursor(body_ref);
 
-    // Calculate the MIR locals which have been previously
-    // borrowed (even if they are still active).
-    let borrowed_locals_results =
-        MaybeBorrowedLocals.into_engine(tcx, body_ref).pass_name("generator").iterate_to_fixpoint();
-
-    let mut borrowed_locals_cursor = borrowed_locals_results.cloned_results_cursor(body_ref);
-
-    let mut live_borrows_cursor = get_borrowed_locals_results(body, tcx);
+    // Calculate the locals that are live due to outstanding references or pointers.
+    let live_borrows_results = get_borrowed_locals_results(body_ref, tcx);
+    let mut live_borrows_cursor = BorrowedLocalsResultsCursor::new(body_ref, &live_borrows_results);
 
     // Calculate the MIR locals that we actually need to keep storage around
     // for.
-    let mut requires_storage_results =
-        MaybeRequiresStorage::new(borrowed_locals_results.cloned_results_cursor(body))
-            .into_engine(tcx, body_ref)
-            .iterate_to_fixpoint();
-    let mut requires_storage_cursor = requires_storage_results.as_results_cursor(body_ref);
+    let requires_storage_results = MaybeRequiresStorage::new(body, &live_borrows_results)
+        .into_engine(tcx, body_ref)
+        .iterate_to_fixpoint();
+
+    let mut requires_storage_cursor =
+        rustc_mir_dataflow::ResultsCursor::new(body_ref, &requires_storage_results);
 
     // Calculate the liveness of MIR locals ignoring borrows.
     let mut liveness = MaybeLiveLocals
@@ -623,21 +619,9 @@ fn locals_live_across_suspend_points<'tcx>(
     let mut live_locals_at_any_suspension_point = BitSet::new_empty(body.local_decls.len());
 
     for (block, data) in body.basic_blocks.iter_enumerated() {
-        for (i, stmt) in data.statements.iter().enumerate() {
-            debug!(?stmt);
-            let loc = Location { block, statement_index: i };
-            debug!("live_borrows_cursor seek before");
-            live_borrows_cursor.seek_before_primary_effect(loc);
-            debug!("finished seek before");
-            let live_borrowed_locals = live_borrows_cursor.get();
-            debug!(?live_borrowed_locals);
-        }
-
         debug!(?block, ?data.terminator);
         if let TerminatorKind::Yield { .. } = data.terminator().kind {
             let loc = Location { block, statement_index: data.statements.len() };
-            debug!("encountered Yield at loc {:?}", loc);
-
             liveness.seek_to_block_end(block);
             let mut live_locals: BitSet<_> = BitSet::new_empty(body.local_decls.len());
             live_locals.union(liveness.get());
@@ -653,13 +637,7 @@ fn locals_live_across_suspend_points<'tcx>(
                 // If a borrow is converted to a raw reference, we must also assume that it lives
                 // forever. Note that the final liveness is still bounded by the storage liveness
                 // of the local, which happens using the `intersect` operation below.
-                borrowed_locals_cursor.seek_before_primary_effect(loc);
-                let current_borrowed_locals = borrowed_locals_cursor.get();
-
-                debug!("live_borrows_cursor seek before");
-                live_borrows_cursor.seek_before_primary_effect(loc);
-                debug!("finished seek before");
-                let live_borrowed_locals = live_borrows_cursor.get();
+                let live_borrowed_locals = live_borrows_cursor.get(loc);
 
                 let mut live_locals_stmt: BitSet<_> = BitSet::new_empty(body.local_decls.len());
                 liveness.seek_before_primary_effect(loc);
@@ -669,12 +647,11 @@ fn locals_live_across_suspend_points<'tcx>(
                 requires_storage_cursor.seek_before_primary_effect(loc);
                 storage_req.union(requires_storage_cursor.get());
 
-                debug!(?current_borrowed_locals);
                 debug!(?live_borrowed_locals);
                 debug!(?live_locals_stmt);
                 debug!(?storage_req);
 
-                live_locals.union(current_borrowed_locals);
+                live_locals.union(&live_borrowed_locals);
             }
 
             // Store the storage liveness for later use so we can restore the state
@@ -686,7 +663,8 @@ fn locals_live_across_suspend_points<'tcx>(
             // suspension points (the `liveness` variable)
             // and their storage is required (the `storage_required` variable)
             requires_storage_cursor.seek_before_primary_effect(loc);
-            live_locals.intersect(requires_storage_cursor.get());
+            let storage_required = requires_storage_cursor.get();
+            live_locals.intersect(storage_required);
 
             // The generator argument is ignored.
             live_locals.remove(SELF_ARG);
@@ -777,11 +755,11 @@ impl ops::Deref for GeneratorSavedLocals {
 /// time. Generates a bitset for every local of all the other locals that may be
 /// StorageLive simultaneously with that local. This is used in the layout
 /// computation; see `GeneratorLayout` for more.
-fn compute_storage_conflicts<'mir, 'tcx>(
+fn compute_storage_conflicts<'a, 'mir, 'tcx>(
     body: &'mir Body<'tcx>,
     saved_locals: &GeneratorSavedLocals,
     always_live_locals: BitSet<Local>,
-    mut requires_storage: rustc_mir_dataflow::Results<'tcx, MaybeRequiresStorage<'_, 'mir, 'tcx>>,
+    requires_storage: rustc_mir_dataflow::Results<'tcx, MaybeRequiresStorage<'a, 'mir, 'tcx>>,
 ) -> BitMatrix<GeneratorSavedLocal, GeneratorSavedLocal> {
     assert_eq!(body.local_decls.len(), saved_locals.domain_size());