Implement dataflow state joins through the analysis. Make JoinSemiLattice the default implementation when the join does not require extra context.

Author: Jarcho

compiler/rustc_mir_dataflow/src/framework/direction.rs

@@ -55,7 +55,7 @@ pub trait Direction {
         body: &mir::Body<'tcx>,
         exit_state: &mut A::Domain,
         block: (BasicBlock, &'_ mir::BasicBlockData<'tcx>),
-        propagate: impl FnMut(BasicBlock, &A::Domain),
+        propagate: impl FnMut(&mut A, BasicBlock, &A::Domain),
     ) where
         A: Analysis<'tcx>;
 }
@@ -221,7 +221,7 @@ impl Direction for Backward {
         body: &mir::Body<'tcx>,
         exit_state: &mut A::Domain,
         (bb, _bb_data): (BasicBlock, &'_ mir::BasicBlockData<'tcx>),
-        mut propagate: impl FnMut(BasicBlock, &A::Domain),
+        mut propagate: impl FnMut(&mut A, BasicBlock, &A::Domain),
     ) where
         A: Analysis<'tcx>,
     {
@@ -237,7 +237,7 @@ impl Direction for Backward {
                         pred,
                         CallReturnPlaces::Call(destination),
                     );
-                    propagate(pred, &tmp);
+                    propagate(analysis, pred, &tmp);
                 }
 
                 mir::TerminatorKind::InlineAsm {
@@ -249,13 +249,13 @@ impl Direction for Backward {
                         pred,
                         CallReturnPlaces::InlineAsm(operands),
                     );
-                    propagate(pred, &tmp);
+                    propagate(analysis, pred, &tmp);
                 }
 
                 mir::TerminatorKind::Yield { resume, resume_arg, .. } if resume == bb => {
                     let mut tmp = exit_state.clone();
                     analysis.apply_yield_resume_effect(&mut tmp, resume, resume_arg);
-                    propagate(pred, &tmp);
+                    propagate(analysis, pred, &tmp);
                 }
 
                 mir::TerminatorKind::SwitchInt { targets: _, ref discr } => {
@@ -271,11 +271,11 @@ impl Direction for Backward {
                     analysis.apply_switch_int_edge_effects(pred, discr, &mut applier);
 
                     if !applier.effects_applied {
-                        propagate(pred, exit_state)
+                        propagate(analysis, pred, exit_state)
                     }
                 }
 
-                _ => propagate(pred, exit_state),
+                _ => propagate(analysis, pred, exit_state),
             }
         }
     }
@@ -290,12 +290,17 @@ struct BackwardSwitchIntEdgeEffectsApplier<'a, 'tcx, D, F> {
     effects_applied: bool,
 }
 
-impl<D, F> super::SwitchIntEdgeEffects<D> for BackwardSwitchIntEdgeEffectsApplier<'_, '_, D, F>
+impl<'tcx, A, F> super::SwitchIntEdgeEffects<'tcx, A>
+    for BackwardSwitchIntEdgeEffectsApplier<'_, '_, A::Domain, F>
 where
