Reimplement DestinationPropagation according to live ranges.

Author: cjgillot

compiler/rustc_index/src/bit_set.rs

@@ -1538,28 +1538,6 @@ impl<R: Idx, C: Idx> BitMatrix<R, C> {
         changed != 0
     }
 
-    /// Adds the bits from col `read` to the bits from col `write`, and
-    /// returns `true` if anything changed.
-    pub fn union_cols(&mut self, read: C, write: C) -> bool {
-        assert!(read.index() < self.num_columns && write.index() < self.num_columns);
-
-        let words_per_row = num_words(self.num_columns);
-        let (read_index, read_mask) = word_index_and_mask(read);
-        let (write_index, write_mask) = word_index_and_mask(write);
-
-        let words = &mut self.words[..];
-        let mut changed = 0;
-        for row in 0..self.num_rows {
-            let write_word = words[row * words_per_row + write_index];
-            let read_word = (words[row * words_per_row + read_index] & read_mask) != 0;
-            let new_word = if read_word { write_word | write_mask } else { write_word };
-            words[row * words_per_row + write_index] = new_word;
-            // See `bitwise` for the rationale.
-            changed |= write_word ^ new_word;
-        }
-        changed != 0
-    }
-
     /// Adds the bits from `with` to the bits from row `write`, and
     /// returns `true` if anything changed.
     pub fn union_row_with(&mut self, with: &DenseBitSet<C>, write: R) -> bool {

compiler/rustc_index/src/interval.rs

@@ -219,6 +219,32 @@ impl<I: Idx> IntervalSet<I> {
         })
     }
 
+    pub fn disjoint(&self, other: &IntervalSet<I>) -> bool
+    where
+        I: Step,
+    {
+        let helper = move || {
+            let mut self_iter = self.iter_intervals();
+            let mut other_iter = other.iter_intervals();
+
+            let mut self_current = self_iter.next()?;
+            let mut other_current = other_iter.next()?;
+
+            loop {
+                if self_current.end <= other_current.start {
+                    self_current = self_iter.next()?;
+                    continue;
+                }
+                if other_current.end <= self_current.start {
+                    other_current = other_iter.next()?;
+                    continue;
+                }
+                return Some(false);
+            }
+        };
+        helper().unwrap_or(true)
+    }
+
     pub fn is_empty(&self) -> bool {
         self.map.is_empty()
     }

compiler/rustc_mir_dataflow/src/impls/liveness.rs

@@ -92,7 +92,7 @@ impl<'tcx> Visitor<'tcx> for TransferFunction<'_> {
         }
 
         match DefUse::for_place(*place, context) {
-            Some(DefUse::Def) => {
+            DefUse::Def => {
                 if let PlaceContext::MutatingUse(
                     MutatingUseContext::Call | MutatingUseContext::AsmOutput,
                 ) = context
@@ -105,8 +105,8 @@ impl<'tcx> Visitor<'tcx> for TransferFunction<'_> {
                     self.0.kill(place.local);
                 }
             }
-            Some(DefUse::Use) => self.0.gen_(place.local),
-            None => {}
+            DefUse::Use => self.0.gen_(place.local),
+            DefUse::PartialWrite | DefUse::NonUse => {}
         }
 
         self.visit_projection(place.as_ref(), context, location);
@@ -131,23 +131,29 @@ impl<'tcx> Visitor<'tcx> for YieldResumeEffect<'_> {
 }
 
 #[derive(Eq, PartialEq, Clone)]
