add option to run dataflow on live code only

Author: zeegomo

compiler/rustc_borrowck/src/lib.rs

@@ -48,8 +48,8 @@ use rustc_mir_dataflow::impls::{
 };
 use rustc_mir_dataflow::move_paths::{InitIndex, MoveOutIndex, MovePathIndex};
 use rustc_mir_dataflow::move_paths::{InitLocation, LookupResult, MoveData, MoveError};
-use rustc_mir_dataflow::Analysis;
 use rustc_mir_dataflow::MoveDataParamEnv;
+use rustc_mir_dataflow::{Analysis, Blocks};
 
 use crate::session_diagnostics::VarNeedNotMut;
 
@@ -234,7 +234,7 @@ fn do_mir_borrowck<'tcx>(
     let mdpe = MoveDataParamEnv { move_data, param_env };
 
     let mut flow_inits = MaybeInitializedPlaces::new(tcx, &body, &mdpe)
-        .into_engine(tcx, &body)
+        .into_engine(tcx, &body, Blocks::All)
         .pass_name("borrowck")
         .iterate_to_fixpoint()
         .into_results_cursor(&body);
@@ -290,15 +290,15 @@ fn do_mir_borrowck<'tcx>(
     let regioncx = Rc::new(regioncx);
 
     let flow_borrows = Borrows::new(tcx, body, &regioncx, &borrow_set)
-        .into_engine(tcx, body)
+        .into_engine(tcx, body, Blocks::All)
         .pass_name("borrowck")
         .iterate_to_fixpoint();
     let flow_uninits = MaybeUninitializedPlaces::new(tcx, body, &mdpe)
-        .into_engine(tcx, body)
+        .into_engine(tcx, body, Blocks::All)
         .pass_name("borrowck")
         .iterate_to_fixpoint();
     let flow_ever_inits = EverInitializedPlaces::new(tcx, body, &mdpe)
-        .into_engine(tcx, body)
+        .into_engine(tcx, body, Blocks::All)
         .pass_name("borrowck")
         .iterate_to_fixpoint();
 

compiler/rustc_const_eval/src/transform/check_consts/check.rs

@@ -11,7 +11,7 @@ use rustc_middle::mir::*;
 use rustc_middle::ty::subst::{GenericArgKind, InternalSubsts};
 use rustc_middle::ty::{self, adjustment::PointerCast, Instance, InstanceDef, Ty, TyCtxt};
 use rustc_middle::ty::{Binder, TraitRef, TypeVisitable};
-use rustc_mir_dataflow::{self, Analysis};
+use rustc_mir_dataflow::{self, Analysis, Blocks};
 use rustc_span::{sym, Span, Symbol};
 use rustc_trait_selection::traits::error_reporting::TypeErrCtxtExt as _;
 use rustc_trait_selection::traits::{self, ObligationCauseCode, ObligationCtxt, SelectionContext};
@@ -58,7 +58,7 @@ impl<'mir, 'tcx> Qualifs<'mir, 'tcx> {
             let ConstCx { tcx, body, .. } = *ccx;
 
             FlowSensitiveAnalysis::new(NeedsDrop, ccx)
-                .into_engine(tcx, &body)
+                .into_engine(tcx, &body, Blocks::All)
                 .iterate_to_fixpoint()
                 .into_results_cursor(&body)
         });
@@ -85,7 +85,7 @@ impl<'mir, 'tcx> Qualifs<'mir, 'tcx> {
             let ConstCx { tcx, body, .. } = *ccx;
 
             FlowSensitiveAnalysis::new(NeedsNonConstDrop, ccx)
-                .into_engine(tcx, &body)
+                .into_engine(tcx, &body, Blocks::All)
                 .iterate_to_fixpoint()
                 .into_results_cursor(&body)
         });
@@ -115,7 +115,7 @@ impl<'mir, 'tcx> Qualifs<'mir, 'tcx> {
             let ConstCx { tcx, body, .. } = *ccx;
 
             FlowSensitiveAnalysis::new(HasMutInterior, ccx)
-                .into_engine(tcx, &body)
+                .into_engine(tcx, &body, Blocks::All)
                 .iterate_to_fixpoint()
                 .into_results_cursor(&body)
         });