-    D: Clone,
-    F: FnMut(BasicBlock, &D),
+    A: Analysis<'tcx>,
+    F: FnMut(&mut A, BasicBlock, &A::Domain),
 {
-    fn apply(&mut self, mut apply_edge_effect: impl FnMut(&mut D, SwitchIntTarget)) {
+    fn apply(
+        &mut self,
+        analysis: &mut A,
+        mut apply_edge_effect: impl FnMut(&mut A, &mut A::Domain, SwitchIntTarget),
+    ) {
         assert!(!self.effects_applied);
 
         let values = &self.body.basic_blocks.switch_sources()[&(self.bb, self.pred)];
@@ -304,8 +309,8 @@ where
         let mut tmp = None;
         for target in targets {
             let tmp = opt_clone_from_or_clone(&mut tmp, self.exit_state);
-            apply_edge_effect(tmp, target);
-            (self.propagate)(self.pred, tmp);
+            apply_edge_effect(analysis, tmp, target);
+            (self.propagate)(analysis, self.pred, tmp);
         }
 
         self.effects_applied = true;
@@ -468,43 +473,43 @@ impl Direction for Forward {
         _body: &mir::Body<'tcx>,
         exit_state: &mut A::Domain,
         (bb, bb_data): (BasicBlock, &'_ mir::BasicBlockData<'tcx>),
-        mut propagate: impl FnMut(BasicBlock, &A::Domain),
+        mut propagate: impl FnMut(&mut A, BasicBlock, &A::Domain),
     ) where
         A: Analysis<'tcx>,
     {
         use mir::TerminatorKind::*;
         match bb_data.terminator().kind {
             Return | Resume | Terminate | GeneratorDrop | Unreachable => {}
 
-            Goto { target } => propagate(target, exit_state),
+            Goto { target } => propagate(analysis, target, exit_state),
 
             Assert { target, unwind, expected: _, msg: _, cond: _ }
             | Drop { target, unwind, place: _, replace: _ }
             | FalseUnwind { real_target: target, unwind } => {
                 if let UnwindAction::Cleanup(unwind) = unwind {
-                    propagate(unwind, exit_state);
+                    propagate(analysis, unwind, exit_state);
                 }
 
-                propagate(target, exit_state);
+                propagate(analysis, target, exit_state);
             }
 
             FalseEdge { real_target, imaginary_target } => {
-                propagate(real_target, exit_state);
-                propagate(imaginary_target, exit_state);
+                propagate(analysis, real_target, exit_state);
+                propagate(analysis, imaginary_target, exit_state);
             }
 
             Yield { resume: target, drop, resume_arg, value: _ } => {
                 if let Some(drop) = drop {
-                    propagate(drop, exit_state);
+                    propagate(analysis, drop, exit_state);
                 }
 
                 analysis.apply_yield_resume_effect(exit_state, target, resume_arg);
-                propagate(target, exit_state);
+                propagate(analysis, target, exit_state);
             }
 
             Call { unwind, destination, target, func: _, args: _, call_source: _, fn_span: _ } => {
                 if let UnwindAction::Cleanup(unwind) = unwind {
-                    propagate(unwind, exit_state);
+                    propagate(analysis, unwind, exit_state);
                 }
 
                 if let Some(target) = target {
@@ -515,7 +520,7 @@ impl Direction for Forward {
                         bb,
                         CallReturnPlaces::Call(destination),
                     );
-                    propagate(target, exit_state);
+                    propagate(analysis, target, exit_state);
                 }
             }
 
@@ -528,7 +533,7 @@ impl Direction for Forward {
                 unwind,
             } => {
                 if let UnwindAction::Cleanup(unwind) = unwind {
-                    propagate(unwind, exit_state);
+                    propagate(analysis, unwind, exit_state);
                 }
 
                 if let Some(target) = destination {
@@ -539,7 +544,7 @@ impl Direction for Forward {
                         bb,
                         CallReturnPlaces::InlineAsm(operands),
                     );
-                    propagate(target, exit_state);
+                    propagate(analysis, target, exit_state);
                 }
             }
 
@@ -562,7 +567,7 @@ impl Direction for Forward {
 
                 if !effects_applied {
                     for target in targets.all_targets() {
-                        propagate(*target, exit_state);
+                        propagate(analysis, *target, exit_state);
                     }
                 }
             }
@@ -578,26 +583,35 @@ struct ForwardSwitchIntEdgeEffectsApplier<'a, D, F> {
     effects_applied: bool,
 }
 
-impl<D, F> super::SwitchIntEdgeEffects<D> for ForwardSwitchIntEdgeEffectsApplier<'_, D, F>
+impl<'tcx, A, F> super::SwitchIntEdgeEffects<'tcx, A>
+    for ForwardSwitchIntEdgeEffectsApplier<'_, A::Domain, F>
 where
-    D: Clone,
-    F: FnMut(BasicBlock, &D),
+    A: Analysis<'tcx>,
+    F: FnMut(&mut A, BasicBlock, &A::Domain),
 {
-    fn apply(&mut self, mut apply_edge_effect: impl FnMut(&mut D, SwitchIntTarget)) {
+    fn apply(
+        &mut self,
+        analysis: &mut A,
+        mut apply_edge_effect: impl FnMut(&mut A, &mut A::Domain, SwitchIntTarget),
+    ) {
         assert!(!self.effects_applied);
 
         let mut tmp = None;
         for (value, target) in self.targets.iter() {
             let tmp = opt_clone_from_or_clone(&mut tmp, self.exit_state);
-            apply_edge_effect(tmp, SwitchIntTarget { value: Some(value), target });
-            (self.propagate)(target, tmp);
+            apply_edge_effect(analysis, tmp, SwitchIntTarget { value: Some(value), target });
+            (self.propagate)(analysis, target, tmp);
         }
 
         // Once we get to the final, "otherwise" branch, there is no need to preserve `exit_state`,
         // so pass it directly to `apply_edge_effect` to save a clone of the dataflow state.
         let otherwise = self.targets.otherwise();
-        apply_edge_effect(self.exit_state, SwitchIntTarget { value: None, target: otherwise });
-        (self.propagate)(otherwise, self.exit_state);
+        apply_edge_effect(
+            analysis,
+            self.exit_state,
+            SwitchIntTarget { value: None, target: otherwise },
+        );
+        (self.propagate)(analysis, otherwise, self.exit_state);
 
         self.effects_applied = true;
     }

compiler/rustc_mir_dataflow/src/framework/engine.rs

@@ -25,8 +25,7 @@ use super::fmt::DebugWithContext;
 use super::graphviz;
 use super::{
     visit_results, Analysis, AnalysisDomain, CloneAnalysis, Direction, GenKill, GenKillAnalysis,
-    GenKillSet, JoinSemiLattice, ResultsClonedCursor, ResultsCursor, ResultsRefCursor,
-    ResultsVisitor,
+    GenKillSet, ResultsClonedCursor, ResultsCursor, ResultsRefCursor, ResultsVisitor,
 };
 
 pub type EntrySets<'tcx, A> = IndexVec<BasicBlock, <A as AnalysisDomain<'tcx>>::Domain>;
@@ -150,7 +149,7 @@ where
 impl<'a, 'tcx, A, D, T> Engine<'a, 'tcx, A>
 where
     A: GenKillAnalysis<'tcx, Idx = T, Domain = D>,
-    D: Clone + JoinSemiLattice + GenKill<T> + BitSetExt<T>,
+    D: Clone + GenKill<T> + BitSetExt<T>,
     T: Idx,
 {
     /// Creates a new `Engine` to solve a gen-kill dataflow problem.
@@ -181,10 +180,9 @@ where
     }
 }
 
-impl<'a, 'tcx, A, D> Engine<'a, 'tcx, A>
+impl<'a, 'tcx, A> Engine<'a, 'tcx, A>
 where
-    A: Analysis<'tcx, Domain = D>,
-    D: Clone + JoinSemiLattice,
+    A: Analysis<'tcx>,
 {
     /// Creates a new `Engine` to solve a dataflow problem with an arbitrary transfer
     /// function.
@@ -276,8 +274,8 @@ where
                 body,
                 &mut state,
                 (bb, bb_data),
-                |target: BasicBlock, state: &A::Domain| {
-                    let set_changed = entry_sets[target].join(state);
+                |analysis: &mut A, target: BasicBlock, state: &A::Domain| {
+                    let set_changed = analysis.join(&mut entry_sets[target], state, target);
                     if set_changed {
                         dirty_queue.insert(target);
                     }

compiler/rustc_mir_dataflow/src/framework/mod.rs

@@ -102,7 +102,7 @@ impl<T: Idx> BitSetExt<T> for ChunkedBitSet<T> {
 /// initial value at the entry point of each basic block.
 pub trait AnalysisDomain<'tcx> {
     /// The type that holds the dataflow state at any given point in the program.
-    type Domain: Clone + JoinSemiLattice;
+    type Domain: Clone + Eq;
 
     /// The direction of this analysis. Either `Forward` or `Backward`.
     type Direction: Direction = Forward;
@@ -127,6 +127,21 @@ pub trait AnalysisDomain<'tcx> {
     fn initialize_start_block(&self, body: &mir::Body<'tcx>, state: &mut Self::Domain);
 }
 
+/// Gets the context under which to perform a join.
+pub trait AnalysisJoin<'tcx>: AnalysisDomain<'tcx> {
+    fn join(&mut self, state: &mut Self::Domain, other: &Self::Domain, loc: BasicBlock) -> bool;
+}
+
+impl<'tcx, T> AnalysisJoin<'tcx> for T
+where
+    T: ?Sized + AnalysisDomain<'tcx>,
+    <T as AnalysisDomain<'tcx>>::Domain: JoinSemiLattice,
+{
+    fn join(&mut self, state: &mut Self::Domain, other: &Self::Domain, _: BasicBlock) -> bool {
+        state.join(other)
+    }
+}
+
 /// A dataflow problem with an arbitrarily complex transfer function.
 ///
 /// # Convergence
@@ -143,7 +158,7 @@ pub trait AnalysisDomain<'tcx> {
 /// monotonically until fixpoint is reached. Note that this monotonicity requirement only applies
 /// to the same point in the program at different points in time. The dataflow state at a given
 /// point in the program may or may not be greater than the state at any preceding point.
-pub trait Analysis<'tcx>: AnalysisDomain<'tcx> {
+pub trait Analysis<'tcx>: AnalysisJoin<'tcx> {
     /// Updates the current dataflow state with the effect of evaluating a statement.
     fn apply_statement_effect(
         &mut self,
@@ -238,7 +253,7 @@ pub trait Analysis<'tcx>: AnalysisDomain<'tcx> {
         &mut self,
         _block: BasicBlock,
         _discr: &mir::Operand<'tcx>,
-        _apply_edge_effects: &mut impl SwitchIntEdgeEffects<Self::Domain>,
+        _apply_edge_effects: &mut impl SwitchIntEdgeEffects<'tcx, Self>,
     ) {
     }
 
@@ -349,18 +364,18 @@ pub trait GenKillAnalysis<'tcx>: Analysis<'tcx> {
     }
 
     /// See `Analysis::apply_switch_int_edge_effects`.
-    fn switch_int_edge_effects<G: GenKill<Self::Idx>>(
+    fn switch_int_edge_effects(
         &mut self,
         _block: BasicBlock,
         _discr: &mir::Operand<'tcx>,
-        _edge_effects: &mut impl SwitchIntEdgeEffects<G>,
+        _edge_effects: &mut impl SwitchIntEdgeEffects<'tcx, Self>,
     ) {
     }
 }
 
 impl<'tcx, A> Analysis<'tcx> for A
 where
-    A: GenKillAnalysis<'tcx>,
+    A: GenKillAnalysis<'tcx> + ?Sized,
     A::Domain: GenKill<A::Idx> + BitSetExt<A::Idx>,
 {
     fn apply_statement_effect(
@@ -423,7 +438,7 @@ where
         &mut self,
         block: BasicBlock,
         discr: &mir::Operand<'tcx>,
-        edge_effects: &mut impl SwitchIntEdgeEffects<A::Domain>,
+        edge_effects: &mut impl SwitchIntEdgeEffects<'tcx, Self>,
     ) {
         self.switch_int_edge_effects(block, discr, edge_effects);
     }
@@ -606,10 +621,14 @@ pub struct SwitchIntTarget {
 }
 
 /// A type that records the edge-specific effects for a `SwitchInt` terminator.
-pub trait SwitchIntEdgeEffects<D> {
+pub trait SwitchIntEdgeEffects<'tcx, A: ?Sized + AnalysisDomain<'tcx>> {
     /// Calls `apply_edge_effect` for each outgoing edge from a `SwitchInt` terminator and
     /// records the results.
-    fn apply(&mut self, apply_edge_effect: impl FnMut(&mut D, SwitchIntTarget));
+    fn apply(
+        &mut self,
+        analysis: &mut A,
+        apply_edge_effect: impl FnMut(&mut A, &mut A::Domain, SwitchIntTarget),
+    );
 }
 
 /// List of places that are written to after a successful (non-unwind) return