Avoid handle dereference during graph optimization.

src/handles-inl.h

 // Copyright 2006-2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 45 matching lines @@
 Handle<T>::Handle(T* obj, Isolate* isolate) {
   ASSERT(!obj->IsFailure());
   location_ = HandleScope::CreateHandle(obj, isolate);
 }
 
 
 template <typename T>
 inline T* Handle<T>::operator*() const {
   ASSERT(location_ != NULL);
   ASSERT(reinterpret_cast<Address>(*location_) != kHandleZapValue);
+  SLOW_ASSERT(ISOLATE->allow_handle_deref());
   return *BitCast<T**>(location_);
 }
 
 
 HandleScope::HandleScope() {
   Isolate* isolate = Isolate::Current();
   v8::ImplementationUtilities::HandleScopeData* current =
       isolate->handle_scope_data();
   isolate_ = isolate;
   prev_next_ = current->next;
@@ skipping 92 matching lines @@
 inline NoHandleAllocation::~NoHandleAllocation() {
   if (active_) {
     // Restore state in current handle scope to re-enable handle
     // allocations.
     v8::ImplementationUtilities::HandleScopeData* data =
         Isolate::Current()->handle_scope_data();
     ASSERT_EQ(0, data->level);
     data->level = level_;
   }
 }
+
+
+NoHandleDereference::NoHandleDereference() {
+  Isolate* isolate = Isolate::Current();
+  active_ = !isolate->optimizing_compiler_thread()->IsOptimizerThread();

[Jakob Kummerow, 2013/01/23 12:09:18]

I'd appreciate a comment here, something along the lines of: "The guard can only
be enabled for all threads at once, so we can only do that when parallel
compilation is disabled. Checking for the current thread is sufficient to detect
that, because this constructor is only ever called from the optimizer thread."
While typing this it occurred to me: why not just hook this off the
FLAG_parallel_recompilation?

[Yang, 2013/01/23 13:34:25]

Done.

+  if (active_) {
+    old_state_ = isolate->allow_handle_deref();
+    isolate->set_allow_handle_deref(false);
+  }
+}
+
+
+NoHandleDereference::~NoHandleDereference() {
+  if (active_) Isolate::Current()->set_allow_handle_deref(old_state_);
+}
+
+
+AllowHandleDereference::AllowHandleDereference() {
+  Isolate* isolate = Isolate::Current();
+  active_ = !isolate->optimizing_compiler_thread()->IsOptimizerThread();
+  if (active_) {
+    old_state_ = isolate->allow_handle_deref();
+    isolate->set_allow_handle_deref(true);
+  }
+}
+
+
+AllowHandleDereference::~AllowHandleDereference() {
+  if (active_) Isolate::Current()->set_allow_handle_deref(old_state_);
+}
 #endif
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_HANDLES_INL_H_