@@ -163,7 +163,7 @@ impl<'mir, 'tcx> Qualifs<'mir, 'tcx> {
 
             hir::ConstContext::Const | hir::ConstContext::Static(_) => {
                 let mut cursor = FlowSensitiveAnalysis::new(CustomEq, ccx)
-                    .into_engine(ccx.tcx, &ccx.body)
+                    .into_engine(ccx.tcx, &ccx.body, Blocks::All)
                     .iterate_to_fixpoint()
                     .into_results_cursor(&ccx.body);
 

compiler/rustc_const_eval/src/transform/validate.rs

@@ -15,7 +15,7 @@ use rustc_middle::mir::{
 use rustc_middle::ty::{self, InstanceDef, ParamEnv, Ty, TyCtxt, TypeVisitable};
 use rustc_mir_dataflow::impls::MaybeStorageLive;
 use rustc_mir_dataflow::storage::always_storage_live_locals;
-use rustc_mir_dataflow::{Analysis, ResultsCursor};
+use rustc_mir_dataflow::{Analysis, Blocks, ResultsCursor};
 use rustc_target::abi::{Size, VariantIdx};
 
 #[derive(Copy, Clone, Debug)]
@@ -53,7 +53,7 @@ impl<'tcx> MirPass<'tcx> for Validator {
 
         let always_live_locals = always_storage_live_locals(body);
         let storage_liveness = MaybeStorageLive::new(std::borrow::Cow::Owned(always_live_locals))
-            .into_engine(tcx, body)
+            .into_engine(tcx, body, Blocks::All)
             .iterate_to_fixpoint()
             .into_results_cursor(body);
 

compiler/rustc_mir_dataflow/src/framework/engine.rs

@@ -71,6 +71,13 @@ where
     }
 }
 
+pub enum Blocks {
+    /// Consider all MIR blocks
+    All,
+    /// Consider only the MIR blocks reachable from the start
+    Reachable,
+}
+
 /// A solver for dataflow problems.
 pub struct Engine<'a, 'tcx, A>
 where
@@ -90,6 +97,7 @@ where
     // performance in practice. I've tried a few ways to avoid this, but they have downsides. See
     // the message for the commit that added this FIXME for more information.
     apply_trans_for_block: Option<Box<dyn Fn(BasicBlock, &mut A::Domain)>>,
+    blocks: Blocks,
 }
 
 impl<'a, 'tcx, A, D, T> Engine<'a, 'tcx, A>
@@ -99,13 +107,18 @@ where
     T: Idx,
 {
     /// Creates a new `Engine` to solve a gen-kill dataflow problem.
-    pub fn new_gen_kill(tcx: TyCtxt<'tcx>, body: &'a mir::Body<'tcx>, analysis: A) -> Self {
+    pub fn new_gen_kill(
+        tcx: TyCtxt<'tcx>,
+        body: &'a mir::Body<'tcx>,
+        analysis: A,
+        blocks: Blocks,
+    ) -> Self {
         // If there are no back-edges in the control-flow graph, we only ever need to apply the
         // transfer function for each block exactly once (assuming that we process blocks in RPO).
         //
         // In this case, there's no need to compute the block transfer functions ahead of time.
         if !body.basic_blocks.is_cfg_cyclic() {
-            return Self::new(tcx, body, analysis, None);
+            return Self::new(tcx, body, analysis, None, blocks);
         }
 
         // Otherwise, compute and store the cumulative transfer function for each block.
@@ -122,7 +135,7 @@ where
             trans_for_block[bb].apply(state);
         });
 
-        Self::new(tcx, body, analysis, Some(apply_trans as Box<_>))
+        Self::new(tcx, body, analysis, Some(apply_trans as Box<_>), blocks)
     }
 }
 
@@ -136,15 +149,21 @@ where
     ///
     /// Gen-kill problems should use `new_gen_kill`, which will coalesce transfer functions for
     /// better performance.
-    pub fn new_generic(tcx: TyCtxt<'tcx>, body: &'a mir::Body<'tcx>, analysis: A) -> Self {
-        Self::new(tcx, body, analysis, None)
+    pub fn new_generic(
+        tcx: TyCtxt<'tcx>,
+        body: &'a mir::Body<'tcx>,
+        analysis: A,
+        blocks: Blocks,
+    ) -> Self {
+        Self::new(tcx, body, analysis, None, blocks)
     }
 
     fn new(
         tcx: TyCtxt<'tcx>,
         body: &'a mir::Body<'tcx>,
         analysis: A,
         apply_trans_for_block: Option<Box<dyn Fn(BasicBlock, &mut A::Domain)>>,
+        blocks: Blocks,
     ) -> Self {
         let bottom_value = analysis.bottom_value(body);
         let mut entry_sets = IndexVec::from_elem(bottom_value.clone(), &body.basic_blocks);
@@ -162,6 +181,7 @@ where
             pass_name: None,
             entry_sets,
             apply_trans_for_block,
+            blocks,
         }
     }
 
@@ -197,21 +217,32 @@ where
             tcx,
             apply_trans_for_block,
             pass_name,
+            blocks,
             ..
         } = self;
 
         let mut dirty_queue: WorkQueue<BasicBlock> = WorkQueue::with_none(body.basic_blocks.len());
