Canonicalize handles for optimized compilation.

src/handles.h

 // Copyright 2011 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.
 
 #ifndef V8_HANDLES_H_
 #define V8_HANDLES_H_
 
 #include "include/v8.h"
 #include "src/base/functional.h"
 #include "src/base/macros.h"
 #include "src/checks.h"
 #include "src/globals.h"
+#include "src/zone.h"
 
 namespace v8 {
 namespace internal {
 
 // Forward declarations.
 class DeferredHandles;
 class HandleScopeImplementer;
 class Isolate;
 class Object;
 
@@ skipping 62 matching lines @@
   V8_INLINE explicit Handle(T** location = nullptr)
       : HandleBase(reinterpret_cast<Object**>(location)) {
     Object* a = nullptr;
     T* b = nullptr;
     a = b;  // Fake assignment to enforce type checks.
     USE(a);
   }
   V8_INLINE explicit Handle(T* object) : Handle(object, object->GetIsolate()) {}
   V8_INLINE Handle(T* object, Isolate* isolate) : HandleBase(object, isolate) {}
 
+  // Allocate a new handle for the object, do not canonicalize.
+  V8_INLINE static Handle<T> New(T* object, Isolate* isolate);
+
   // Constructor for handling automatic up casting.
   // Ex. Handle<JSFunction> can be passed when Handle<Object> is expected.
   template <typename S>
   V8_INLINE Handle(Handle<S> handle)
       : HandleBase(handle) {
     T* a = nullptr;
     S* b = nullptr;
     a = b;  // Fake assignment to enforce type checks.
     USE(a);
   }
@@ skipping 142 matching lines @@
 // for which the handle scope has been deleted is undefined.
 class HandleScope {
  public:
   explicit inline HandleScope(Isolate* isolate);
 
   inline ~HandleScope();
 
   // Counts the number of allocated handles.
   static int NumberOfHandles(Isolate* isolate);
 
+  // Create a new handle or lookup a canonical handle.
+  V8_INLINE static Object** GetHandle(Isolate* isolate, Object* value);
+
   // Creates a new handle with the given value.
-  template <typename T>
-  static inline T** CreateHandle(Isolate* isolate, T* value);
+  V8_INLINE static Object** CreateHandle(Isolate* isolate, Object* value);
 
   // Deallocates any extensions used by the current scope.
   static void DeleteExtensions(Isolate* isolate);
 
   static Address current_next_address(Isolate* isolate);
   static Address current_limit_address(Isolate* isolate);
   static Address current_level_address(Isolate* isolate);
 
   // Closes the HandleScope (invalidating all handles
   // created in the scope of the HandleScope) and returns
@@ skipping 28 matching lines @@
   // Extend the handle scope making room for more handles.
   static Object** Extend(Isolate* isolate);
 
 #ifdef ENABLE_HANDLE_ZAPPING
   // Zaps the handles in the half-open interval [start, end).
   static void ZapRange(Object** start, Object** end);
 #endif
 
   friend class v8::HandleScope;
   friend class DeferredHandles;
+  friend class DeferredHandleScope;
   friend class HandleScopeImplementer;
   friend class Isolate;
 };
 
 
+// Forward declarations for CanonicalHandleScope.
+template <typename V>
+class IdentityMap;
+class RootIndexMap;
+
+
+// A CanonicalHandleScope does not open a new HandleScope. It changes the
+// existing HandleScope so that Handles created within are canonicalized.
+// This does not apply to nested inner HandleScopes unless a nested
+// CanonicalHandleScope is introduced. Handles are only canonicalized within
+// the same CanonicalHandleScope, but not across nested ones.
+class CanonicalHandleScope final {
+ public:
+  explicit CanonicalHandleScope(Isolate* isolate);
+  ~CanonicalHandleScope();
+
+ private:
+  Object** Lookup(Object* object);
+
+  Isolate* isolate_;
+  Zone zone_;
+  RootIndexMap* root_index_map_;
+  IdentityMap<Object**>* identity_map_;
+  // Ordinary nested handle scopes within the current one are not canonical.
+  int canonical_level_;
+  // We may have nested canonical scopes. Handles are canonical within each one.
+  CanonicalHandleScope* prev_canonical_scope_;
+
+  friend class HandleScope;
+};
+
+
 class DeferredHandleScope final {
  public:
   explicit DeferredHandleScope(Isolate* isolate);
   // The DeferredHandles object returned stores the Handles created
   // since the creation of this DeferredHandleScope.  The Handles are
   // alive as long as the DeferredHandles object is alive.
   DeferredHandles* Detach();
   ~DeferredHandleScope();
 
  private:
@@ skipping 15 matching lines @@
 class SealHandleScope final {
  public:
 #ifndef DEBUG
   explicit SealHandleScope(Isolate* isolate) {}
   ~SealHandleScope() {}
 #else
   explicit inline SealHandleScope(Isolate* isolate);
   inline ~SealHandleScope();
  private:
   Isolate* isolate_;
-  Object** limit_;
-  int level_;
+  Object** prev_limit_;
+  int prev_sealed_level_;
 #endif
 };
 
 
 struct HandleScopeData final {
   Object** next;
   Object** limit;
   int level;
+  int sealed_level;
+  CanonicalHandleScope* canonical_scope;
 
   void Initialize() {
     next = limit = NULL;
-    level = 0;
+    sealed_level = level = 0;
+    canonical_scope = NULL;
   }
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_HANDLES_H_