Only allocate a handler compiler when necessary

src/ic.cc

 // Copyright 2012 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.
 
 #include "src/v8.h"
 
 #include "src/accessors.h"
 #include "src/api.h"
 #include "src/arguments.h"
 #include "src/codegen.h"
@@ skipping 980 matching lines @@
       Handle<JSFunction>::cast(object)->should_have_prototype() &&
       !Handle<JSFunction>::cast(object)->map()->has_non_instance_prototype()) {
     Handle<Code> stub;
     FunctionPrototypeStub function_prototype_stub(isolate());
     return function_prototype_stub.GetCode();
   }
 
   Handle<HeapType> type = receiver_type();
   Handle<JSObject> holder = lookup->GetHolder<JSObject>();
   bool receiver_is_holder = object.is_identical_to(holder);
-  NamedLoadHandlerCompiler compiler(isolate(), receiver_type(), holder,
-                                    cache_holder);
-
   // -------------- Interceptors --------------
   if (lookup->state() == LookupIterator::INTERCEPTOR) {
     DCHECK(!holder->GetNamedInterceptor()->getter()->IsUndefined());
+    NamedLoadHandlerCompiler compiler(isolate(), receiver_type(), holder,
+                                      cache_holder);
     return compiler.CompileLoadInterceptor(name);
   }
   DCHECK(lookup->state() == LookupIterator::PROPERTY);
 
   // -------------- Accessors --------------
   if (lookup->property_kind() == LookupIterator::ACCESSOR) {
     // Use simple field loads for some well-known callback properties.
     if (receiver_is_holder) {
       DCHECK(object->IsJSObject());
       Handle<JSObject> receiver = Handle<JSObject>::cast(object);
       int object_offset;
       if (Accessors::IsJSObjectFieldAccessor<HeapType>(type, name,
                                                        &object_offset)) {
         FieldIndex index =
             FieldIndex::ForInObjectOffset(object_offset, receiver->map());
         return SimpleFieldLoad(index);
       }
     }
 
     Handle<Object> accessors = lookup->GetAccessors();
     if (accessors->IsExecutableAccessorInfo()) {
       Handle<ExecutableAccessorInfo> info =
           Handle<ExecutableAccessorInfo>::cast(accessors);
       if (v8::ToCData<Address>(info->getter()) == 0) return slow_stub();
       if (!ExecutableAccessorInfo::IsCompatibleReceiverType(isolate(), info,
                                                             type)) {
         return slow_stub();
       }
       if (!holder->HasFastProperties()) return slow_stub();
+      NamedLoadHandlerCompiler compiler(isolate(), receiver_type(), holder,
+                                        cache_holder);
       return compiler.CompileLoadCallback(name, info);
     }
     if (accessors->IsAccessorPair()) {
       Handle<Object> getter(Handle<AccessorPair>::cast(accessors)->getter(),
                             isolate());
       if (!getter->IsJSFunction()) return slow_stub();
       if (!holder->HasFastProperties()) return slow_stub();
       Handle<JSFunction> function = Handle<JSFunction>::cast(getter);
       if (!object->IsJSObject() && !function->IsBuiltin() &&
           function->shared()->strict_mode() == SLOPPY) {
         // Calling sloppy non-builtins with a value as the receiver
         // requires boxing.
         return slow_stub();
       }
       CallOptimization call_optimization(function);
+      NamedLoadHandlerCompiler compiler(isolate(), receiver_type(), holder,
+                                        cache_holder);
       if (call_optimization.is_simple_api_call() &&
           call_optimization.IsCompatibleReceiver(object, holder)) {
         return compiler.CompileLoadCallback(name, call_optimization);
       }
       return compiler.CompileLoadViaGetter(name, function);
     }
     // TODO(dcarney): Handle correctly.
     DCHECK(accessors->IsDeclaredAccessorInfo());
     return slow_stub();
   }
 
   // -------------- Dictionary properties --------------
   DCHECK(lookup->property_kind() == LookupIterator::DATA);
   if (lookup->property_encoding() == LookupIterator::DICTIONARY) {
     if (kind() != Code::LOAD_IC) return slow_stub();
     if (holder->IsGlobalObject()) {
+      NamedLoadHandlerCompiler compiler(isolate(), receiver_type(), holder,
+                                        cache_holder);
       Handle<PropertyCell> cell = lookup->GetPropertyCell();
       Handle<Code> code =
           compiler.CompileLoadGlobal(cell, name, lookup->IsConfigurable());
       // TODO(verwaest): Move caching of these NORMAL stubs outside as well.
       CacheHolderFlag flag;
       Handle<Map> stub_holder_map =
           GetHandlerCacheHolder(*type, receiver_is_holder, isolate(), &flag);
       Map::UpdateCodeCache(stub_holder_map, name, code);
       return code;
     }
     // There is only one shared stub for loading normalized
     // properties. It does not traverse the prototype chain, so the
     // property must be found in the object for the stub to be
     // applicable.
     if (!receiver_is_holder) return slow_stub();
     return isolate()->builtins()->LoadIC_Normal();
   }
 
   // -------------- Fields --------------
   DCHECK(lookup->property_encoding() == LookupIterator::DESCRIPTOR);
   if (lookup->property_details().type() == FIELD) {
     FieldIndex field = lookup->GetFieldIndex();
     if (receiver_is_holder) {
       return SimpleFieldLoad(field);
     }
+    NamedLoadHandlerCompiler compiler(isolate(), receiver_type(), holder,
+                                      cache_holder);
     return compiler.CompileLoadField(name, field);
   }
 
   // -------------- Constant properties --------------
   DCHECK(lookup->property_details().type() == CONSTANT);
   if (receiver_is_holder) {
     LoadConstantStub stub(isolate(), lookup->GetConstantIndex());
     return stub.GetCode();
   }
