Do not hash opaques in GVN.

Author: cjgillot

compiler/rustc_mir_transform/src/gvn.rs

@@ -153,9 +153,15 @@ impl<'tcx> crate::MirPass<'tcx> for GVN {
 }
 
 newtype_index! {
+    #[debug_format = "_v{}"]
     struct VnIndex {}
 }
 
+newtype_index! {
+    #[debug_format = "_o{}"]
+    struct VnOpaque {}
+}
+
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
 enum AddressKind {
     Ref(BorrowKind),
@@ -167,7 +173,7 @@ enum Value<'tcx> {
     // Root values.
     /// Used to represent values we know nothing about.
     /// The `usize` is a counter incremented by `new_opaque`.
-    Opaque(usize),
+    Opaque(VnOpaque),
     /// Evaluated or unevaluated constant value.
     Constant {
         value: Const<'tcx>,
@@ -219,8 +225,7 @@ struct ValueSet<'tcx> {
     hashes: IndexVec<VnIndex, u64>,
     values: IndexVec<VnIndex, Value<'tcx>>,
     types: IndexVec<VnIndex, Ty<'tcx>>,
-    /// Counter to generate different values.
-    next_opaque: usize,
+    opaques: IndexVec<VnOpaque, VnIndex>,
 }
 
 impl<'tcx> ValueSet<'tcx> {
@@ -230,12 +235,16 @@ impl<'tcx> ValueSet<'tcx> {
             hashes: IndexVec::with_capacity(num_values),
             values: IndexVec::with_capacity(num_values),
             types: IndexVec::with_capacity(num_values),
-            next_opaque: 1,
+            opaques: IndexVec::with_capacity(num_values),
         }
     }
 
     #[allow(rustc::pass_by_value)]
     fn insert(&mut self, value: Value<'tcx>, ty: Ty<'tcx>) -> (VnIndex, bool) {
+        if let Value::Opaque(opaque) = value {
+            return (self.opaques[opaque], false);
+        }
+
         let hash: u64 = {
             let mut h = FxHasher::default();
             value.hash(&mut h);
@@ -263,10 +272,14 @@ impl<'tcx> ValueSet<'tcx> {
     }
 
     #[inline]
-    fn next_opaque(&mut self) -> usize {
-        let next_opaque = self.next_opaque;
-        self.next_opaque += 1;
-        next_opaque
+    fn new_opaque(&mut self, ty: Ty<'tcx>) -> VnIndex {
+        let index = self.hashes.push(0);
+        let _index = self.types.push(ty);
+        debug_assert_eq!(index, _index);
+        let opaque = self.opaques.push(index);
+        let _index = self.values.push(Value::Opaque(opaque));
+        debug_assert_eq!(index, _index);
+        index
     }
 
     #[inline]
@@ -281,7 +294,7 @@ impl<'tcx> ValueSet<'tcx> {
 
     #[inline]
     fn forget(&mut self, index: VnIndex) {
-        let opaque = self.next_opaque();
+        let opaque = self.opaques.push(index);
         self.values[index] = Value::Opaque(opaque);
     }
 }
@@ -299,6 +312,8 @@ struct VnState<'body, 'tcx> {
     values: ValueSet<'tcx>,
     /// Values evaluated as constants if possible.
     evaluated: IndexVec<VnIndex, Option<OpTy<'tcx>>>,
+    /// Counter to generate different values.
+    next_disambiguator: usize,
     /// Cache the deref values.
     derefs: Vec<VnIndex>,
     ssa: &'body SsaLocals,
@@ -331,6 +346,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
             rev_locals: IndexVec::with_capacity(num_values),
             values: ValueSet::new(num_values),
             evaluated: IndexVec::with_capacity(num_values),
+            next_disambiguator: 1,
             derefs: Vec::new(),
             ssa,
             dominators,
@@ -360,8 +376,19 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
     /// from all the others.
     #[instrument(level = "trace", skip(self), ret)]
     fn new_opaque(&mut self, ty: Ty<'tcx>) -> VnIndex {
-        let value = Value::Opaque(self.values.next_opaque());
-        self.insert(ty, value)
+        let index = self.values.new_opaque(ty);
+        let _index = self.evaluated.push(None);
+        debug_assert_eq!(index, _index);
+        let _index = self.rev_locals.push(SmallVec::new());
+        debug_assert_eq!(index, _index);
+        index
+    }
+
+    #[inline]
+    fn next_disambiguator(&mut self) -> usize {
+        let next_disambiguator = self.next_disambiguator;
+        self.next_disambiguator += 1;
+        next_disambiguator
     }
 
     /// Create a new `Value::Address` distinct from all the others.
@@ -374,7 +401,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
             }
             AddressKind::Address(mutbl) => Ty::new_ptr(self.tcx, pty, mutbl.to_mutbl_lossy()),
         };
-        let value = Value::Address { place, kind, provenance: self.values.next_opaque() };
+        let value = Value::Address { place, kind, provenance: self.next_disambiguator() };
         self.insert(ty, value)
     }
 
@@ -403,7 +430,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
         } else {
             // Multiple mentions of this constant will yield different values,
             // so assign a different `disambiguator` to ensure they do not get the same `VnIndex`.
-            let disambiguator = self.values.next_opaque();
+            let disambiguator = self.next_disambiguator();
             // `disambiguator: 0` means deterministic.
             debug_assert_ne!(disambiguator, 0);
             disambiguator