avoid printing allocations twice

diff --git a/src/librustc_mir/interpret/machine.rs b/src/librustc_mir/interpret/machine.rs
index 48082a1e3469680126ecbb62ad9da812ada31cdb..8875baad58cfbb09133231d6378f5b6b9af735a7 100644 (file)
--- a/src/librustc_mir/interpret/machine.rs
+++ b/src/librustc_mir/interpret/machine.rs
@@ -51,7 +51,7 @@ fn remove<Q: ?Sized + Hash + Eq>(&mut self, k: &Q) -> Option<V>
     where
         K: Borrow<Q>;
 
-    /// Returns data based the keys and values in the map.
+    /// Returns data based on the keys and values in the map.
     fn filter_map_collect<T>(&self, f: impl FnMut(&K, &V) -> Option<T>) -> Vec<T>;
 
     /// Returns a reference to entry `k`. If no such entry exists, call

diff --git a/src/librustc_mir/interpret/memory.rs b/src/librustc_mir/interpret/memory.rs
index a97df313ea05be8c56166c5ef737fe63b5cd08f8..66357a48634f48c650b701dced2f6ffd7c0fbf91 100644 (file)
--- a/src/librustc_mir/interpret/memory.rs
+++ b/src/librustc_mir/interpret/memory.rs
@@ -646,14 +646,11 @@ pub fn dump_alloc(&self, id: AllocId) {
 
     fn dump_alloc_helper<Tag, Extra>(
         &self,
-        allocs_seen: &mut FxHashSet<AllocId>,
         allocs_to_print: &mut VecDeque<AllocId>,
         alloc: &Allocation<Tag, Extra>,
     ) {
         for &(_, target_id) in alloc.relocations().values() {
-            if allocs_seen.insert(target_id) {
-                allocs_to_print.push_back(target_id);
-            }
+            allocs_to_print.push_back(target_id);
         }
         crate::util::pretty::write_allocation(self.tcx.tcx, alloc, &mut std::io::stderr(), "")
             .unwrap();
@@ -666,9 +663,14 @@ pub fn dump_allocs(&self, mut allocs: Vec<AllocId>) {
         allocs.sort();
         allocs.dedup();
         let mut allocs_to_print = VecDeque::from(allocs);
-        let mut allocs_seen = FxHashSet::default();
+        // `allocs_printed` contains all allocations that we have already printed.
+        let mut allocs_printed = FxHashSet::default();
 
         while let Some(id) = allocs_to_print.pop_front() {
+            if !allocs_printed.insert(id) {
+                // Already printed, so skip this.
+                continue;
+            }
             eprint!("Alloc {:<5}: ", id);
             fn msg<Tag, Extra>(alloc: &Allocation<Tag, Extra>, extra: &str) {
                 eprintln!(
@@ -688,14 +690,14 @@ fn msg<Tag, Extra>(alloc: &Allocation<Tag, Extra>, extra: &str) {
                         MemoryKind::CallerLocation => msg(alloc, " (caller_location)"),
                         MemoryKind::Machine(m) => msg(alloc, &format!(" ({:?})", m)),
                     };
-                    self.dump_alloc_helper(&mut allocs_seen, &mut allocs_to_print, alloc);
+                    self.dump_alloc_helper(&mut allocs_to_print, alloc);
                 }
                 Err(()) => {
                     // global alloc?
                     match self.tcx.alloc_map.lock().get(id) {
                         Some(GlobalAlloc::Memory(alloc)) => {
                             msg(alloc, " (immutable)");
-                            self.dump_alloc_helper(&mut allocs_seen, &mut allocs_to_print, alloc);
+                            self.dump_alloc_helper(&mut allocs_to_print, alloc);
                         }
                         Some(GlobalAlloc::Function(func)) => {
                             eprintln!("{}", func);
@@ -722,8 +724,8 @@ pub fn leak_report(&self) -> usize {
             });
             while let Some(id) = todo.pop() {
                 if reachable.insert(id) {
+                    // This is a new allocation, add its relocations to `todo`.
                     if let Some((_, alloc)) = self.alloc_map.get(id) {
-                        // This is a new allocation, add its relocations to `todo`.
                         todo.extend(alloc.relocations().values().map(|&(_, target_id)| target_id));
                     }
                 }