Implement weak persistent handles in the Dart API.

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 "vm/dart.h"
 #include "vm/isolate.h"
 #include "vm/object.h"
 #include "vm/stack_frame.h"
 #include "vm/verifier.h"
 #include "vm/visitor.h"
 
 namespace dart {
 
+enum {
+  kForwardingMask = 3,
+  kNotForwarded = 1,  // Tagged pointer.
+  kForwarded = 3,  // Tagged pointer and forwarding bit set.
+};
+
+
+static inline bool IsForwarding(uword header) {
+  uword bits = header & kForwardingMask;
+  ASSERT((bits == kNotForwarded) || (bits == kForwarded));
+  return bits == kForwarded;
+}
+
+
+static inline uword ForwardedAddr(uword header) {
+  ASSERT(IsForwarding(header));
+  return header & ~kForwardingMask;
+}
+
+
+static inline void ForwardTo(uword orignal, uword target) {
+  // Make sure forwarding can be encoded.
+  ASSERT((target & kForwardingMask) == 0);
+  *reinterpret_cast<uword*>(orignal) = target | kForwarded;
+}
+
+
 class ScavengerVisitor : public ObjectPointerVisitor {
  public:
   explicit ScavengerVisitor(Scavenger* scavenger)
       : scavenger_(scavenger),
         heap_(scavenger->heap_),
         vm_heap_(Dart::vm_isolate()->heap()) {}
 
   void VisitPointers(RawObject** first, RawObject** last) {
     for (RawObject** current = first; current <= last; current++) {
       ScavengePointer(current);
     }
   }
 
  private:
-  enum {
-    kForwardingMask = 3,
-    kNotForwarded = 1,  // Tagged pointer.
-    kForwarded = 3,  // Tagged pointer and forwarding bit set.
-  };
-
-  static inline bool IsForwarding(uword header) {
-    uword bits = header & kForwardingMask;
-    ASSERT((bits == kNotForwarded) || (bits == kForwarded));
-    return bits == kForwarded;
-  }
-
-  static inline uword ForwardedAddr(uword header) {
-    ASSERT(IsForwarding(header));
-    return header & ~kForwardingMask;
-  }
-
-  static inline void ForwardTo(uword orignal, uword target) {
-    // Make sure forwarding can be encoded.
-    ASSERT((target & kForwardingMask) == 0);
-    *reinterpret_cast<uword*>(orignal) = target | kForwarded;
-  }
-
   void UpdateStoreBuffer(RawObject** p, RawObject* obj) {
     // TODO(iposva): Implement store buffers.
   }
 
   void ScavengePointer(RawObject** p) {
     RawObject* raw_obj = *p;
 
     // Fast exit if the raw object is a Smi.
     if (!raw_obj->IsHeapObject()) return;
 
@@ skipping 35 matching lines @@
     // Update the reference.
     RawObject* new_obj = RawObject::FromAddr(new_addr);
     *p = new_obj;
     // Update the store buffer as needed.
     UpdateStoreBuffer(p, new_obj);
   }
 
   Scavenger* scavenger_;
   Heap* heap_;
   Heap* vm_heap_;
+
+  DISALLOW_COPY_AND_ASSIGN(ScavengerVisitor);
 };
 
 
+class ScavengerWeakVisitor : public ObjectPointerVisitor {
+ public:
+  explicit ScavengerWeakVisitor(Scavenger* scavenger) : scavenger_(scavenger) {
+  }
+
+  void VisitPointers(RawObject** first, RawObject** last) {
+    for (RawObject** current = first; current <= last; current++) {
+      RawObject* raw_obj = *current;
+      ASSERT(raw_obj->IsHeapObject());
+      uword raw_addr = RawObject::ToAddr(raw_obj);
+      if (scavenger_->from_->Contains(raw_addr)) {
+        uword header = *reinterpret_cast<uword*>(raw_addr);
+        if (IsForwarding(header)) {
+          *current = RawObject::FromAddr(ForwardedAddr(header));
+        } else {
+          *current = Object::null();
+        }
+      }
+    }
+  }
+
+ private:
+  Scavenger* scavenger_;
+
+  DISALLOW_COPY_AND_ASSIGN(ScavengerWeakVisitor);
+};
+
+
 Scavenger::Scavenger(Heap* heap, intptr_t max_capacity, uword object_alignment)
     : heap_(heap),
       object_alignment_(object_alignment),
       count_(0),
       scavenging_(false) {
   // Allocate the virtual memory for this scavenge heap.
   space_ = VirtualMemory::Reserve(max_capacity);
   ASSERT(space_ != NULL);
 
   // Allocate the entire space at the beginning.
@@ skipping 39 matching lines @@
 
 
 void Scavenger::Epilogue() {
 #if defined(DEBUG)
   memset(from_->pointer(), 0xf3, from_->size());
 #endif  // defined(DEBUG)
 }
 
 
 void Scavenger::IterateRoots(Isolate* isolate, ObjectPointerVisitor* visitor) {
-  isolate->VisitObjectPointers(visitor,
-                               StackFrameIterator::kDontValidateFrames);
+  isolate->VisitStrongObjectPointers(visitor,
+                                     StackFrameIterator::kDontValidateFrames);
   heap_->IterateOldPointers(visitor);
 }
 
 
+void Scavenger::IterateWeakRoots(Isolate* isolate,
+                                 ObjectPointerVisitor* visitor) {
+  isolate->VisitWeakObjectPointers(visitor);
+}
+
+
 void Scavenger::ProcessToSpace(ObjectPointerVisitor* visitor) {
   uword resolved_top = FirstObjectStart();
   // Iterate until all work has been drained.
   while (resolved_top < top_) {
     RawObject* raw_obj = RawObject::FromAddr(resolved_top);
     resolved_top += raw_obj->VisitPointers(visitor);
   }
 }
 
 
@@ skipping 13 matching lines @@
   Isolate* isolate = Isolate::Current();
   NoHandleScope no_handles(isolate);
 
   Timer timer(FLAG_verbose_gc, "Scavenge");
   timer.Start();
   // Setup the visitor and run a scavenge.
   ScavengerVisitor visitor(this);
   Prologue();
   IterateRoots(isolate, &visitor);
   ProcessToSpace(&visitor);
+  ScavengerWeakVisitor weak_visitor(this);
+  IterateWeakRoots(isolate, &weak_visitor);
   Epilogue();
   timer.Stop();
   if (FLAG_verbose_gc) {
     OS::PrintErr("Scavenge[%d]: %dus\n", count_, timer.TotalElapsedTime());
   }
 
   count_++;
   // Done scavenging. Reset the marker.
   ASSERT(scavenging_);
   scavenging_ = false;
 }
 
 }  // namespace dart