+  NamedLoadHandlerCompiler compiler(isolate(), receiver_type(), holder,
+                                    cache_holder);
   return compiler.CompileLoadConstant(name, lookup->GetConstantIndex());
 }
 
 
 static Handle<Object> TryConvertKey(Handle<Object> key, Isolate* isolate) {
   // This helper implements a few common fast cases for converting
   // non-smi keys of keyed loads/stores to a smi or a string.
   if (key->IsHeapNumber()) {
     double value = Handle<HeapNumber>::cast(key)->value();
     if (std::isnan(value)) {
@@ skipping 341 matching lines @@
                                           Handle<String> name,
                                           Handle<Object> value,
                                           CacheHolderFlag cache_holder) {
   if (object->IsAccessCheckNeeded()) return slow_stub();
   DCHECK(cache_holder == kCacheOnReceiver || lookup->type() == CALLBACKS ||
          (object->IsJSGlobalProxy() && lookup->holder()->IsJSGlobalObject()));
   // This is currently guaranteed by checks in StoreIC::Store.
   Handle<JSObject> receiver = Handle<JSObject>::cast(object);
 
   Handle<JSObject> holder(lookup->holder());
-  NamedStoreHandlerCompiler compiler(isolate(), receiver_type(), holder);
 
   if (lookup->IsTransition()) {
     // Explicitly pass in the receiver map since LookupForWrite may have
     // stored something else than the receiver in the holder.
     Handle<Map> transition(lookup->GetTransitionTarget());
     PropertyDetails details = lookup->GetPropertyDetails();
 
     if (details.type() != CALLBACKS && details.attributes() == NONE &&
         holder->HasFastProperties()) {
+      NamedStoreHandlerCompiler compiler(isolate(), receiver_type(), holder);
       return compiler.CompileStoreTransition(transition, name);
     }
   } else {
     switch (lookup->type()) {
       case FIELD: {
         bool use_stub = true;
         if (lookup->representation().IsHeapObject()) {
           // Only use a generic stub if no types need to be tracked.
           HeapType* field_type = lookup->GetFieldType();
           HeapType::Iterator<Map> it = field_type->Classes();
           use_stub = it.Done();
         }
         if (use_stub) {
           StoreFieldStub stub(isolate(), lookup->GetFieldIndex(),
                               lookup->representation());
           return stub.GetCode();
         }
+        NamedStoreHandlerCompiler compiler(isolate(), receiver_type(), holder);
         return compiler.CompileStoreField(lookup, name);
       }
       case NORMAL:
         if (receiver->IsJSGlobalProxy() || receiver->IsGlobalObject()) {
           // The stub generated for the global object picks the value directly
           // from the property cell. So the property must be directly on the
           // global object.
           PrototypeIterator iter(isolate(), receiver);
           Handle<GlobalObject> global =
               receiver->IsJSGlobalProxy()
@@ skipping 15 matching lines @@
         Handle<Object> callback(lookup->GetCallbackObject(), isolate());
         if (callback->IsExecutableAccessorInfo()) {
           Handle<ExecutableAccessorInfo> info =
               Handle<ExecutableAccessorInfo>::cast(callback);
           if (v8::ToCData<Address>(info->setter()) == 0) break;
           if (!holder->HasFastProperties()) break;
           if (!ExecutableAccessorInfo::IsCompatibleReceiverType(
                   isolate(), info, receiver_type())) {
             break;
           }
+          NamedStoreHandlerCompiler compiler(isolate(), receiver_type(),
+                                             holder);
           return compiler.CompileStoreCallback(receiver, name, info);
         } else if (callback->IsAccessorPair()) {
           Handle<Object> setter(
               Handle<AccessorPair>::cast(callback)->setter(), isolate());
           if (!setter->IsJSFunction()) break;
           if (holder->IsGlobalObject()) break;
           if (!holder->HasFastProperties()) break;
           Handle<JSFunction> function = Handle<JSFunction>::cast(setter);
           CallOptimization call_optimization(function);
+          NamedStoreHandlerCompiler compiler(isolate(), receiver_type(),
+                                             holder);
           if (call_optimization.is_simple_api_call() &&
               call_optimization.IsCompatibleReceiver(receiver, holder)) {
             return compiler.CompileStoreCallback(receiver, name,
                                                  call_optimization);
           }
           return compiler.CompileStoreViaSetter(
               receiver, name, Handle<JSFunction>::cast(setter));
         }
         // TODO(dcarney): Handle correctly.
         DCHECK(callback->IsDeclaredAccessorInfo());
         break;
       }
-      case INTERCEPTOR:
+      case INTERCEPTOR: {
         DCHECK(HasInterceptorSetter(*holder));
+        NamedStoreHandlerCompiler compiler(isolate(), receiver_type(), holder);
         return compiler.CompileStoreInterceptor(name);
+      }
       case CONSTANT:
         break;
       case NONEXISTENT:
       case HANDLER:
         UNREACHABLE();
         break;
     }
   }
   return slow_stub();
 }
@@ skipping 1547 matching lines @@
 #undef ADDR
 };
 
 
 Address IC::AddressFromUtilityId(IC::UtilityId id) {
   return IC_utilities[id];
 }
 
 
 } }  // namespace v8::internal