Move MaybeUninitializedLocals to the ssa module

Author: ohadravid

compiler/rustc_mir_dataflow/src/impls/initialized.rs

@@ -602,80 +602,6 @@ impl<'tcx> Analysis<'tcx> for MaybeUninitializedPlaces<'_, 'tcx> {
     }
 }
 
-/// A dataflow analysis that tracks locals that are maybe uninitialized.
-///
-/// This is a simpler analysis than `MaybeUninitializedPlaces`, because it does not track
-/// individual fields.
-pub struct MaybeUninitializedLocals;
-
-impl MaybeUninitializedLocals {
-    pub fn new() -> Self {
-        Self {}
-    }
-}
-
-impl<'tcx> Analysis<'tcx> for MaybeUninitializedLocals {
-    type Domain = DenseBitSet<mir::Local>;
-
-    const NAME: &'static str = "maybe_uninit_locals";
-
-    fn bottom_value(&self, body: &Body<'tcx>) -> Self::Domain {
-        // bottom = all locals are initialized.
-        DenseBitSet::new_empty(body.local_decls.len())
-    }
-
-    fn initialize_start_block(&self, body: &Body<'tcx>, state: &mut Self::Domain) {
-        // All locals start as uninitialized...
-        state.insert_all();
-        // ...except for arguments, which are definitely initialized.
-        for arg in body.args_iter() {
-            state.remove(arg);
-        }
-    }
-
-    fn apply_primary_statement_effect(
-        &mut self,
-        state: &mut Self::Domain,
-        statement: &mir::Statement<'tcx>,
-        _location: Location,
-    ) {
-        match statement.kind {
-            // An assignment makes a local initialized.
-            mir::StatementKind::Assign(box (place, _)) => {
-                if let Some(local) = place.as_local() {
-                    state.remove(local);
-                }
-            }
-            // Deinit makes the local uninitialized.
-            mir::StatementKind::Deinit(box place) => {
-                // A deinit makes a local uninitialized.
-                if let Some(local) = place.as_local() {
-                    state.insert(local);
-                }
-            }
-            // Storage{Live,Dead} makes a local uninitialized.
-            mir::StatementKind::StorageLive(local) | mir::StatementKind::StorageDead(local) => {
-                state.insert(local);
-            }
-            _ => {}
-        }
-    }
-
-    fn apply_call_return_effect(
-        &mut self,
-        state: &mut Self::Domain,
-        _block: mir::BasicBlock,
-        return_places: CallReturnPlaces<'_, 'tcx>,
-    ) {
-        // The return place of a call is initialized.
-        return_places.for_each(|place| {
-            if let Some(local) = place.as_local() {
-                state.remove(local);
-            }
-        });
-    }
-}
-
 /// There can be many more `InitIndex` than there are locals in a MIR body.
 /// We use a mixed bitset to avoid paying too high a memory footprint.
 pub type EverInitializedPlacesDomain = MixedBitSet<InitIndex>;

compiler/rustc_mir_dataflow/src/impls/mod.rs