+        // could be tracked in `entry_sets`
+        let mut visited = BitSet::new_empty(body.basic_blocks.len());
 
         if A::Direction::IS_FORWARD {
-            for (bb, _) in traversal::reverse_postorder(body) {
-                dirty_queue.insert(bb);
+            match blocks {
+                Blocks::All => {
+                    for (bb, _) in traversal::reverse_postorder(body) {
+                        dirty_queue.insert(bb);
+                    }
+                }
+                Blocks::Reachable => {
+                    dirty_queue.insert(mir::START_BLOCK);
+                }
             }
         } else {
             // Reverse post-order on the reverse CFG may generate a better iteration order for
             // backward dataflow analyses, but probably not enough to matter.
             for (bb, _) in traversal::postorder(body) {
                 dirty_queue.insert(bb);
             }
+            assert!(matches!(blocks, Blocks::All));
         }
 
         // `state` is not actually used between iterations;
@@ -241,8 +272,9 @@ where
                 (bb, bb_data),
                 |target: BasicBlock, state: &A::Domain| {
                     let set_changed = entry_sets[target].join(state);
-                    if set_changed {
+                    if set_changed || !visited.contains(target) {
                         dirty_queue.insert(target);
+                        visited.insert(target);
                     }
                 },
             );

compiler/rustc_mir_dataflow/src/framework/mod.rs

@@ -47,7 +47,7 @@ mod visitor;
 
 pub use self::cursor::{ResultsCursor, ResultsRefCursor};
 pub use self::direction::{Backward, Direction, Forward};
-pub use self::engine::{Engine, Results};
+pub use self::engine::{Blocks, Engine, Results};
 pub use self::lattice::{JoinSemiLattice, MeetSemiLattice};
 pub use self::visitor::{visit_results, ResultsVisitable, ResultsVisitor};
 
@@ -261,11 +261,12 @@ pub trait Analysis<'tcx>: AnalysisDomain<'tcx> {
         self,
         tcx: TyCtxt<'tcx>,
         body: &'mir mir::Body<'tcx>,
+        blocks: Blocks,
     ) -> Engine<'mir, 'tcx, Self>
     where
         Self: Sized,
     {
-        Engine::new_generic(tcx, body, self)
+        Engine::new_generic(tcx, body, self, blocks)
     }
 }
 
@@ -419,11 +420,12 @@ where
         self,
         tcx: TyCtxt<'tcx>,
         body: &'mir mir::Body<'tcx>,
+        blocks: Blocks,
     ) -> Engine<'mir, 'tcx, Self>
     where
         Self: Sized,
     {
-        Engine::new_gen_kill(tcx, body, self)
+        Engine::new_gen_kill(tcx, body, self, blocks)
     }
 }
 

compiler/rustc_mir_dataflow/src/lib.rs

@@ -25,9 +25,10 @@ pub use self::drop_flag_effects::{
     on_lookup_result_bits,
 };
 pub use self::framework::{
-    fmt, graphviz, lattice, visit_results, Analysis, AnalysisDomain, Backward, CallReturnPlaces,
-    Direction, Engine, Forward, GenKill, GenKillAnalysis, JoinSemiLattice, Results, ResultsCursor,
-    ResultsRefCursor, ResultsVisitable, ResultsVisitor, SwitchIntEdgeEffects,
+    fmt, graphviz, lattice, visit_results, Analysis, AnalysisDomain, Backward, Blocks,
+    CallReturnPlaces, Direction, Engine, Forward, GenKill, GenKillAnalysis, JoinSemiLattice,
+    Results, ResultsCursor, ResultsRefCursor, ResultsVisitable, ResultsVisitor,
+    SwitchIntEdgeEffects,
 };
 
 use self::move_paths::MoveData;

compiler/rustc_mir_dataflow/src/rustc_peek.rs

@@ -10,7 +10,7 @@ use crate::errors::{
     PeekArgumentNotALocal, PeekArgumentUntracked, PeekBitNotSet, PeekMustBeNotTemporary,
     PeekMustBePlaceOrRefPlace, StopAfterDataFlowEndedCompilation,
 };
-use crate::framework::BitSetExt;
+use crate::framework::{BitSetExt, Blocks};
 use crate::impls::{
     DefinitelyInitializedPlaces, MaybeInitializedPlaces, MaybeLiveLocals, MaybeUninitializedPlaces,
 };
