switch to using MaybeUninitializedPlaces

Author: ohadravid

compiler/rustc_middle/src/mir/mod.rs

@@ -1189,8 +1189,8 @@ impl<'tcx> LocalDecl<'tcx> {
 
     /// Returns `true` if this is a DerefTemp
     pub fn is_deref_temp(&self) -> bool {
-        match self.local_info() {
-            LocalInfo::DerefTemp => true,
+        match self.local_info.as_ref() {
+            ClearCrossCrate::Set(box LocalInfo::DerefTemp) => true,
             _ => false,
         }
     }

compiler/rustc_mir_transform/src/copy_prop.rs

@@ -1,11 +1,10 @@
-use std::borrow::Cow;
-
 use rustc_index::IndexSlice;
 use rustc_index::bit_set::DenseBitSet;
 use rustc_middle::mir::visit::*;
 use rustc_middle::mir::*;
 use rustc_middle::ty::TyCtxt;
-use rustc_mir_dataflow::impls::{MaybeStorageDead, always_storage_live_locals};
+use rustc_mir_dataflow::impls::MaybeUninitializedPlaces;
+use rustc_mir_dataflow::move_paths::{HasMoveData, MoveData};
 use rustc_mir_dataflow::{Analysis, ResultsCursor};
 use tracing::{debug, instrument};
 
@@ -51,15 +50,20 @@ impl<'tcx> crate::MirPass<'tcx> for CopyProp {
         let any_replacement = ssa.copy_classes().iter_enumerated().any(|(l, &h)| l != h);
 
         let storage_to_remove = if any_replacement {
-            let always_live_locals = &always_storage_live_locals(body);
+            // The replacer will remove tautological moves from the head to the local,
+            // so we remove them before running `MaybeUninitializedPlaces`.
+            TautologicalMoveAssignmentRemover { tcx, copy_classes: ssa.copy_classes() }
+                .visit_body_preserves_cfg(body);
+
+            let move_data = MoveData::gather_moves(body, tcx, |_| true);
 
-            let maybe_storage_dead = MaybeStorageDead::new(Cow::Borrowed(always_live_locals))
-                .iterate_to_fixpoint(tcx, body, None)
+            let maybe_uninit = MaybeUninitializedPlaces::new(tcx, body, &move_data)
+                .iterate_to_fixpoint(tcx, body, Some("mir_opt::copy_prop"))
                 .into_results_cursor(body);
 
             let mut storage_checker = StorageChecker {
                 copy_classes: ssa.copy_classes(),
-                maybe_storage_dead,
+                maybe_uninit,
                 head_storage_to_check,
                 storage_to_remove: DenseBitSet::new_empty(fully_moved.domain_size()),
             };
@@ -126,6 +130,33 @@ fn fully_moved_locals(ssa: &SsaLocals, body: &Body<'_>) -> DenseBitSet<Local> {
     fully_moved
 }
 
+// The replacer will remove tautological moves from the head to the local, so we want the `MaybeUninitializedPlaces`
+struct TautologicalMoveAssignmentRemover<'a, 'tcx> {
+    tcx: TyCtxt<'tcx>,
+    copy_classes: &'a IndexSlice<Local, Local>,
+}
+
+impl<'tcx> MutVisitor<'tcx> for TautologicalMoveAssignmentRemover<'_, 'tcx> {
+    fn tcx(&self) -> TyCtxt<'tcx> {
+        self.tcx
+    }
+
+    fn visit_statement(&mut self, stmt: &mut Statement<'tcx>, loc: Location) {
+        // Similar to `Replacer::visit_statement`, but only handle moves.
+        if let StatementKind::Assign(box (lhs, ref rhs)) = stmt.kind
+            && let Rvalue::Use(Operand::Move(rhs)) = *rhs
+        {
+            let new_lhs_local = self.copy_classes[lhs.local];
+            let new_rhs_local = self.copy_classes[rhs.local];
+
+            if new_lhs_local == new_rhs_local && lhs.projection == rhs.projection {
+                debug!(?loc, ?lhs, ?rhs, "removing a to-be-tautological assignment");
+                stmt.make_nop();
+            }
+        }
+    }
+}
+
 /// Utility to help performing substitution of `*pattern` by `target`.
 struct Replacer<'a, 'tcx> {
     tcx: TyCtxt<'tcx>,
@@ -206,30 +237,41 @@ impl<'tcx> MutVisitor<'tcx> for Replacer<'_, 'tcx> {
 struct StorageChecker<'a, 'tcx> {
     storage_to_remove: DenseBitSet<Local>,
     head_storage_to_check: DenseBitSet<Local>,
-    maybe_storage_dead: ResultsCursor<'a, 'tcx, MaybeStorageDead<'a>>,
+    maybe_uninit: ResultsCursor<'a, 'tcx, MaybeUninitializedPlaces<'a, 'tcx>>,
     copy_classes: &'a IndexSlice<Local, Local>,
 }
 
 impl<'a, 'tcx> Visitor<'tcx> for StorageChecker<'a, 'tcx> {
-    fn visit_local(&mut self, local: Local, context: PlaceContext, location: Location) {
+    fn visit_local(&mut self, local: Local, context: PlaceContext, loc: Location) {
         if !context.is_use() {
             return;
         }
 
         let head = self.copy_classes[local];
-        if self.head_storage_to_check.contains(head) {
-            self.maybe_storage_dead.seek_after_primary_effect(location);
 
-            if self.maybe_storage_dead.get().contains(head) {
+        if local == head {
+            // Every original use of the head is known to be initialized, so we don't need to check it.
+            return;
+        }
+
+        // The head must be initialized at the location of the local, otherwise we must remove it's storage statements.
+        if self.head_storage_to_check.contains(head)
+            && let Some(move_idx) =
+                self.maybe_uninit.analysis().move_data().rev_lookup.find_local(head)
+        {
+            self.maybe_uninit.seek_after_primary_effect(loc);
+
+            if self.maybe_uninit.get().contains(move_idx) {
                 debug!(
-                    ?location,
+                    ?loc,
                     ?local,
                     ?head,
-                    "found use of local with head at a location in which head is maybe dead, marking head for storage removal"
+                    ?move_idx,
+                    "found use of local with head at a location in which it is maybe uninit, marking head for storage statement removal"
                 );
                 self.storage_to_remove.insert(head);
 
-                // Once we found a use of the head that is maybe dead, we do not need to check it again.
+                // Once we found a use of the head that is maybe uninit, we do not need to check it again.
                 self.head_storage_to_check.remove(head);
             }
         }