Invalidate all dereferences

dianqk · dianqk · commit a7c8edd27fa9 · 2024-11-02T22:56:36.000+08:00
diff --git a/compiler/rustc_data_structures/src/fx.rs b/compiler/rustc_data_structures/src/fx.rs
@@ -9,6 +9,8 @@ pub type FxIndexSet<V> = indexmap::IndexSet<V, BuildHasherDefault<FxHasher>>;
 pub type IndexEntry<'a, K, V> = indexmap::map::Entry<'a, K, V>;
 pub type IndexOccupiedEntry<'a, K, V> = indexmap::map::OccupiedEntry<'a, K, V>;
 
+pub use indexmap::set::MutableValues;
+
 #[macro_export]
 macro_rules! define_id_collections {
     ($map_name:ident, $set_name:ident, $entry_name:ident, $key:ty) => {
diff --git a/compiler/rustc_mir_transform/src/gvn.rs b/compiler/rustc_mir_transform/src/gvn.rs
@@ -93,7 +93,7 @@ use rustc_const_eval::interpret::{
     ImmTy, Immediate, InterpCx, MemPlaceMeta, MemoryKind, OpTy, Projectable, Scalar,
     intern_const_alloc_for_constprop,
 };
-use rustc_data_structures::fx::FxIndexSet;
+use rustc_data_structures::fx::{FxIndexSet, MutableValues};
 use rustc_data_structures::graph::dominators::Dominators;
 use rustc_hir::def::DefKind;
 use rustc_index::bit_set::BitSet;
@@ -235,6 +235,8 @@ struct VnState<'body, 'tcx> {
     evaluated: IndexVec<VnIndex, Option<OpTy<'tcx>>>,
     /// Counter to generate different values.
     next_opaque: usize,
+    /// Cache the deref values.
+    derefs: Vec<VnIndex>,
     /// Cache the value of the `unsized_locals` features, to avoid fetching it repeatedly in a loop.
     feature_unsized_locals: bool,
     ssa: &'body SsaLocals,
@@ -268,6 +270,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
             values: FxIndexSet::with_capacity_and_hasher(num_values, Default::default()),
             evaluated: IndexVec::with_capacity(num_values),
             next_opaque: 1,
+            derefs: Vec::new(),
             feature_unsized_locals: tcx.features().unsized_locals(),
             ssa,
             dominators,
@@ -362,6 +365,21 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
         self.insert(Value::Aggregate(AggregateTy::Tuple, VariantIdx::ZERO, values))
     }
 
+    fn insert_deref(&mut self, value: VnIndex) -> VnIndex {
+        let value = self.insert(Value::Projection(value, ProjectionElem::Deref));
+        self.derefs.push(value);
+        value
+    }
+
+    fn invalidate_derefs(&mut self) {
+        let mut derefs = Vec::new();
+        std::mem::swap(&mut derefs, &mut self.derefs);
+        for deref in derefs {
+            let opaque = self.next_opaque();
+            *self.values.get_index_mut2(deref.index()).unwrap() = Value::Opaque(opaque);
+        }
+    }
+
     #[instrument(level = "trace", skip(self), ret)]
     fn eval_to_const(&mut self, value: VnIndex) -> Option<OpTy<'tcx>> {
         use Value::*;
@@ -620,7 +638,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
                 {
                     // An immutable borrow `_x` always points to the same value for the
                     // lifetime of the borrow, so we can merge all instances of `*_x`.
-                    ProjectionElem::Deref
+                    return Some(self.insert_deref(value));
                 } else {
                     return None;
                 }
@@ -1621,6 +1639,8 @@ impl<'tcx> MutVisitor<'tcx> for VnState<'_, 'tcx> {
                 self.assign(local, value);
                 Some(value)
             } else {
+                // Non-local assignments maybe invalidate deref.
+                self.invalidate_derefs();
                 value
             };
             let Some(value) = value else { return };
@@ -1640,12 +1660,16 @@ impl<'tcx> MutVisitor<'tcx> for VnState<'_, 'tcx> {
     }
 
     fn visit_terminator(&mut self, terminator: &mut Terminator<'tcx>, location: Location) {
-        if let Terminator { kind: TerminatorKind::Call { destination, .. }, .. } = terminator
-            && let Some(local) = destination.as_local()
-            && self.ssa.is_ssa(local)
-        {
-            let opaque = self.new_opaque();
-            self.assign(local, opaque);
+        if let Terminator { kind: TerminatorKind::Call { destination, .. }, .. } = terminator {
+            if let Some(local) = destination.as_local()
+                && self.ssa.is_ssa(local)
+            {
+                let opaque = self.new_opaque();
+                self.assign(local, opaque);
+            }
+            // Function calls maybe invalidate nested deref, and non-local assignments maybe invalidate deref.
+            // Currently, no distinction is made between these two cases.
+            self.invalidate_derefs();
         }
         self.super_terminator(terminator, location);
     }
diff --git a/tests/mir-opt/gvn.dereferences.GVN.panic-unwind.diff b/tests/mir-opt/gvn.dereferences.GVN.panic-unwind.diff
@@ -107,23 +107,18 @@
           StorageLive(_18);
           _18 = &(*_1);
           StorageLive(_19);
--         StorageLive(_20);
-+         nop;
+          StorageLive(_20);
           _20 = copy (*_18);
--         _19 = opaque::<u32>(move _20) -> [return: bb7, unwind continue];
-+         _19 = opaque::<u32>(copy _20) -> [return: bb7, unwind continue];
+          _19 = opaque::<u32>(move _20) -> [return: bb7, unwind continue];
       }
   
       bb7: {
--         StorageDead(_20);
-+         nop;
+          StorageDead(_20);
           StorageDead(_19);
           StorageLive(_21);
           StorageLive(_22);
--         _22 = copy (*_18);
--         _21 = opaque::<u32>(move _22) -> [return: bb8, unwind continue];
-+         _22 = copy _20;
-+         _21 = opaque::<u32>(copy _20) -> [return: bb8, unwind continue];
+          _22 = copy (*_18);
+          _21 = opaque::<u32>(move _22) -> [return: bb8, unwind continue];
       }
   
       bb8: {
@@ -157,23 +152,18 @@
           StorageDead(_28);
           StorageDead(_27);
           StorageLive(_29);
--         StorageLive(_30);
-+         nop;
+          StorageLive(_30);
           _30 = copy ((*_3).0: u32);
--         _29 = opaque::<u32>(move _30) -> [return: bb12, unwind continue];
-+         _29 = opaque::<u32>(copy _30) -> [return: bb12, unwind continue];
+          _29 = opaque::<u32>(move _30) -> [return: bb12, unwind continue];
       }
   
       bb12: {
--         StorageDead(_30);
-+         nop;
+          StorageDead(_30);
           StorageDead(_29);
           StorageLive(_31);
           StorageLive(_32);
--         _32 = copy ((*_3).0: u32);
--         _31 = opaque::<u32>(move _32) -> [return: bb13, unwind continue];
-+         _32 = copy _30;
-+         _31 = opaque::<u32>(copy _30) -> [return: bb13, unwind continue];
+          _32 = copy ((*_3).0: u32);
+          _31 = opaque::<u32>(move _32) -> [return: bb13, unwind continue];
       }
   
       bb13: {
diff --git a/tests/mir-opt/gvn.subexpression_elimination.GVN.panic-unwind.diff b/tests/mir-opt/gvn.subexpression_elimination.GVN.panic-unwind.diff
@@ -758,39 +758,32 @@
           StorageLive(_126);
           _126 = &_3;
           StorageLive(_127);
--         StorageLive(_128);
--         StorageLive(_129);
-+         nop;
-+         nop;
+          StorageLive(_128);
+          StorageLive(_129);
           _129 = copy (*_126);
           StorageLive(_130);
           _130 = copy _1;
 -         _128 = Add(move _129, move _130);
-+         _128 = Add(copy _129, copy _1);
++         _128 = Add(move _129, copy _1);
           StorageDead(_130);
--         StorageDead(_129);
--         _127 = opaque::<u64>(move _128) -> [return: bb35, unwind continue];
-+         nop;
-+         _127 = opaque::<u64>(copy _128) -> [return: bb35, unwind continue];
+          StorageDead(_129);
+          _127 = opaque::<u64>(move _128) -> [return: bb35, unwind continue];
       }
   
       bb35: {
--         StorageDead(_128);
-+         nop;
+          StorageDead(_128);
           StorageDead(_127);
           StorageLive(_131);
           StorageLive(_132);
           StorageLive(_133);
--         _133 = copy (*_126);
-+         _133 = copy _129;
+          _133 = copy (*_126);
           StorageLive(_134);
           _134 = copy _1;
 -         _132 = Add(move _133, move _134);
-+         _132 = copy _128;
++         _132 = Add(move _133, copy _1);
           StorageDead(_134);
           StorageDead(_133);
--         _131 = opaque::<u64>(move _132) -> [return: bb36, unwind continue];
-+         _131 = opaque::<u64>(copy _128) -> [return: bb36, unwind continue];
+          _131 = opaque::<u64>(move _132) -> [return: bb36, unwind continue];
       }
   
       bb36: {
@@ -906,39 +899,32 @@
           StorageLive(_163);
           _163 = &_3;
           StorageLive(_164);
--         StorageLive(_165);
--         StorageLive(_166);
-+         nop;
-+         nop;
+          StorageLive(_165);
+          StorageLive(_166);
           _166 = copy (*_163);
           StorageLive(_167);
           _167 = copy _1;
 -         _165 = Add(move _166, move _167);
-+         _165 = Add(copy _166, copy _1);
++         _165 = Add(move _166, copy _1);
           StorageDead(_167);
--         StorageDead(_166);
--         _164 = opaque::<u64>(move _165) -> [return: bb43, unwind continue];
-+         nop;
-+         _164 = opaque::<u64>(copy _165) -> [return: bb43, unwind continue];
+          StorageDead(_166);
+          _164 = opaque::<u64>(move _165) -> [return: bb43, unwind continue];
       }
   
       bb43: {
--         StorageDead(_165);
-+         nop;
+          StorageDead(_165);
           StorageDead(_164);
           StorageLive(_168);
           StorageLive(_169);
           StorageLive(_170);
--         _170 = copy (*_163);
-+         _170 = copy _166;
+          _170 = copy (*_163);
           StorageLive(_171);
           _171 = copy _1;
 -         _169 = Add(move _170, move _171);
-+         _169 = copy _165;
++         _169 = Add(move _170, copy _1);
           StorageDead(_171);
           StorageDead(_170);
--         _168 = opaque::<u64>(move _169) -> [return: bb44, unwind continue];
-+         _168 = opaque::<u64>(copy _165) -> [return: bb44, unwind continue];
+          _168 = opaque::<u64>(move _169) -> [return: bb44, unwind continue];
       }
   
       bb44: {
