Use a DFS to compare CTFE snapshots

src/librustc/mir/interpret/pointer.rs

@@ -201,6 +201,13 @@ impl<'tcx, Tag> Pointer<Tag> {
         Pointer { alloc_id: self.alloc_id, offset: self.offset, tag: () }
     }
 
+    /// Replace any allocation IDs in this type with `()`.
+    ///
+    /// Used when comparing heap snapshots.
+    pub fn erase_alloc_id(self) -> Pointer<Tag, ()> {
+        Pointer { alloc_id: (), offset: self.offset, tag: self.tag }
+    }
+
     /// Test if the pointer is "inbounds" of an allocation of the given size.
     /// A pointer is "inbounds" even if its offset is equal to the size; this is
     /// a "one-past-the-end" pointer.

src/librustc/mir/interpret/value.rs

@@ -153,6 +153,16 @@ impl<'tcx, Tag> Scalar<Tag> {
         }
     }
 
+    /// Replace any allocation IDs in this type with `()`.
+    ///
+    /// Used when comparing heap snapshots.
+    pub fn erase_alloc_id(self) -> Scalar<Tag, ()> {
+        match self {
+            Scalar::Ptr(ptr) => Scalar::Ptr(ptr.erase_alloc_id()),
+            Scalar::Raw { data, size } => Scalar::Raw { data, size },
+        }
+    }
+
     #[inline]
     pub fn ptr_null(cx: &impl HasDataLayout) -> Self {
         Scalar::Raw {
@@ -509,6 +519,16 @@ impl<'tcx, Tag> ScalarMaybeUndef<Tag> {
         }
     }
 
+    /// Replace any allocation IDs in this type with `()`.
+    ///
+    /// Used when comparing heap snapshots.
+    pub fn erase_alloc_id(self) -> ScalarMaybeUndef<Tag, ()> {
+        match self {
+            ScalarMaybeUndef::Scalar(s) => ScalarMaybeUndef::Scalar(s.erase_alloc_id()),
+            ScalarMaybeUndef::Undef => ScalarMaybeUndef::Undef,
+        }
+    }
+
     #[inline]
     pub fn not_undef(self) -> InterpResult<'static, Scalar<Tag>> {
         match self {

src/librustc_mir/const_eval.rs

@@ -305,6 +305,8 @@ impl interpret::MayLeak for ! {
     }
 }
 
+pub type CtfeMemory<'mir, 'tcx> = Memory<'mir, 'tcx, CompileTimeInterpreter<'mir, 'tcx>>;
+
 impl<'mir, 'tcx> interpret::Machine<'mir, 'tcx> for CompileTimeInterpreter<'mir, 'tcx> {
     type MemoryKinds = !;
     type PointerTag = ();
@@ -445,7 +447,7 @@ impl<'mir, 'tcx> interpret::Machine<'mir, 'tcx> for CompileTimeInterpreter<'mir,
     }
 
     fn ptr_to_int(
-        _mem: &Memory<'mir, 'tcx, Self>,
+        _mem: &CtfeMemory<'mir, 'tcx>,
         _ptr: Pointer,
     ) -> InterpResult<'tcx, u64> {
         Err(
@@ -514,13 +516,16 @@ impl<'mir, 'tcx> interpret::Machine<'mir, 'tcx> for CompileTimeInterpreter<'mir,
             }
         }
 
+        // Emit a warning if this is the first time we have triggered the loop detector. This means
+        // we have been executing for quite some time.
         let span = ecx.frame().span;
-        ecx.machine.loop_detector.observe_and_analyze(
-            *ecx.tcx,
-            span,
-            &ecx.memory,
-            &ecx.stack[..],
-        )
+        if !ecx.machine.loop_detector.has_been_invoked() {
+            // FIXME(#49980): make this warning a lint
+            ecx.tcx.sess.span_warn(span,
+                "Constant evaluating a complex constant, this might take some time");
+        }
+
+        ecx.machine.loop_detector.observe_and_analyze(&ecx.stack, &ecx.memory)
     }
 
     #[inline(always)]

src/librustc_mir/interpret/eval_context.rs

@@ -121,7 +121,7 @@ pub struct LocalState<'tcx, Tag=(), Id=AllocId> {
 }
 
 /// Current value of a local variable
-#[derive(Clone, PartialEq, Eq, Debug, HashStable)] // Miri debug-prints these
+#[derive(Clone, PartialEq, Eq, Debug, Hash, HashStable)] // Miri debug-prints these
 pub enum LocalValue<Tag=(), Id=AllocId> {
     /// This local is not currently alive, and cannot be used at all.
     Dead,

src/librustc_mir/interpret/memory.rs

@@ -22,7 +22,7 @@ use super::{
     Machine, AllocMap, MayLeak, ErrorHandled, CheckInAllocMsg,
 };
 
-#[derive(Debug, PartialEq, Copy, Clone)]
+#[derive(Debug, PartialEq, Eq, Copy, Clone, Hash)]
 pub enum MemoryKind<T> {
     /// Stack memory. Error if deallocated except during a stack pop.
     Stack,
@@ -114,24 +114,6 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> HasDataLayout for Memory<'mir, 'tcx, M>
     }
 }
 