-enum DefUse {
+pub enum DefUse {
+    /// Full write to the local.
     Def,
+    /// Read of any part of the local.
     Use,
+    /// Partial write to the local.
+    PartialWrite,
+    /// Non-use, like debuginfo.
+    NonUse,
 }
 
 impl DefUse {
     fn apply(state: &mut DenseBitSet<Local>, place: Place<'_>, context: PlaceContext) {
         match DefUse::for_place(place, context) {
-            Some(DefUse::Def) => state.kill(place.local),
-            Some(DefUse::Use) => state.gen_(place.local),
-            None => {}
+            DefUse::Def => state.kill(place.local),
+            DefUse::Use => state.gen_(place.local),
+            DefUse::PartialWrite | DefUse::NonUse => {}
         }
     }
 
-    fn for_place(place: Place<'_>, context: PlaceContext) -> Option<DefUse> {
+    pub fn for_place(place: Place<'_>, context: PlaceContext) -> DefUse {
         match context {
-            PlaceContext::NonUse(_) => None,
+            PlaceContext::NonUse(_) => DefUse::NonUse,
 
             PlaceContext::MutatingUse(
                 MutatingUseContext::Call
@@ -156,21 +162,20 @@ impl DefUse {
                 | MutatingUseContext::Store
                 | MutatingUseContext::Deinit,
             ) => {
+                // Treat derefs as a use of the base local. `*p = 4` is not a def of `p` but a use.
                 if place.is_indirect() {
-                    // Treat derefs as a use of the base local. `*p = 4` is not a def of `p` but a
-                    // use.
-                    Some(DefUse::Use)
+                    DefUse::Use
                 } else if place.projection.is_empty() {
-                    Some(DefUse::Def)
+                    DefUse::Def
                 } else {
-                    None
+                    DefUse::PartialWrite
                 }
             }
 
             // Setting the discriminant is not a use because it does no reading, but it is also not
             // a def because it does not overwrite the whole place
             PlaceContext::MutatingUse(MutatingUseContext::SetDiscriminant) => {
-                place.is_indirect().then_some(DefUse::Use)
+                if place.is_indirect() { DefUse::Use } else { DefUse::PartialWrite }
             }
 
             // All other contexts are uses...
@@ -188,7 +193,7 @@ impl DefUse {
                 | NonMutatingUseContext::PlaceMention
                 | NonMutatingUseContext::FakeBorrow
                 | NonMutatingUseContext::SharedBorrow,
-            ) => Some(DefUse::Use),
+            ) => DefUse::Use,
 
             PlaceContext::MutatingUse(MutatingUseContext::Projection)
             | PlaceContext::NonMutatingUse(NonMutatingUseContext::Projection) => {

compiler/rustc_mir_dataflow/src/impls/mod.rs

@@ -9,7 +9,8 @@ pub use self::initialized::{
     MaybeUninitializedPlaces, MaybeUninitializedPlacesDomain,
 };
 pub use self::liveness::{
-    MaybeLiveLocals, MaybeTransitiveLiveLocals, TransferFunction as LivenessTransferFunction,
+    DefUse, MaybeLiveLocals, MaybeTransitiveLiveLocals,
+    TransferFunction as LivenessTransferFunction,
 };
 pub use self::storage_liveness::{
     MaybeRequiresStorage, MaybeStorageDead, MaybeStorageLive, always_storage_live_locals,

compiler/rustc_mir_dataflow/src/points.rs

@@ -1,9 +1,5 @@
-use rustc_index::bit_set::DenseBitSet;
-use rustc_index::interval::SparseIntervalMatrix;
-use rustc_index::{Idx, IndexSlice, IndexVec};
-use rustc_middle::mir::{self, BasicBlock, Body, Location};
-
-use crate::framework::{Analysis, Direction, Results, ResultsVisitor, visit_results};
+use rustc_index::{Idx, IndexVec};
+use rustc_middle::mir::{BasicBlock, Body, Location};
 
 /// Maps between a `Location` and a `PointIndex` (and vice versa).
 pub struct DenseLocationMap {
@@ -93,85 +89,3 @@ rustc_index::newtype_index! {
     #[debug_format = "PointIndex({})"]
     pub struct PointIndex {}
 }
-
-/// Add points depending on the result of the given dataflow analysis.
-pub fn save_as_intervals<'tcx, N, M, A>(
-    elements: &DenseLocationMap,
-    body: &mir::Body<'tcx>,
-    relevant: &IndexSlice<N, M>,
-    mut analysis: A,
-    results: Results<A::Domain>,
-) -> SparseIntervalMatrix<N, PointIndex>
-where
-    N: Idx,
-    M: Idx,
-    A: Analysis<'tcx, Domain = DenseBitSet<M>>,
-{
-    let mut values = SparseIntervalMatrix::new(elements.num_points());
-    let reachable_blocks = mir::traversal::reachable_as_bitset(body);
-    if A::Direction::IS_BACKWARD {
-        // Iterate blocks in decreasing order, to visit locations in decreasing order. This
-        // allows to use the more efficient `prepend` method to interval sets.
-        let callback = |state: &DenseBitSet<M>, location| {
-            let point = elements.point_from_location(location);
-            for (relevant, &original) in relevant.iter_enumerated() {
-                if state.contains(original) {
-                    values.prepend(relevant, point);
-                }
-            }
-        };
-        let mut visitor = Visitor { callback };
-        visit_results(
-            body,
-            // Note the `.rev()`.
-            body.basic_blocks.indices().filter(|&bb| reachable_blocks.contains(bb)).rev(),
-            &mut analysis,
-            &results,
-            &mut visitor,
-        );
-    } else {
-        // Iterate blocks in increasing order, to visit locations in increasing order. This
-        // allows to use the more efficient `append` method to interval sets.
-        let callback = |state: &DenseBitSet<M>, location| {
-            let point = elements.point_from_location(location);
-            for (relevant, &original) in relevant.iter_enumerated() {
-                if state.contains(original) {
-                    values.append(relevant, point);
-                }
-            }
-        };
-        let mut visitor = Visitor { callback };
-        visit_results(body, reachable_blocks.iter(), &mut analysis, &results, &mut visitor);
-    }
-    values
-}
-
-struct Visitor<F> {
-    callback: F,
-}
-
-impl<'tcx, A, F> ResultsVisitor<'tcx, A> for Visitor<F>
-where
-    A: Analysis<'tcx>,
-    F: FnMut(&A::Domain, Location),
-{
-    fn visit_after_primary_statement_effect<'mir>(
-        &mut self,
-        _analysis: &mut A,
-        state: &A::Domain,
-        _statement: &'mir mir::Statement<'tcx>,
-        location: Location,
-    ) {
-        (self.callback)(state, location);
-    }
-
-    fn visit_after_primary_terminator_effect<'mir>(
-        &mut self,
-        _analysis: &mut A,
-        state: &A::Domain,
-        _terminator: &'mir mir::Terminator<'tcx>,
-        location: Location,
-    ) {
-        (self.callback)(state, location);
-    }
-}