Disallow dereferencing deferred handles when generating optimized code.

src/isolate.h

 // Copyright 2012 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 973 matching lines @@
 
 #ifdef DEBUG
   HistogramInfo* heap_histograms() { return heap_histograms_; }
 
   JSObject::SpillInformation* js_spill_information() {
     return &js_spill_information_;
   }
 
   int* code_kind_statistics() { return code_kind_statistics_; }
 
-  bool AllowHandleDereference();
+  HandleDereferenceGuard::State HandleDereferenceGuardState();
 
-  void SetAllowHandleDereference(bool allow);
+  void SetHandleDereferenceGuardState(HandleDereferenceGuard::State state);
 #endif
 
 #if defined(V8_TARGET_ARCH_ARM) && !defined(__arm__) || \
     defined(V8_TARGET_ARCH_MIPS) && !defined(__mips__)
   bool simulator_initialized() { return simulator_initialized_; }
   void set_simulator_initialized(bool initialized) {
     simulator_initialized_ = initialized;
   }
 
   HashMap* simulator_i_cache() { return simulator_i_cache_; }
@@ skipping 60 matching lines @@
     date_cache_ = date_cache;
   }
 
   CodeStubInterfaceDescriptor*
       code_stub_interface_descriptor(int index);
 
   void IterateDeferredHandles(ObjectVisitor* visitor);
   void LinkDeferredHandles(DeferredHandles* deferred_handles);
   void UnlinkDeferredHandles(DeferredHandles* deferred_handles);
 
+#ifdef DEBUG
+  bool IsDeferredHandle(Object** location);
+#endif  // DEBUG
+
   OptimizingCompilerThread* optimizing_compiler_thread() {
     return &optimizing_compiler_thread_;
   }
 
   // PreInits and returns a default isolate. Needed when a new thread tries
   // to create a Locker for the first time (the lock itself is in the isolate).
   // TODO(svenpanne) This method is on death row...
   static v8::Isolate* GetDefaultIsolateForLocking();
 
   MarkingThread** marking_threads() {
@@ skipping 198 matching lines @@
   HashMap* simulator_i_cache_;
   Redirection* simulator_redirection_;
 #endif
 
 #ifdef DEBUG
   // A static array of histogram info for each type.
   HistogramInfo heap_histograms_[LAST_TYPE + 1];
   JSObject::SpillInformation js_spill_information_;
   int code_kind_statistics_[Code::NUMBER_OF_KINDS];
 
-  bool allow_compiler_thread_handle_deref_;
-  bool allow_execution_thread_handle_deref_;
+  HandleDereferenceGuard::State compiler_thread_handle_deref_state_;
+  HandleDereferenceGuard::State execution_thread_handle_deref_state_;
 #endif
 
 #ifdef ENABLE_DEBUGGER_SUPPORT
   Debugger* debugger_;
   Debug* debug_;
 #endif
   CpuProfiler* cpu_profiler_;
   HeapProfiler* heap_profiler_;
 
 #define GLOBAL_BACKING_STORE(type, name, initialvalue)                         \
@@ skipping 171 matching lines @@
 
 // Mark the native context with out of memory.
 inline void Context::mark_out_of_memory() {
   native_context()->set_out_of_memory(HEAP->true_value());
 }
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_ISOLATE_H_