@@ -39,30 +39,31 @@ impl<'tcx> MirPass<'tcx> for SanityCheck {
 
         if has_rustc_mir_with(tcx, def_id, sym::rustc_peek_maybe_init).is_some() {
             let flow_inits = MaybeInitializedPlaces::new(tcx, body, &mdpe)
-                .into_engine(tcx, body)
+                .into_engine(tcx, body, Blocks::All)
                 .iterate_to_fixpoint();
 
             sanity_check_via_rustc_peek(tcx, body, &flow_inits);
         }
 
         if has_rustc_mir_with(tcx, def_id, sym::rustc_peek_maybe_uninit).is_some() {
             let flow_uninits = MaybeUninitializedPlaces::new(tcx, body, &mdpe)
-                .into_engine(tcx, body)
+                .into_engine(tcx, body, Blocks::All)
                 .iterate_to_fixpoint();
 
             sanity_check_via_rustc_peek(tcx, body, &flow_uninits);
         }
 
         if has_rustc_mir_with(tcx, def_id, sym::rustc_peek_definite_init).is_some() {
             let flow_def_inits = DefinitelyInitializedPlaces::new(tcx, body, &mdpe)
-                .into_engine(tcx, body)
+                .into_engine(tcx, body, Blocks::All)
                 .iterate_to_fixpoint();
 
             sanity_check_via_rustc_peek(tcx, body, &flow_def_inits);
         }
 
         if has_rustc_mir_with(tcx, def_id, sym::rustc_peek_liveness).is_some() {
-            let flow_liveness = MaybeLiveLocals.into_engine(tcx, body).iterate_to_fixpoint();
+            let flow_liveness =
+                MaybeLiveLocals.into_engine(tcx, body, Blocks::All).iterate_to_fixpoint();
 
             sanity_check_via_rustc_peek(tcx, body, &flow_liveness);
         }

compiler/rustc_mir_transform/src/dataflow_const_prop.rs

@@ -9,7 +9,9 @@ use rustc_middle::mir::visit::{MutVisitor, Visitor};
 use rustc_middle::mir::*;
 use rustc_middle::ty::{self, Ty, TyCtxt};
 use rustc_mir_dataflow::value_analysis::{Map, State, TrackElem, ValueAnalysis, ValueOrPlace};
-use rustc_mir_dataflow::{lattice::FlatSet, Analysis, ResultsVisitor, SwitchIntEdgeEffects};
+use rustc_mir_dataflow::{
+    lattice::FlatSet, Analysis, Blocks, ResultsVisitor, SwitchIntEdgeEffects,
+};
 use rustc_span::DUMMY_SP;
 use rustc_target::abi::Align;
 
@@ -53,7 +55,7 @@ impl<'tcx> MirPass<'tcx> for DataflowConstProp {
         // Perform the actual dataflow analysis.
         let analysis = ConstAnalysis::new(tcx, body, map);
         let results = debug_span!("analyze")
-            .in_scope(|| analysis.wrap().into_engine(tcx, body).iterate_to_fixpoint());
+            .in_scope(|| analysis.wrap().into_engine(tcx, body, Blocks::All).iterate_to_fixpoint());
 
         // Collect results and patch the body afterwards.
         let mut visitor = CollectAndPatch::new(tcx, &results.analysis.0.map);

compiler/rustc_mir_transform/src/dead_store_elimination.rs

@@ -16,15 +16,15 @@ use rustc_index::bit_set::BitSet;
 use rustc_middle::mir::*;
 use rustc_middle::ty::TyCtxt;
 use rustc_mir_dataflow::impls::{borrowed_locals, MaybeTransitiveLiveLocals};
-use rustc_mir_dataflow::Analysis;
+use rustc_mir_dataflow::{Analysis, Blocks};
 
 /// Performs the optimization on the body
 ///
 /// The `borrowed` set must be a `BitSet` of all the locals that are ever borrowed in this body. It
 /// can be generated via the [`borrowed_locals`] function.
 pub fn eliminate<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>, borrowed: &BitSet<Local>) {
     let mut live = MaybeTransitiveLiveLocals::new(borrowed)
-        .into_engine(tcx, body)
+        .into_engine(tcx, body, Blocks::All)
         .iterate_to_fixpoint()
         .into_results_cursor(body);
 

compiler/rustc_mir_transform/src/dest_prop.rs

@@ -141,7 +141,7 @@ use rustc_middle::mir::{
 };
 use rustc_middle::ty::TyCtxt;
 use rustc_mir_dataflow::impls::MaybeLiveLocals;
-use rustc_mir_dataflow::{Analysis, ResultsCursor};
+use rustc_mir_dataflow::{Analysis, Blocks, ResultsCursor};
 
 pub struct DestinationPropagation;
 
@@ -189,7 +189,7 @@ impl<'tcx> MirPass<'tcx> for DestinationPropagation {
             );
             trace!(?candidates);
             let mut live = MaybeLiveLocals
-                .into_engine(tcx, body)
+                .into_engine(tcx, body, Blocks::All)
                 .iterate_to_fixpoint()
                 .into_results_cursor(body);
             dest_prop_mir_dump(tcx, body, &mut live, round_count);