Disallow dereferencing deferred handles when generating optimized code.

src/handles.h

 // Copyright 2011 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 55 matching lines @@
   // Check if this handle refers to the exact same object as the other handle.
   INLINE(bool is_identical_to(const Handle<T> other) const);
 
   // Provides the C++ dereference operator.
   INLINE(T* operator*() const);
 
   // Returns the address to where the raw pointer is stored.
   INLINE(T** location() const);
 
   template <class S> static Handle<T> cast(Handle<S> that) {
-    T::cast(*that);
-    return Handle<T>(reinterpret_cast<T**>(that.location()));
+    T::cast(*reinterpret_cast<T**>(that.location_));
+    return Handle<T>(reinterpret_cast<T**>(that.location_));
   }
 
   static Handle<T> null() { return Handle<T>(); }
   bool is_null() const { return location_ == NULL; }
 
   // Closes the given scope, but lets this handle escape. See
   // implementation in api.h.
   inline Handle<T> EscapeFrom(v8::HandleScope* scope);
 
+#ifdef DEBUG
+  bool IsDereferenceAllowed(bool allow_deferred) const;
+#endif  // DEBUG
+
  private:
   T** location_;
 
   // Handles of different classes are allowed to access each other's location_.
   template<class S> friend class Handle;
 };
 
 
 // Convenience wrapper.
 template<class T>
@@ skipping 237 matching lines @@
  private:
   Isolate* isolate_;
   int level_;
   bool active_;
 #endif
 };
 
 
 class HandleDereferenceGuard BASE_EMBEDDED {
  public:
-  enum State { ALLOW, DISALLOW };
+  enum State { ALLOW, DISALLOW, DISALLOW_DEFERRED };
 #ifndef DEBUG
   HandleDereferenceGuard(Isolate* isolate, State state) { }
   ~HandleDereferenceGuard() { }
 #else
   inline HandleDereferenceGuard(Isolate* isolate,  State state);
   inline ~HandleDereferenceGuard();
  private:
   Isolate* isolate_;
-  bool old_state_;
+  State old_state_;
 #endif
 };
 
+#ifdef DEBUG
+#define ALLOW_HANDLE_DEREF(why_this_is_safe)                                   \
+  HandleDereferenceGuard allow(Isolate::Current(),                             \

[Sven Panne, 2013/04/23 06:42:13]

Please do *not* introduce any new Isolate::Current() calls, this function is
really on death row. Adding another parameter to the macro is probably the
easiest way for this, the right Isolate is probably easily available at all call
sites, anyway.

+                               HandleDereferenceGuard::ALLOW);
+#else
+#define ALLOW_HANDLE_DEREF(why_this_is_safe)
+#endif  // DEBUG
+
 } }  // namespace v8::internal
 
 #endif  // V8_HANDLES_H_