-// FIXME: Really we shouldn't clone memory, ever. Snapshot machinery should instead
-// carefully copy only the reachable parts.
-impl<'mir, 'tcx, M> Clone for Memory<'mir, 'tcx, M>
-where
-    M: Machine<'mir, 'tcx, PointerTag = (), AllocExtra = (), MemoryExtra = ()>,
-    M::MemoryMap: AllocMap<AllocId, (MemoryKind<M::MemoryKinds>, Allocation)>,
-{
-    fn clone(&self) -> Self {
-        Memory {
-            alloc_map: self.alloc_map.clone(),
-            extra_fn_ptr_map: self.extra_fn_ptr_map.clone(),
-            dead_alloc_map: self.dead_alloc_map.clone(),
-            extra: (),
-            tcx: self.tcx,
-        }
-    }
-}
-
 impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'mir, 'tcx, M> {
     pub fn new(tcx: TyCtxtAt<'tcx>, extra: M::MemoryExtra) -> Self {
         Memory {
@@ -950,3 +932,56 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'mir, 'tcx, M> {
         }
     }
 }
+
+/// A depth-first search over the allocation graph.
+///
+/// This is based on the DFS iterator in `rustc_data_structures`, which we cannot use directly
+/// because `AllocId` does not implement `Idx` (it is not dense).
+pub struct DepthFirstSearch<'mem, 'mir, 'tcx, M: Machine<'mir, 'tcx>> {
+    memory: &'mem Memory<'mir, 'tcx, M>,
+    visited: FxHashSet<AllocId>,
+    stack: Vec<AllocId>,
+}
+
+impl<M: Machine<'mir, 'tcx>> DepthFirstSearch<'mem, 'mir, 'tcx, M> {
+    /// Returns a new DFS iterator that will traverse all allocations reachable from the given
+    /// `AllocId`s.
+    ///
+    /// The first node in `roots` will be the first node visited by the DFS.
+    pub fn with_roots(
+        memory: &'mem Memory<'mir, 'tcx, M>,
+        roots: impl IntoIterator<Item = AllocId>,
+    ) -> Self {
+        let mut stack: Vec<_> = roots.into_iter().collect();
+        stack.reverse();
+
+        DepthFirstSearch {
+            memory,
+            visited: stack.iter().copied().collect(),
+            stack,
+        }
+    }
+}
+
+impl<M: Machine<'mir, 'tcx>> Iterator for DepthFirstSearch<'mem, 'mir, 'tcx, M> {
+    type Item = (AllocId, InterpResult<'tcx, &'mem Allocation<M::PointerTag, M::AllocExtra>>);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let DepthFirstSearch { stack, visited, memory } = self;
+
+        let id = stack.pop()?;
+        let alloc = memory.get_raw(id);
+
+        if let Ok(alloc) = alloc {
+            let new_pointers = alloc
+                .relocations()
+                .values()
+                .map(|&(_, id)| id)
+                .filter(|id| visited.insert(*id));
+
+            stack.extend(new_pointers);
+        }
+
+        Some((id, alloc))
+    }
+}

src/librustc_mir/interpret/operand.rs

@@ -91,6 +91,17 @@ impl<'tcx, Tag> Immediate<Tag> {
             Immediate::ScalarPair(a, b) => Ok((a.not_undef()?, b.not_undef()?))
         }
     }
+
+    /// Replace any allocation IDs in this type with `()`.
+    ///
+    /// Used when comparing heap snapshots.
+    pub(super) fn erase_alloc_id(self) -> Immediate<Tag, ()> {
+        match self {
+            Immediate::Scalar(a) => Immediate::Scalar(a.erase_alloc_id()),
+            Immediate::ScalarPair(a, b)
+                => Immediate::ScalarPair(a.erase_alloc_id(), b.erase_alloc_id()),
+        }
+    }
 }
 
 // ScalarPair needs a type to interpret, so we often have an immediate and a type together
@@ -176,6 +187,16 @@ impl<Tag> Operand<Tag> {
 
         }
     }
+
+    /// Replace any allocation IDs in this type with `()`.
+    ///
+    /// Used when comparing heap snapshots.
+    pub(super) fn erase_alloc_id(self) -> Operand<Tag, ()> {
+        match self {
+            Operand::Immediate(imm) => Operand::Immediate(imm.erase_alloc_id()),
+            Operand::Indirect(place) => Operand::Indirect(place.erase_alloc_id()),
+        }
+    }
 }
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]

src/librustc_mir/interpret/place.rs

@@ -105,6 +105,17 @@ impl<Tag> MemPlace<Tag> {
         }
     }
 
+    /// Replace any allocation IDs in this type with `()`.
+    ///
+    /// Used when comparing heap snapshots.
+    pub fn erase_alloc_id(self) -> MemPlace<Tag, ()> {
+        MemPlace {
+            ptr: self.ptr.erase_alloc_id(),
+            align: self.align,
+            meta: self.meta.map(Scalar::erase_alloc_id),
+        }
+    }
+
     #[inline(always)]
     pub fn from_scalar_ptr(ptr: Scalar<Tag>, align: Align) -> Self {
         MemPlace {