- Remember objects (not addresses) in the old generation containing new pointers.

runtime/vm/gc_marker.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/gc_marker.h"
 
 #include <map>
 #include <utility>
 
 #include "vm/allocation.h"
@@ skipping 110 matching lines @@
  public:
   MarkingVisitor(Isolate* isolate,
                  Heap* heap,
                  PageSpace* page_space,
                  MarkingStack* marking_stack)
       : ObjectPointerVisitor(isolate),
         heap_(heap),
         vm_heap_(Dart::vm_isolate()->heap()),
         page_space_(page_space),
         marking_stack_(marking_stack),
-        update_store_buffers_(false) {
+        visiting_old_object_(NULL) {
     ASSERT(heap_ != vm_heap_);
   }
 
   MarkingStack* marking_stack() const { return marking_stack_; }
 
   void VisitPointers(RawObject** first, RawObject** last) {
     for (RawObject** current = first; current <= last; current++) {
       MarkObject(*current, current);
     }
   }
@@ skipping 10 matching lines @@
     delay_set_.insert(std::make_pair(raw_key, raw_weak));
   }
 
   void Finalize() {
     DelaySet::iterator it = delay_set_.begin();
     for (; it != delay_set_.end(); ++it) {
       WeakProperty::Clear(it->second);
     }
   }
 
-  void set_update_store_buffers(bool val) { update_store_buffers_ = val; }
+  void VisitingOldObject(RawObject* obj) {
+    ASSERT((obj == NULL) || obj->IsOldObject());
+    visiting_old_object_ = obj;
+  }
 
  private:
   void MarkAndPush(RawObject* raw_obj) {
     ASSERT(raw_obj->IsHeapObject());
     ASSERT((FLAG_verify_before_gc || FLAG_verify_before_gc) ?
            page_space_->Contains(RawObject::ToAddr(raw_obj)) :
            true);
 
     // Mark the object and push it on the marking stack.
     ASSERT(!raw_obj->IsMarked());
@@ skipping 22 matching lines @@
   void MarkObject(RawObject* raw_obj, RawObject** p) {
     // Fast exit if the raw object is a Smi.
     if (!raw_obj->IsHeapObject()) return;
 
     // Fast exit if the raw object is marked.
     if (raw_obj->IsMarked()) return;
 
     // Skip over new objects, but verify consistency of heap while at it.
     if (raw_obj->IsNewObject()) {
       // TODO(iposva): Add consistency check.
-      if (update_store_buffers_) {
+      if (visiting_old_object_ != NULL) {
         ASSERT(p != NULL);
-        isolate()->store_buffer()->AddPointer(reinterpret_cast<uword>(p));
+        isolate()->store_buffer()->AddPointer(
+            reinterpret_cast<uword>(visiting_old_object_));
       }
       return;
     }
 
     MarkAndPush(raw_obj);
   }
 
   Heap* heap_;
   Heap* vm_heap_;
   PageSpace* page_space_;
   MarkingStack* marking_stack_;
+  RawObject* visiting_old_object_;
   typedef std::multimap<RawObject*, RawWeakProperty*> DelaySet;
   DelaySet delay_set_;
-  bool update_store_buffers_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(MarkingVisitor);
 };
 
 
 bool IsUnreachable(const RawObject* raw_obj) {
   if (!raw_obj->IsHeapObject()) {
     return false;
   }
   if (raw_obj == Object::null()) {
@@ skipping 109 matching lines @@
     state->set_delayed_weak_reference_sets(NULL);
     while (queue != NULL) {
       delete WeakReferenceSet::Pop(&queue);
     }
   }
 }
 
 
 void GCMarker::DrainMarkingStack(Isolate* isolate,
                                  MarkingVisitor* visitor) {
-  visitor->set_update_store_buffers(true);
   while (!visitor->marking_stack()->IsEmpty()) {
     RawObject* raw_obj = visitor->marking_stack()->Pop();
+    visitor->VisitingOldObject(raw_obj);
     if (raw_obj->GetClassId() != kWeakPropertyCid) {
       raw_obj->VisitPointers(visitor);
     } else {
       RawWeakProperty* raw_weak = reinterpret_cast<RawWeakProperty*>(raw_obj);
       ProcessWeakProperty(raw_weak, visitor);
     }
   }
-  visitor->set_update_store_buffers(false);
+  visitor->VisitingOldObject(NULL);
 }
 
 
 void GCMarker::ProcessWeakProperty(RawWeakProperty* raw_weak,
                                    MarkingVisitor* visitor) {
   // The fate of the weak property is determined by its key.
   RawObject* raw_key = raw_weak->ptr()->key_;
   if (raw_key->IsHeapObject() &&
       raw_key->IsOldObject() &&
       !raw_key->IsMarked()) {
@@ skipping 33 matching lines @@
   DrainMarkingStack(isolate, &mark);
   IterateWeakReferences(isolate, &mark);
   MarkingWeakVisitor mark_weak;
   IterateWeakRoots(isolate, &mark_weak, invoke_api_callbacks);
   mark.Finalize();
   ProcessPeerReferents(page_space);
   Epilogue(isolate, invoke_api_callbacks);
 }
 
 }  // namespace dart