Don't NULL-check GlobalHandle::Node::object_

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/global-handles.h"
 
 #include "src/api.h"
 #include "src/v8.h"
 #include "src/vm-state-inl.h"
 
@@ skipping 60 matching lines @@
     } else {
       set_partially_dependent(false);
     }
     set_in_new_space_list(false);
     parameter_or_next_free_.next_free = NULL;
     weak_callback_ = NULL;
   }
 #endif
 
   void Initialize(int index, Node** first_free) {
+    object_ = reinterpret_cast<Object*>(kGlobalHandleZapValue);

[vogelheim, 2016/01/25 12:00:19]

nitpick: Wouldn't it be better for debugging to distinguish the "not
initialized" guard value from the "already dead" value? I.e., introduce a
kGlobalHandleUninitialized?

(Not sure if worth the hassle, though.)

[jochen (gone - plz use gerrit), 2016/01/25 13:05:48]

since we recycle handles, they're expected to constantly go back and forth
between zapped and valid

     index_ = static_cast<uint8_t>(index);
     DCHECK(static_cast<int>(index_) == index);
     set_state(FREE);
     set_weakness_type(NORMAL_WEAK);
     set_in_new_space_list(false);
     parameter_or_next_free_.next_free = *first_free;
     *first_free = this;
   }
 
   void Acquire(Object* object) {
     DCHECK(state() == FREE);
     object_ = object;

[vogelheim, 2016/01/25 12:00:19]

Maybe DCHECK(object != nullptr)?

[jochen (gone - plz use gerrit), 2016/01/25 13:05:48]

nullptr is valid here (since that's Smi::FromInt(0))

the zap value is a heap ptr (ie the lowest bit is 1), so that should actually
never happen

     class_id_ = v8::HeapProfiler::kPersistentHandleNoClassId;
     set_independent(false);
     if (FLAG_scavenge_reclaim_unmodified_objects) {
       set_active(false);
     } else {
       set_partially_dependent(false);
     }
     set_state(NORMAL);
     parameter_or_next_free_.parameter = NULL;
     weak_callback_ = NULL;
@@ skipping 140 matching lines @@
   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) {
-    DCHECK(weak_callback != NULL);
+    DCHECK(weak_callback != nullptr);
     DCHECK(IsInUse());
-    CHECK(object_ != NULL);
+    CHECK_NE(object_, reinterpret_cast<Object*>(kGlobalHandleZapValue));
     set_state(WEAK);
     set_weakness_type(NORMAL_WEAK);
     set_parameter(parameter);
     weak_callback_ = weak_callback;
   }
 
   void MakeWeak(void* parameter,
                 WeakCallbackInfo<void>::Callback phantom_callback,
                 v8::WeakCallbackType type) {
     DCHECK(phantom_callback != nullptr);
     DCHECK(IsInUse());
-    CHECK(object_ != nullptr);
+    CHECK_NE(object_, reinterpret_cast<Object*>(kGlobalHandleZapValue));
     set_state(WEAK);
     switch (type) {
       case v8::WeakCallbackType::kParameter:
         set_weakness_type(PHANTOM_WEAK);
         break;
       case v8::WeakCallbackType::kInternalFields:
       set_weakness_type(PHANTOM_WEAK_2_INTERNAL_FIELDS);
       break;
     }
     set_parameter(parameter);
@@ skipping 1098 matching lines @@
   blocks_[block][offset] = object;
   if (isolate->heap()->InNewSpace(object)) {
     new_space_indices_.Add(size_);
   }
   *index = size_++;
 }
 
 
 }  // namespace internal
 }  // namespace v8