@@ -6,7 +6,7 @@ mod storage_liveness;
 pub use self::borrowed_locals::{MaybeBorrowedLocals, borrowed_locals};
 pub use self::initialized::{
     EverInitializedPlaces, EverInitializedPlacesDomain, MaybeInitializedPlaces,
-    MaybeUninitializedLocals, MaybeUninitializedPlaces, MaybeUninitializedPlacesDomain,
+    MaybeUninitializedPlaces, MaybeUninitializedPlacesDomain,
 };
 pub use self::liveness::{
     MaybeLiveLocals, MaybeTransitiveLiveLocals, TransferFunction as LivenessTransferFunction,

compiler/rustc_mir_transform/src/copy_prop.rs

@@ -3,11 +3,10 @@ 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::MaybeUninitializedLocals;
 use rustc_mir_dataflow::{Analysis, ResultsCursor};
 use tracing::{debug, instrument};
 
-use crate::ssa::SsaLocals;
+use crate::ssa::{MaybeUninitializedLocals, SsaLocals};
 
 /// Unify locals that copy each other.
 ///
@@ -37,10 +36,7 @@ impl<'tcx> crate::MirPass<'tcx> for CopyProp {
         debug!(copy_classes = ?ssa.copy_classes());
 
         let mut any_replacement = false;
-        let fully_moved = fully_moved_locals(&ssa, body);
-        debug!(?fully_moved);
-
-        let mut storage_to_remove = DenseBitSet::new_empty(fully_moved.domain_size());
+        let mut storage_to_remove = DenseBitSet::new_empty(body.local_decls.len());
 
         for (local, &head) in ssa.copy_classes().iter_enumerated() {
             if local != head {

compiler/rustc_mir_transform/src/gvn.rs

@@ -104,13 +104,12 @@ use rustc_middle::mir::visit::*;
 use rustc_middle::mir::*;
 use rustc_middle::ty::layout::HasTypingEnv;
 use rustc_middle::ty::{self, Ty, TyCtxt};
-use rustc_mir_dataflow::impls::MaybeUninitializedLocals;
 use rustc_mir_dataflow::{Analysis, ResultsCursor};
 use rustc_span::DUMMY_SP;
 use smallvec::SmallVec;
 use tracing::{debug, instrument, trace};
 
-use crate::ssa::SsaLocals;
+use crate::ssa::{MaybeUninitializedLocals, SsaLocals};
 
 pub(super) struct GVN;
 

compiler/rustc_mir_transform/src/ssa.rs

@@ -14,6 +14,7 @@ use rustc_middle::middle::resolve_bound_vars::Set1;
 use rustc_middle::mir::visit::*;
 use rustc_middle::mir::*;
 use rustc_middle::ty::{self, TyCtxt};
+use rustc_mir_dataflow::Analysis;
 use tracing::{debug, instrument, trace};
 
 pub(super) struct SsaLocals {
@@ -391,3 +392,77 @@ impl StorageLiveLocals {
         matches!(self.storage_live[local], Set1::One(_))
     }
 }
+
+/// A dataflow analysis that tracks locals that are maybe uninitialized.
+///
+/// This is a simpler analysis than `MaybeUninitializedPlaces`, because it does not track
+/// individual fields.
+pub(crate) struct MaybeUninitializedLocals;
+
+impl MaybeUninitializedLocals {
+    pub(crate) fn new() -> Self {
+        Self {}
+    }
+}
+
+impl<'tcx> Analysis<'tcx> for MaybeUninitializedLocals {
+    type Domain = DenseBitSet<Local>;
+
+    const NAME: &'static str = "maybe_uninit_locals";
+
+    fn bottom_value(&self, body: &Body<'tcx>) -> Self::Domain {
+        // bottom = all locals are initialized.
+        DenseBitSet::new_empty(body.local_decls.len())
+    }
+
+    fn initialize_start_block(&self, body: &Body<'tcx>, state: &mut Self::Domain) {
+        // All locals start as uninitialized...
+        state.insert_all();
+        // ...except for arguments, which are definitely initialized.
+        for arg in body.args_iter() {
+            state.remove(arg);
+        }
+    }
+
+    fn apply_primary_statement_effect(
+        &mut self,
+        state: &mut Self::Domain,
+        statement: &Statement<'tcx>,
+        _location: Location,
+    ) {
+        match statement.kind {
+            // An assignment makes a local initialized.
+            StatementKind::Assign(box (place, _)) => {
+                if let Some(local) = place.as_local() {
+                    state.remove(local);
+                }
+            }
+            // Deinit makes the local uninitialized.
+            StatementKind::Deinit(box place) => {
+                // A deinit makes a local uninitialized.
+                if let Some(local) = place.as_local() {
+                    state.insert(local);
+                }
+            }
+            // Storage{Live,Dead} makes a local uninitialized.
+            StatementKind::StorageLive(local) | StatementKind::StorageDead(local) => {
+                state.insert(local);
+            }
+            _ => {}
+        }
+    }
+
+    fn apply_call_return_effect(
+        &mut self,
+        state: &mut Self::Domain,
+        _block: BasicBlock,
+        return_places: CallReturnPlaces<'_, 'tcx>,
+    ) {
+        // The return place of a call is initialized.
+        return_places.for_each(|place| {
+            if let Some(local) = place.as_local() {
+                state.remove(local);
+            }
+        });
+    }
+}