Introduce phantom weak handles in the API and use them internally for debug info

src/global-handles.cc

 // Copyright 2009 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/v8.h"
 
 #include "src/api.h"
 #include "src/global-handles.h"
 
 #include "src/vm-state-inl.h"
@@ skipping 128 matching lines @@
     flags_ = IsPartiallyDependent::update(flags_, v);
   }
 
   bool is_in_new_space_list() {
     return IsInNewSpaceList::decode(flags_);
   }
   void set_in_new_space_list(bool v) {
     flags_ = IsInNewSpaceList::update(flags_, v);
   }
 
+  bool is_zapped_during_weak_callback() {
+    return IsZappedDuringWeakCallback::decode(flags_);
+  }
+  void set_is_zapped_during_weak_callback(bool v) {
+    flags_ = IsZappedDuringWeakCallback::update(flags_, v);
+  }
+
   bool IsNearDeath() const {
     // Check for PENDING to ensure correct answer when processing callbacks.
     return state() == PENDING || state() == NEAR_DEATH;
   }
 
   bool IsWeak() const { return state() == WEAK; }
 
   bool IsRetainer() const { return state() != FREE; }
 
   bool IsStrongRetainer() const { return state() == NORMAL; }
@@ skipping 38 matching lines @@
   // Accessors for next free node in the free list.
   Node* next_free() {
     DCHECK(state() == FREE);
     return parameter_or_next_free_.next_free;
   }
   void set_next_free(Node* value) {
     DCHECK(state() == FREE);
     parameter_or_next_free_.next_free = value;
   }
 
-  void MakeWeak(void* parameter, WeakCallback weak_callback) {
+  void MakeWeak(void* parameter, WeakCallback weak_callback,
+                bool is_zapped_during_weak_callback = false) {
     DCHECK(weak_callback != NULL);
     DCHECK(state() != FREE);
     CHECK(object_ != NULL);
     set_state(WEAK);
     set_parameter(parameter);
+    set_is_zapped_during_weak_callback(is_zapped_during_weak_callback);
     weak_callback_ = weak_callback;
   }
 
   void* ClearWeakness() {
     DCHECK(state() != FREE);
     void* p = parameter();
     set_state(NORMAL);
     set_parameter(NULL);
     return p;
   }
 
   bool PostGarbageCollectionProcessing(Isolate* isolate) {
     if (state() != Node::PENDING) return false;
     if (weak_callback_ == NULL) {
       Release();
       return false;
     }
-    void* par = parameter();
+    void* param = parameter();
     set_state(NEAR_DEATH);
     set_parameter(NULL);
 
     Object** object = location();
     {
       // Check that we are not passing a finalized external string to
       // the callback.
       DCHECK(!object_->IsExternalOneByteString() ||
              ExternalOneByteString::cast(object_)->resource() != NULL);
       DCHECK(!object_->IsExternalTwoByteString() ||
              ExternalTwoByteString::cast(object_)->resource() != NULL);
       // Leaving V8.
       VMState<EXTERNAL> state(isolate);
       HandleScope handle_scope(isolate);
       Handle<Object> handle(*object, isolate);
+      if (is_zapped_during_weak_callback()) {
+        DCHECK(*handle == Smi::FromInt(kPhantomReferenceZap));
+      }
       v8::WeakCallbackData<v8::Value, void> data(
-          reinterpret_cast<v8::Isolate*>(isolate),
-          v8::Utils::ToLocal(handle),
-          par);
+          reinterpret_cast<v8::Isolate*>(isolate), v8::Utils::ToLocal(handle),
+          param);
       weak_callback_(data);
     }
     // Absence of explicit cleanup or revival of weak handle
     // in most of the cases would lead to memory leak.
     CHECK(state() != NEAR_DEATH);
     return true;
   }
 
   inline GlobalHandles* GetGlobalHandles();
 
@@ skipping 10 matching lines @@
   // Note: the most aligned fields should go first.
 
   // Wrapper class ID.
   uint16_t class_id_;
 
   // Index in the containing handle block.
   uint8_t index_;
 
   // This stores three flags (independent, partially_dependent and
   // in_new_space_list) and a State.
-  class NodeState:            public BitField<State, 0, 4> {};
-  class IsIndependent:        public BitField<bool,  4, 1> {};
-  class IsPartiallyDependent: public BitField<bool,  5, 1> {};
-  class IsInNewSpaceList:     public BitField<bool,  6, 1> {};
+  class NodeState : public BitField<State, 0, 4> {};
+  class IsIndependent : public BitField<bool, 4, 1> {};
+  class IsPartiallyDependent : public BitField<bool, 5, 1> {};
+  class IsInNewSpaceList : public BitField<bool, 6, 1> {};
+  class IsZappedDuringWeakCallback : public BitField<bool, 7, 1> {};
 
   uint8_t flags_;
 
   // Handle specific callback - might be a weak reference in disguise.
   WeakCallback weak_callback_;
 
   // Provided data for callback.  In FREE state, this is used for
   // the free list link.
   union {
     void* parameter;
@@ skipping 174 matching lines @@
   DCHECK(location != NULL);
   return Node::FromLocation(location)->GetGlobalHandles()->Create(*location);
 }
 
 
 void GlobalHandles::Destroy(Object** location) {
   if (location != NULL) Node::FromLocation(location)->Release();
 }
 
 
-void GlobalHandles::MakeWeak(Object** location,
-                             void* parameter,
-                             WeakCallback weak_callback) {
-  Node::FromLocation(location)->MakeWeak(parameter, weak_callback);
+void GlobalHandles::MakeWeak(Object** location, void* parameter,
+                             WeakCallback weak_callback, PhantomState phantom) {
+  Node::FromLocation(location)
+      ->MakeWeak(parameter, weak_callback, phantom == Phantom);
 }
 
 
 void* GlobalHandles::ClearWeakness(Object** location) {
   return Node::FromLocation(location)->ClearWeakness();
 }
 
 
 void GlobalHandles::MarkIndependent(Object** location) {
   Node::FromLocation(location)->MarkIndependent();
@@ skipping 15 matching lines @@
 }
 
 
 bool GlobalHandles::IsWeak(Object** location) {
   return Node::FromLocation(location)->IsWeak();
 }
 
 
 void GlobalHandles::IterateWeakRoots(ObjectVisitor* v) {
   for (NodeIterator it(this); !it.done(); it.Advance()) {
-    if (it.node()->IsWeakRetainer()) v->VisitPointer(it.node()->location());
+    if (it.node()->IsWeakRetainer()) {
+      if (it.node()->state() == Node::PENDING &&
+          it.node()->is_zapped_during_weak_callback()) {
+        *(it.node()->location()) = Smi::FromInt(kPhantomReferenceZap);
+      } else {
+        v->VisitPointer(it.node()->location());
+      }
+    }
   }
 }
 
 
 void GlobalHandles::IdentifyWeakHandles(WeakSlotCallback f) {
   for (NodeIterator it(this); !it.done(); it.Advance()) {
     if (it.node()->IsWeak() && f(it.node()->location())) {
       it.node()->MarkPending();
     }
   }
@@ skipping 519 matching lines @@
   DCHECK_EQ(isolate->heap()->the_hole_value(), blocks_[block][offset]);
   blocks_[block][offset] = object;
   if (isolate->heap()->InNewSpace(object)) {
     new_space_indices_.Add(size_);
   }
   *index = size_++;
 }
 
 
 } }  // namespace v8::internal