Begin to handlify the stub cache.

src/stub-cache.cc

Index: src/stub-cache.cc
diff --git a/src/stub-cache.cc b/src/stub-cache.cc
index c06a11dd03e91cce1e040426d28fbae5b711b38c..e6222c9740c605c26ec395cba1c036cfac12c948 100644
--- a/src/stub-cache.cc
+++ b/src/stub-cache.cc
@@ -109,8 +109,31 @@ Code* StubCache::Set(String* name, Map* map, Code* code) {
 }
 
 
-MaybeObject* StubCache::ComputeLoadNonexistent(String* name,
-                                               JSObject* receiver) {
+// This static helper should be removed if
+// LoadStubCompiler::CompileLoadNonexistent is handlified.
+static Handle<Code> CompileLoadNonexistent(Isolate* isolate,
+                                           LoadStubCompiler* compiler,
+                                           Handle<String> cache_name,
+                                           Handle<JSObject> receiver,
+                                           Handle<JSObject> last) {
+  CALL_HEAP_FUNCTION(

[Kevin Millikin (Chromium), 2011/09/29 09:21:32]

This is the interface between handle code and raw pointer code, that will
perform GC and retry on allocation failures.  The handle code can tolerate the
GC.

+      isolate,
+      compiler->CompileLoadNonexistent(*cache_name, *receiver, *last),
+      Code);
+}
+
+
+static void UpdateMapCodeCache(Isolate* isolate,
+                               Handle<JSObject> receiver,
+                               Handle<String> cache_name,
+                               Handle<Code> code) {
+  CALL_HEAP_FUNCTION_VOID(isolate,
+                          receiver->UpdateMapCodeCache(*cache_name, *code));
+}
+
+
+Handle<Code> StubCache::ComputeLoadNonexistent(Handle<String> name,
+                                               Handle<JSObject> receiver) {
   ASSERT(receiver->IsGlobalObject() || receiver->HasFastProperties());
   // If no global objects are present in the prototype chain, the load
   // nonexistent IC stub can be shared for all names for a given map
@@ -118,173 +141,228 @@ MaybeObject* StubCache::ComputeLoadNonexistent(String* name,
   // there are global objects involved, we need to check global
   // property cells in the stub and therefore the stub will be
   // specific to the name.
-  String* cache_name = heap()->empty_string();
+  Handle<String> cache_name = factory()->empty_string();
   if (receiver->IsGlobalObject()) cache_name = name;
-  JSObject* last = receiver;
+
+  // TODO(kmillikin): If we were willing to write
+  //   *last.location() = JSObject::cast(last->GetPrototype());
+  // we could avoid the linear space usage.

[Kevin Millikin (Chromium), 2011/09/29 09:21:32]

We never do this trick because we're paranoid about handle cell ownership and
mutating them behind the scenes (it would be really bad if we mutated a
'spoofed' handle like one of the heap roots).

+  Handle<JSObject> last = receiver;
   while (last->GetPrototype() != heap()->null_value()) {
-    last = JSObject::cast(last->GetPrototype());
+    last = Handle<JSObject>(JSObject::cast(last->GetPrototype()));
     if (last->IsGlobalObject()) cache_name = name;
   }
   // Compile the stub that is either shared for all names or
   // name specific if there are global objects involved.
   Code::Flags flags =
       Code::ComputeMonomorphicFlags(Code::LOAD_IC, NONEXISTENT);
-  Object* code = receiver->map()->FindInCodeCache(cache_name, flags);
-  if (code->IsUndefined()) {
-    LoadStubCompiler compiler;

[Kevin Millikin (Chromium), 2011/09/29 09:21:32]

Though this implicitly introduces a handle scope, all the code uses raw pointers
and so can't tolerate a GC.  So we have to check for allocation failures
explicitly at every level.

We've had a lot of bugs where we get a GC several layers deep (e.g., in the
assembler), which cuts intercepts the allocation failure that the outer layers
needed to safely unwind.

-    { MaybeObject* maybe_code =
-          compiler.CompileLoadNonexistent(cache_name, receiver, last);
-      if (!maybe_code->ToObject(&code)) return maybe_code;
-    }
-    PROFILE(isolate_,
-            CodeCreateEvent(Logger::LOAD_IC_TAG, Code::cast(code), cache_name));
-    GDBJIT(AddCode(GDBJITInterface::LOAD_IC, cache_name, Code::cast(code)));
-    Object* result;
-    { MaybeObject* maybe_result =
-          receiver->UpdateMapCodeCache(cache_name, Code::cast(code));
-      if (!maybe_result->ToObject(&result)) return maybe_result;
-    }
-  }
+  Handle<Object> probe(receiver->map()->FindInCodeCache(*cache_name, flags));
+  if (probe->IsCode()) return Handle<Code>::cast(probe);
+
+  LoadStubCompiler compiler(isolate_);
+  Handle<Code> code =
+      CompileLoadNonexistent(isolate_, &compiler, cache_name, receiver, last);
+  PROFILE(isolate_, CodeCreateEvent(Logger::LOAD_IC_TAG, *code, *cache_name));
+  GDBJIT(AddCode(GDBJITInterface::LOAD_IC, *cache_name, *code));
+  UpdateMapCodeCache(isolate_, receiver, cache_name, code);
   return code;
 }
 
 
-MaybeObject* StubCache::ComputeLoadField(String* name,
-                                         JSObject* receiver,
-                                         JSObject* holder,
+// This static helper should be removed if
+// LoadStubCompiler::CompileLoadField is handlified.
+static Handle<Code> CompileLoadField(Isolate* isolate,
+                                     LoadStubCompiler* compiler,
+                                     Handle<JSObject> receiver,
+                                     Handle<JSObject> holder,
+                                     int field_index,
+                                     Handle<String> name) {
+  CALL_HEAP_FUNCTION(
+      isolate,
+      compiler->CompileLoadField(*receiver, *holder, field_index, *name),
+      Code);
+}
+
+
+Handle<Code> StubCache::ComputeLoadField(Handle<String> name,
+                                         Handle<JSObject> receiver,
+                                         Handle<JSObject> holder,
                                          int field_index) {
-  ASSERT(IC::GetCodeCacheForObject(receiver, holder) == OWN_MAP);
+  ASSERT(IC::GetCodeCacheForObject(*receiver, *holder) == OWN_MAP);
   Code::Flags flags = Code::ComputeMonomorphicFlags(Code::LOAD_IC, FIELD);
-  Object* code = receiver->map()->FindInCodeCache(name, flags);
-  if (code->IsUndefined()) {
-    LoadStubCompiler compiler;
-    { MaybeObject* maybe_code =
-          compiler.CompileLoadField(receiver, holder, field_index, name);
-      if (!maybe_code->ToObject(&code)) return maybe_code;
-    }
-    PROFILE(isolate_,
-            CodeCreateEvent(Logger::LOAD_IC_TAG, Code::cast(code), name));
-    GDBJIT(AddCode(GDBJITInterface::LOAD_IC, name, Code::cast(code)));
-    Object* result;
-    { MaybeObject* maybe_result =
-          receiver->UpdateMapCodeCache(name, Code::cast(code));
-      if (!maybe_result->ToObject(&result)) return maybe_result;
-    }
-  }
+  Handle<Object> probe(receiver->map()->FindInCodeCache(*name, flags));
+  if (probe->IsCode()) return Handle<Code>::cast(probe);
+
+  LoadStubCompiler compiler(isolate_);
+  Handle<Code> code = CompileLoadField(isolate_,
+                                       &compiler,
+                                       receiver,
+                                       holder,
+                                       field_index,
+                                       name);
+  PROFILE(isolate_, CodeCreateEvent(Logger::LOAD_IC_TAG, *code, *name));
+  GDBJIT(AddCode(GDBJITInterface::LOAD_IC, *name, *code));
+  UpdateMapCodeCache(isolate_, receiver, name, code);
   return code;
 }
 
 
-MaybeObject* StubCache::ComputeLoadCallback(String* name,
-                                            JSObject* receiver,
-                                            JSObject* holder,
-                                            AccessorInfo* callback) {
+// This static helper should be removed if
+// LoadStubCompiler::CompileLoadCallback is handlified.
+static Handle<Code> CompileLoadCallback(Isolate* isolate,
+                                        LoadStubCompiler* compiler,
+                                        Handle<String> name,
+                                        Handle<JSObject> receiver,
+                                        Handle<JSObject> holder,
+                                        Handle<AccessorInfo> callback) {
+  CALL_HEAP_FUNCTION(
+      isolate,
+      compiler->CompileLoadCallback(*name, *receiver, *holder, *callback),
+      Code);
+}
+
+
+Handle<Code> StubCache::ComputeLoadCallback(Handle<String> name,
+                                            Handle<JSObject> receiver,
+                                            Handle<JSObject> holder,
+                                            Handle<AccessorInfo> callback) {
   ASSERT(v8::ToCData<Address>(callback->getter()) != 0);
-  ASSERT(IC::GetCodeCacheForObject(receiver, holder) == OWN_MAP);
+  ASSERT(IC::GetCodeCacheForObject(*receiver, *holder) == OWN_MAP);
   Code::Flags flags = Code::ComputeMonomorphicFlags(Code::LOAD_IC, CALLBACKS);
-  Object* code = receiver->map()->FindInCodeCache(name, flags);
-  if (code->IsUndefined()) {
-    LoadStubCompiler compiler;
-    { MaybeObject* maybe_code =
-          compiler.CompileLoadCallback(name, receiver, holder, callback);
-      if (!maybe_code->ToObject(&code)) return maybe_code;
-    }
-    PROFILE(isolate_,
-            CodeCreateEvent(Logger::LOAD_IC_TAG, Code::cast(code), name));
-    GDBJIT(AddCode(GDBJITInterface::LOAD_IC, name, Code::cast(code)));
-    Object* result;
-    { MaybeObject* maybe_result =
-          receiver->UpdateMapCodeCache(name, Code::cast(code));
-      if (!maybe_result->ToObject(&result)) return maybe_result;
-    }
-  }
+  Handle<Object> probe(receiver->map()->FindInCodeCache(*name, flags));
+  if (probe->IsCode()) return Handle<Code>::cast(probe);
+
+  LoadStubCompiler compiler(isolate_);
+  Handle<Code> code = CompileLoadCallback(isolate_,
+                                          &compiler,
+                                          name,
+                                          receiver,
+                                          holder,
+                                          callback);
+  PROFILE(isolate_, CodeCreateEvent(Logger::LOAD_IC_TAG, *code, *name));
+  GDBJIT(AddCode(GDBJITInterface::LOAD_IC, *name, *code));
+  UpdateMapCodeCache(isolate_, receiver, name, code);
   return code;
 }
 
 
-MaybeObject* StubCache::ComputeLoadConstant(String* name,
-                                            JSObject* receiver,
-                                            JSObject* holder,
-                                            Object* value) {
-  ASSERT(IC::GetCodeCacheForObject(receiver, holder) == OWN_MAP);
+// This static helper should be removed if
+// LoadStubCompiler::CompileLoadConstant is handlified.
+static Handle<Code> CompileLoadConstant(Isolate* isolate,
+                                        LoadStubCompiler* compiler,
+                                        Handle<JSObject> receiver,
+                                        Handle<JSObject> holder,
+                                        Handle<Object> value,
+                                        Handle<String> name) {
+  CALL_HEAP_FUNCTION(
+      isolate,
+      compiler->CompileLoadConstant(*receiver, *holder, *value, *name),
+      Code);
+}
+
+
+Handle<Code> StubCache::ComputeLoadConstant(Handle<String> name,
+                                            Handle<JSObject> receiver,
+                                            Handle<JSObject> holder,
+                                            Handle<Object> value) {
+  ASSERT(IC::GetCodeCacheForObject(*receiver, *holder) == OWN_MAP);
   Code::Flags flags =
       Code::ComputeMonomorphicFlags(Code::LOAD_IC, CONSTANT_FUNCTION);
-  Object* code = receiver->map()->FindInCodeCache(name, flags);
-  if (code->IsUndefined()) {
-    LoadStubCompiler compiler;
-    { MaybeObject* maybe_code =
-          compiler.CompileLoadConstant(receiver, holder, value, name);
-      if (!maybe_code->ToObject(&code)) return maybe_code;
-    }
-    PROFILE(isolate_,
-            CodeCreateEvent(Logger::LOAD_IC_TAG, Code::cast(code), name));
-    GDBJIT(AddCode(GDBJITInterface::LOAD_IC, name, Code::cast(code)));
-    Object* result;
-    { MaybeObject* maybe_result =
-          receiver->UpdateMapCodeCache(name, Code::cast(code));
-      if (!maybe_result->ToObject(&result)) return maybe_result;
-    }
-  }
+  Handle<Object> probe(receiver->map()->FindInCodeCache(*name, flags));
+  if (probe->IsCode()) return Handle<Code>::cast(probe);
+
+  LoadStubCompiler compiler(isolate_);
+  Handle<Code> code = CompileLoadConstant(isolate_,
+                                          &compiler,
+                                          receiver,
+                                          holder,
+                                          value,
+                                          name);
+  PROFILE(isolate_, CodeCreateEvent(Logger::LOAD_IC_TAG, *code, *name));
+  GDBJIT(AddCode(GDBJITInterface::LOAD_IC, *name, *code));
+  UpdateMapCodeCache(isolate_, receiver, name, code);
   return code;
 }
 
 
-MaybeObject* StubCache::ComputeLoadInterceptor(String* name,
-                                               JSObject* receiver,
-                                               JSObject* holder) {
-  ASSERT(IC::GetCodeCacheForObject(receiver, holder) == OWN_MAP);
+// This static helper should be removed if
+// LoadStubCompiler::CompileLoadInterceptor is handlified.
+static Handle<Code> CompileLoadInterceptor(Isolate* isolate,
+                                           LoadStubCompiler* compiler,
+                                           Handle<JSObject> receiver,
+                                           Handle<JSObject> holder,
+                                           Handle<String> name) {
+  CALL_HEAP_FUNCTION(
+      isolate,
+      compiler->CompileLoadInterceptor(*receiver, *holder, *name),
+      Code);
+}
+
+
+Handle<Code> StubCache::ComputeLoadInterceptor(Handle<String> name,
+                                               Handle<JSObject> receiver,
+                                               Handle<JSObject> holder) {
+  ASSERT(IC::GetCodeCacheForObject(*receiver, *holder) == OWN_MAP);
   Code::Flags flags = Code::ComputeMonomorphicFlags(Code::LOAD_IC, INTERCEPTOR);
-  Object* code = receiver->map()->FindInCodeCache(name, flags);
-  if (code->IsUndefined()) {
-    LoadStubCompiler compiler;
-    { MaybeObject* maybe_code =
-          compiler.CompileLoadInterceptor(receiver, holder, name);
-      if (!maybe_code->ToObject(&code)) return maybe_code;
-    }
-    PROFILE(isolate_,
-            CodeCreateEvent(Logger::LOAD_IC_TAG, Code::cast(code), name));
-    GDBJIT(AddCode(GDBJITInterface::LOAD_IC, name, Code::cast(code)));
-    Object* result;
-    { MaybeObject* maybe_result =
-          receiver->UpdateMapCodeCache(name, Code::cast(code));
-      if (!maybe_result->ToObject(&result)) return maybe_result;
-    }
-  }
+  Handle<Object> probe(receiver->map()->FindInCodeCache(*name, flags));
+  if (probe->IsCode()) return Handle<Code>::cast(probe);
+
+  LoadStubCompiler compiler(isolate_);
+  Handle<Code> code = CompileLoadInterceptor(isolate_,
+                                             &compiler,
+                                             receiver,
+                                             holder,
+                                             name);
+  PROFILE(isolate_, CodeCreateEvent(Logger::LOAD_IC_TAG, *code, *name));
+  GDBJIT(AddCode(GDBJITInterface::LOAD_IC, *name, *code));
+  UpdateMapCodeCache(isolate_, receiver, name, code);
   return code;
 }
 
 
-MaybeObject* StubCache::ComputeLoadNormal() {
-  return isolate_->builtins()->builtin(Builtins::kLoadIC_Normal);
+Handle<Code> StubCache::ComputeLoadNormal() {
+  return isolate_->builtins()->LoadIC_Normal();
 }
 
 
-MaybeObject* StubCache::ComputeLoadGlobal(String* name,
-                                          JSObject* receiver,
-                                          GlobalObject* holder,
-                                          JSGlobalPropertyCell* cell,
+// This static helper should be removed if
+// LoadStubCompiler::CompileLoadGlobal is handlified.
+static Handle<Code> CompileLoadGlobal(Isolate* isolate,
+                                      LoadStubCompiler* compiler,
+                                      Handle<JSObject> receiver,
+                                      Handle<GlobalObject> holder,
+                                      Handle<JSGlobalPropertyCell> cell,
+                                      Handle<String> name,
+                                      bool is_dont_delete) {
+  CALL_HEAP_FUNCTION(
+      isolate,
+      compiler->CompileLoadGlobal(*receiver, *holder, *cell, *name,
+                                  is_dont_delete),
+      Code);
+}
+
+
+Handle<Code> StubCache::ComputeLoadGlobal(Handle<String> name,
+                                          Handle<JSObject> receiver,
+                                          Handle<GlobalObject> holder,
+                                          Handle<JSGlobalPropertyCell> cell,
                                           bool is_dont_delete) {
-  ASSERT(IC::GetCodeCacheForObject(receiver, holder) == OWN_MAP);
+  ASSERT(IC::GetCodeCacheForObject(*receiver, *holder) == OWN_MAP);
   Code::Flags flags = Code::ComputeMonomorphicFlags(Code::LOAD_IC, NORMAL);
-  Object* code = receiver->map()->FindInCodeCache(name, flags);
-  if (code->IsUndefined()) {
-    LoadStubCompiler compiler;
-    { MaybeObject* maybe_code = compiler.CompileLoadGlobal(receiver,
-                                                           holder,
-                                                           cell,
-                                                           name,
-                                                           is_dont_delete);
-      if (!maybe_code->ToObject(&code)) return maybe_code;
-    }
-    PROFILE(isolate_,
-            CodeCreateEvent(Logger::LOAD_IC_TAG, Code::cast(code), name));
-    GDBJIT(AddCode(GDBJITInterface::LOAD_IC, name, Code::cast(code)));
-    Object* result;
-    { MaybeObject* maybe_result =
-          receiver->UpdateMapCodeCache(name, Code::cast(code));
-      if (!maybe_result->ToObject(&result)) return maybe_result;
-    }
-  }
+  Handle<Object> probe(receiver->map()->FindInCodeCache(*name, flags));
+  if (probe->IsCode()) return Handle<Code>::cast(probe);
+
+  LoadStubCompiler compiler(isolate_);
+  Handle<Code> code = CompileLoadGlobal(isolate_,
+                                        &compiler,
+                                        receiver,
+                                        holder,
+                                        cell,
+                                        name,
+                                        is_dont_delete);
+  PROFILE(isolate_, CodeCreateEvent(Logger::LOAD_IC_TAG, *code, *name));
+  GDBJIT(AddCode(GDBJITInterface::LOAD_IC, *name, *code));
+  UpdateMapCodeCache(isolate_, receiver, name, code);
   return code;
 }
 
@@ -297,7 +375,8 @@ MaybeObject* StubCache::ComputeKeyedLoadField(String* name,
   Code::Flags flags = Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC, FIELD);
   Object* code = receiver->map()->FindInCodeCache(name, flags);
   if (code->IsUndefined()) {
-    KeyedLoadStubCompiler compiler;
+    HandleScope scope(isolate());
+    KeyedLoadStubCompiler compiler(isolate());
     { MaybeObject* maybe_code =
           compiler.CompileLoadField(name, receiver, holder, field_index);
       if (!maybe_code->ToObject(&code)) return maybe_code;
@@ -324,7 +403,8 @@ MaybeObject* StubCache::ComputeKeyedLoadConstant(String* name,
       Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC, CONSTANT_FUNCTION);
   Object* code = receiver->map()->FindInCodeCache(name, flags);
   if (code->IsUndefined()) {
-    KeyedLoadStubCompiler compiler;
+    HandleScope scope(isolate());
+    KeyedLoadStubCompiler compiler(isolate());
     { MaybeObject* maybe_code =
           compiler.CompileLoadConstant(name, receiver, holder, value);
       if (!maybe_code->ToObject(&code)) return maybe_code;
@@ -350,7 +430,8 @@ MaybeObject* StubCache::ComputeKeyedLoadInterceptor(String* name,
       Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC, INTERCEPTOR);
   Object* code = receiver->map()->FindInCodeCache(name, flags);
   if (code->IsUndefined()) {
-    KeyedLoadStubCompiler compiler;
+    HandleScope scope(isolate());
+    KeyedLoadStubCompiler compiler(isolate());
     { MaybeObject* maybe_code =
           compiler.CompileLoadInterceptor(receiver, holder, name);
       if (!maybe_code->ToObject(&code)) return maybe_code;
@@ -377,7 +458,8 @@ MaybeObject* StubCache::ComputeKeyedLoadCallback(String* name,
       Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC, CALLBACKS);
   Object* code = receiver->map()->FindInCodeCache(name, flags);
   if (code->IsUndefined()) {
-    KeyedLoadStubCompiler compiler;
+    HandleScope scope(isolate());
+    KeyedLoadStubCompiler compiler(isolate());
     { MaybeObject* maybe_code =
           compiler.CompileLoadCallback(name, receiver, holder, callback);
       if (!maybe_code->ToObject(&code)) return maybe_code;
@@ -403,7 +485,8 @@ MaybeObject* StubCache::ComputeKeyedLoadArrayLength(String* name,
   ASSERT(receiver->IsJSObject());
   Object* code = receiver->map()->FindInCodeCache(name, flags);
   if (code->IsUndefined()) {
-    KeyedLoadStubCompiler compiler;
+    HandleScope scope(isolate());
+    KeyedLoadStubCompiler compiler(isolate());
     { MaybeObject* maybe_code = compiler.CompileLoadArrayLength(name);
       if (!maybe_code->ToObject(&code)) return maybe_code;
     }
@@ -427,7 +510,8 @@ MaybeObject* StubCache::ComputeKeyedLoadStringLength(String* name,
   Map* map = receiver->map();
   Object* code = map->FindInCodeCache(name, flags);
   if (code->IsUndefined()) {
-    KeyedLoadStubCompiler compiler;
+    HandleScope scope(isolate());
+    KeyedLoadStubCompiler compiler(isolate());
     { MaybeObject* maybe_code = compiler.CompileLoadStringLength(name);
       if (!maybe_code->ToObject(&code)) return maybe_code;
     }
@@ -450,7 +534,8 @@ MaybeObject* StubCache::ComputeKeyedLoadFunctionPrototype(
       Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC, CALLBACKS);
   Object* code = receiver->map()->FindInCodeCache(name, flags);
   if (code->IsUndefined()) {
-    KeyedLoadStubCompiler compiler;
+    HandleScope scope(isolate());
+    KeyedLoadStubCompiler compiler(isolate());
     { MaybeObject* maybe_code = compiler.CompileLoadFunctionPrototype(name);
       if (!maybe_code->ToObject(&code)) return maybe_code;
     }
@@ -477,7 +562,8 @@ MaybeObject* StubCache::ComputeStoreField(String* name,
       Code::STORE_IC, type, strict_mode);
   Object* code = receiver->map()->FindInCodeCache(name, flags);
   if (code->IsUndefined()) {
-    StoreStubCompiler compiler(strict_mode);
+    HandleScope scope(isolate());
+    StoreStubCompiler compiler(isolate(), strict_mode);
     { MaybeObject* maybe_code =
           compiler.CompileStoreField(receiver, field_index, transition, name);
       if (!maybe_code->ToObject(&code)) return maybe_code;
@@ -514,10 +600,12 @@ MaybeObject* StubCache::ComputeKeyedLoadOrStoreElement(
   MaybeObject* maybe_new_code = NULL;
   Map* receiver_map = receiver->map();
   if (is_store) {
-    KeyedStoreStubCompiler compiler(strict_mode);
+    HandleScope scope(isolate());
+    KeyedStoreStubCompiler compiler(isolate(), strict_mode);
     maybe_new_code = compiler.CompileStoreElement(receiver_map);
   } else {
-    KeyedLoadStubCompiler compiler;
+    HandleScope scope(isolate());
+    KeyedLoadStubCompiler compiler(isolate());
     maybe_new_code = compiler.CompileLoadElement(receiver_map);
   }
   Code* code;
@@ -556,7 +644,8 @@ MaybeObject* StubCache::ComputeStoreGlobal(String* name,
       Code::STORE_IC, NORMAL, strict_mode);
   Object* code = receiver->map()->FindInCodeCache(name, flags);
   if (code->IsUndefined()) {
-    StoreStubCompiler compiler(strict_mode);
+    HandleScope scope(isolate());
+    StoreStubCompiler compiler(isolate(), strict_mode);
     { MaybeObject* maybe_code =
           compiler.CompileStoreGlobal(receiver, cell, name);
       if (!maybe_code->ToObject(&code)) return maybe_code;
@@ -584,7 +673,8 @@ MaybeObject* StubCache::ComputeStoreCallback(
       Code::STORE_IC, CALLBACKS, strict_mode);
   Object* code = receiver->map()->FindInCodeCache(name, flags);
   if (code->IsUndefined()) {
-    StoreStubCompiler compiler(strict_mode);
+    HandleScope scope(isolate());
+    StoreStubCompiler compiler(isolate(), strict_mode);
     { MaybeObject* maybe_code =
           compiler.CompileStoreCallback(receiver, callback, name);
       if (!maybe_code->ToObject(&code)) return maybe_code;
@@ -610,7 +700,8 @@ MaybeObject* StubCache::ComputeStoreInterceptor(
       Code::STORE_IC, INTERCEPTOR, strict_mode);
   Object* code = receiver->map()->FindInCodeCache(name, flags);
   if (code->IsUndefined()) {
-    StoreStubCompiler compiler(strict_mode);
+    HandleScope scope(isolate());
+    StoreStubCompiler compiler(isolate(), strict_mode);
     { MaybeObject* maybe_code =
           compiler.CompileStoreInterceptor(receiver, name);
       if (!maybe_code->ToObject(&code)) return maybe_code;
@@ -638,7 +729,8 @@ MaybeObject* StubCache::ComputeKeyedStoreField(String* name,
       Code::KEYED_STORE_IC, type, strict_mode);
   Object* code = receiver->map()->FindInCodeCache(name, flags);
   if (code->IsUndefined()) {
-    KeyedStoreStubCompiler compiler(strict_mode);
+    HandleScope scope(isolate());
+    KeyedStoreStubCompiler compiler(isolate(), strict_mode);
     { MaybeObject* maybe_code =
           compiler.CompileStoreField(receiver, field_index, transition, name);
       if (!maybe_code->ToObject(&code)) return maybe_code;
@@ -694,7 +786,9 @@ MaybeObject* StubCache::ComputeCallConstant(int argc,
     // caches.
     if (!function->is_compiled()) return Failure::InternalError();
     // Compile the stub - only create stubs for fully compiled functions.
-    CallStubCompiler compiler(argc, kind, extra_ic_state, cache_holder);
+    HandleScope scope(isolate());
+    CallStubCompiler compiler(isolate(), argc, kind, extra_ic_state,
+                              cache_holder);
     { MaybeObject* maybe_code =
           compiler.CompileCallConstant(object, holder, function, name, check);
       if (!maybe_code->ToObject(&code)) return maybe_code;
@@ -741,7 +835,9 @@ MaybeObject* StubCache::ComputeCallField(int argc,
                                                     argc);
   Object* code = map_holder->map()->FindInCodeCache(name, flags);
   if (code->IsUndefined()) {
-    CallStubCompiler compiler(argc, kind, extra_ic_state, cache_holder);
+    HandleScope scope(isolate());
+    CallStubCompiler compiler(isolate(), argc, kind, extra_ic_state,
+                              cache_holder);
     { MaybeObject* maybe_code =
           compiler.CompileCallField(JSObject::cast(object),
                                     holder,
@@ -790,7 +886,9 @@ MaybeObject* StubCache::ComputeCallInterceptor(
                                                     argc);
   Object* code = map_holder->map()->FindInCodeCache(name, flags);
   if (code->IsUndefined()) {
-    CallStubCompiler compiler(argc, kind, extra_ic_state, cache_holder);
+    HandleScope scope(isolate());
+    CallStubCompiler compiler(isolate(), argc, kind, extra_ic_state,
+                              cache_holder);
     { MaybeObject* maybe_code =
           compiler.CompileCallInterceptor(JSObject::cast(object), holder, name);
       if (!maybe_code->ToObject(&code)) return maybe_code;
@@ -846,7 +944,9 @@ MaybeObject* StubCache::ComputeCallGlobal(int argc,
     // internal error which will make sure we do not update any
     // caches.
     if (!function->is_compiled()) return Failure::InternalError();
-    CallStubCompiler compiler(argc, kind, extra_ic_state, cache_holder);
+    HandleScope scope(isolate());
+    CallStubCompiler compiler(isolate(), argc, kind, extra_ic_state,
+                              cache_holder);
     { MaybeObject* maybe_code =
           compiler.CompileCallGlobal(receiver, holder, cell, function, name);
       if (!maybe_code->ToObject(&code)) return maybe_code;
@@ -949,7 +1049,8 @@ MaybeObject* StubCache::ComputeCallInitialize(int argc,
     if (!maybe_probe->ToObject(&probe)) return maybe_probe;
   }
   if (!probe->IsUndefined()) return probe;
-  StubCompiler compiler;
+  HandleScope scope(isolate());
+  StubCompiler compiler(isolate());
   return FillCache(isolate_, compiler.CompileCallInitialize(flags));
 }
 
@@ -984,7 +1085,8 @@ MaybeObject* StubCache::ComputeCallPreMonomorphic(
     if (!maybe_probe->ToObject(&probe)) return maybe_probe;
   }
   if (!probe->IsUndefined()) return probe;
-  StubCompiler compiler;
+  HandleScope scope(isolate());
+  StubCompiler compiler(isolate());
   return FillCache(isolate_, compiler.CompileCallPreMonomorphic(flags));
 }
 
@@ -1002,7 +1104,8 @@ MaybeObject* StubCache::ComputeCallNormal(int argc,
     if (!maybe_probe->ToObject(&probe)) return maybe_probe;
   }
   if (!probe->IsUndefined()) return probe;
-  StubCompiler compiler;
+  HandleScope scope(isolate());
+  StubCompiler compiler(isolate());
   return FillCache(isolate_, compiler.CompileCallNormal(flags));
 }
 
@@ -1019,7 +1122,8 @@ MaybeObject* StubCache::ComputeCallArguments(int argc, Code::Kind kind) {
     if (!maybe_probe->ToObject(&probe)) return maybe_probe;
   }
   if (!probe->IsUndefined()) return probe;
-  StubCompiler compiler;
+  HandleScope scope(isolate());
+  StubCompiler compiler(isolate());
   return FillCache(isolate_, compiler.CompileCallArguments(flags));
 }
 
@@ -1038,7 +1142,8 @@ MaybeObject* StubCache::ComputeCallMegamorphic(
     if (!maybe_probe->ToObject(&probe)) return maybe_probe;
   }
   if (!probe->IsUndefined()) return probe;
-  StubCompiler compiler;
+  HandleScope scope(isolate());
+  StubCompiler compiler(isolate());
   return FillCache(isolate_, compiler.CompileCallMegamorphic(flags));
 }
 
@@ -1059,7 +1164,8 @@ MaybeObject* StubCache::ComputeCallMiss(int argc,
     if (!maybe_probe->ToObject(&probe)) return maybe_probe;
   }
   if (!probe->IsUndefined()) return probe;
-  StubCompiler compiler;
+  HandleScope scope(isolate());
+  StubCompiler compiler(isolate());
   return FillCache(isolate_, compiler.CompileCallMiss(flags));
 }
 
@@ -1080,7 +1186,8 @@ MaybeObject* StubCache::ComputeCallDebugBreak(
     if (!maybe_probe->ToObject(&probe)) return maybe_probe;
   }
   if (!probe->IsUndefined()) return probe;
-  StubCompiler compiler;
+  HandleScope scope(isolate());
+  StubCompiler compiler(isolate());
   return FillCache(isolate_, compiler.CompileCallDebugBreak(flags));
 }
 
@@ -1100,7 +1207,8 @@ MaybeObject* StubCache::ComputeCallDebugPrepareStepIn(
     if (!maybe_probe->ToObject(&probe)) return maybe_probe;
   }
   if (!probe->IsUndefined()) return probe;
-  StubCompiler compiler;
+  HandleScope scope(isolate());
+  StubCompiler compiler(isolate());
   return FillCache(isolate_, compiler.CompileCallDebugPrepareStepIn(flags));
 }
 #endif
@@ -1692,11 +1800,13 @@ void KeyedStoreStubCompiler::GenerateStoreDictionaryElement(
 }
 
 
-CallStubCompiler::CallStubCompiler(int argc,
+CallStubCompiler::CallStubCompiler(Isolate* isolate,
+                                   int argc,
                                    Code::Kind kind,
                                    Code::ExtraICState extra_ic_state,
                                    InlineCacheHolderFlag cache_holder)
-    : arguments_(argc),
+    : StubCompiler(isolate),
+      arguments_(argc),
       kind_(kind),
       extra_ic_state_(extra_ic_state),
       cache_holder_(cache_holder) {