- Avoid scavenging the same location twice.

runtime/vm/scavenger.cc

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/scavenger.h"
 
 #include <algorithm>
 #include <map>
 #include <utility>
 
@@ skipping 140 matching lines @@
     BoolScope bs(&in_scavenge_pointer_, true);
 #endif
 
     RawObject* raw_obj = *p;
 
     if (raw_obj->IsSmiOrOldObject()) {
       return;
     }
 
     uword raw_addr = RawObject::ToAddr(raw_obj);
-    // The scavenger is only interested in objects located in the from space.
-    if (scavenger_->to_->Contains(raw_addr)) {
-      return;
-    }
+    // The scavenger is only expects objects located in the from space.
     ASSERT(from_->Contains(raw_addr));
     // Read the header word of the object and determine if the object has
     // already been copied.
     uword header = *reinterpret_cast<uword*>(raw_addr);
     uword new_addr = 0;
     if (IsForwarding(header)) {
       // Get the new location of the object.
       new_addr = ForwardedAddr(header);
     } else {
       if (raw_obj->IsWatched()) {
@@ skipping 436 matching lines @@
         // We do not have to process sets that have just one key/value pair
         // and the key and value are identical.
         continue;
       }
       bool is_unreachable = true;
       // Test each key object for reachability.  If a key object is
       // reachable, all value objects should be scavenged.
       for (intptr_t k = 0; k < num_keys; ++k) {
         if (!IsUnreachable(reference_set->get_key(k))) {
           for (intptr_t v = 0; v < num_values; ++v) {
-            visitor->VisitPointer(reference_set->get_value(v));
+            RawObject** raw_obj_addr = reference_set->get_value(v);
+            RawObject* raw_obj = *raw_obj_addr;
+            // Only visit heap objects which are in from space, aka new objects
+            // not in to space. This avoids visiting a value multiple times
+            // during a scavenge.
+            if (raw_obj->IsHeapObject() &&
+                raw_obj->IsNewObject() &&
+                !to_->Contains(RawObject::ToAddr(raw_obj))) {
+              visitor->VisitPointer(raw_obj_addr);
+            }
           }
           is_unreachable = false;
           // Since we have found a key object that is reachable and all
           // value objects have been marked we can break out of iterating
           // this set and move on to the next set.
           break;
         }
       }
       // If all key objects are unreachable put the reference on a
       // delay queue.  This reference will be revisited if another
@@ skipping 264 matching lines @@
 }
 
 
 void Scavenger::FreeExternal(intptr_t size) {
   ASSERT(size >= 0);
   external_size_ -= size;
   ASSERT(external_size_ >= 0);
 }
 
 }  // namespace dart