Always use the LoadStubCompiler for Load handlers, also for keyedload handlers.

src/stub-cache.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/api.h"
 #include "src/arguments.h"
 #include "src/ast.h"
 #include "src/code-stubs.h"
@@ skipping 125 matching lines @@
   Handle<Code> ic;
   // There are multiple string maps that all use the same prototype. That
   // prototype cannot hold multiple handlers, one for each of the string maps,
   // for a single name. Hence, turn off caching of the IC.
   bool can_be_cached = !type->Is(HeapType::String());
   if (can_be_cached) {
     ic = FindIC(name, stub_holder, kind, extra_ic_state, flag);
     if (!ic.is_null()) return ic;
   }
 
-  if (kind == Code::LOAD_IC) {
-    LoadStubCompiler ic_compiler(isolate(), extra_ic_state, flag);
-    ic = ic_compiler.CompileMonomorphicIC(type, handler, name);
-  } else if (kind == Code::KEYED_LOAD_IC) {
-    KeyedLoadStubCompiler ic_compiler(isolate(), extra_ic_state, flag);
+  if (kind == Code::LOAD_IC || kind == Code::KEYED_LOAD_IC) {
+    LoadStubCompiler ic_compiler(isolate(), kind, extra_ic_state, flag);
     ic = ic_compiler.CompileMonomorphicIC(type, handler, name);
   } else if (kind == Code::STORE_IC) {
     StoreStubCompiler ic_compiler(isolate(), extra_ic_state);
     ic = ic_compiler.CompileMonomorphicIC(type, handler, name);
   } else {
     ASSERT(kind == Code::KEYED_STORE_IC);
     ASSERT(STANDARD_STORE ==
            KeyedStoreIC::GetKeyedAccessStoreMode(extra_ic_state));
     KeyedStoreStubCompiler ic_compiler(isolate(), extra_ic_state);
     ic = ic_compiler.CompileMonomorphicIC(type, handler, name);
@@ skipping 29 matching lines @@
   Handle<Map> current_map = stub_holder_map;
   Handle<JSObject> last(JSObject::cast(receiver_map->prototype()));
   while (true) {
     if (current_map->is_dictionary_map()) cache_name = name;
     if (current_map->prototype()->IsNull()) break;
     last = handle(JSObject::cast(current_map->prototype()));
     current_map = handle(last->map());
   }
   // Compile the stub that is either shared for all names or
   // name specific if there are global objects involved.
+  Code::Kind handler_kind = Code::LOAD_IC;
   Handle<Code> handler =
-      FindHandler(cache_name, stub_holder_map, Code::LOAD_IC, flag, Code::FAST);
+      FindHandler(cache_name, stub_holder_map, handler_kind, flag, Code::FAST);
   if (!handler.is_null()) {
     return handler;
   }
 
-  LoadStubCompiler compiler(isolate_, kNoExtraICState, flag);
+  LoadStubCompiler compiler(isolate_, handler_kind, kNoExtraICState, flag);
   handler = compiler.CompileLoadNonexistent(type, last, cache_name);
   Map::UpdateCodeCache(stub_holder_map, cache_name, handler);
   return handler;
 }
 
 
 Handle<Code> StubCache::ComputeKeyedLoadElement(Handle<Map> receiver_map) {
   Code::Flags flags = Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC);
   Handle<Name> name =
       isolate()->factory()->KeyedLoadElementMonomorphic_string();
@@ skipping 143 matching lines @@
   Handle<Object> probe = cache->Lookup(receiver_maps, flags);
   if (probe->IsCode()) return Handle<Code>::cast(probe);
 
   TypeHandleList types(receiver_maps->length());
   for (int i = 0; i < receiver_maps->length(); i++) {
     types.Add(HeapType::Class(receiver_maps->at(i), isolate()));
   }
   CodeHandleList handlers(receiver_maps->length());
   KeyedLoadStubCompiler compiler(isolate_);
   compiler.CompileElementHandlers(receiver_maps, &handlers);
-  Handle<Code> code = compiler.CompilePolymorphicIC(
+  LoadStubCompiler ic_compiler(isolate_, Code::KEYED_LOAD_IC);
+  Handle<Code> code = ic_compiler.CompilePolymorphicIC(
       &types, &handlers, factory()->empty_string(), Code::NORMAL, ELEMENT);
 
   isolate()->counters()->keyed_load_polymorphic_stubs()->Increment();
 
   PolymorphicCodeCache::Update(cache, receiver_maps, flags, code);
   return code;
 }
 
 
 Handle<Code> StubCache::ComputePolymorphicIC(
     Code::Kind kind,
     TypeHandleList* types,
     CodeHandleList* handlers,
     int number_of_valid_types,
     Handle<Name> name,
     ExtraICState extra_ic_state) {
   Handle<Code> handler = handlers->at(0);
   Code::StubType type = number_of_valid_types == 1 ? handler->type()
                                                    : Code::NORMAL;
   if (kind == Code::LOAD_IC) {
-    LoadStubCompiler ic_compiler(isolate_, extra_ic_state);
+    LoadStubCompiler ic_compiler(isolate_, kind, extra_ic_state);
     return ic_compiler.CompilePolymorphicIC(
         types, handlers, name, type, PROPERTY);
   } else {
     ASSERT(kind == Code::STORE_IC);
     StoreStubCompiler ic_compiler(isolate_, extra_ic_state);
     return ic_compiler.CompilePolymorphicIC(
         types, handlers, name, type, PROPERTY);
   }
 }
 
@@ skipping 735 matching lines @@
   } else {
     Handle<Code> stub = FLAG_compiled_keyed_dictionary_loads
         ? KeyedLoadDictionaryElementStub(isolate()).GetCode()
         : KeyedLoadDictionaryElementPlatformStub(isolate()).GetCode();
     __ DispatchMap(receiver(), scratch1(), receiver_map, stub, DO_SMI_CHECK);
   }
 
   TailCallBuiltin(masm(), Builtins::kKeyedLoadIC_Miss);
 
   // Return the generated code.
-  return GetICCode(kind(), Code::NORMAL, factory()->empty_string());
+  Code::Flags flags = Code::ComputeFlags(Code::KEYED_LOAD_IC, MONOMORPHIC,

[mvstanton, 2014/07/23 08:09:28]

Why can't GetICCode() be used? Can it be moved in the class hierarchy and input
parameters changed so as to remain a viable library function for this kind of
thing?

[Toon Verwaest, 2014/07/23 10:28:42]

I'll move this stuff together in another CL in an ICCompiler.

On 2014/07/23 08:09:28, mvstanton wrote:

+                                         extra_state(), Code::NORMAL);
+  Handle<Code> code = GetCodeWithFlags(flags, factory()->empty_string());
+  IC::RegisterWeakMapDependency(code);
+  PROFILE(isolate(), CodeCreateEvent(Logger::KEYED_LOAD_IC_TAG, *code,
+                                     heap()->empty_string()));
+  return code;
 }
 
 
 Handle<Code> KeyedStoreStubCompiler::CompileStoreElement(
     Handle<Map> receiver_map) {
   ElementsKind elements_kind = receiver_map->elements_kind();
   bool is_jsarray = receiver_map->instance_type() == JS_ARRAY_TYPE;
   Handle<Code> stub;
   if (receiver_map->has_fast_elements() ||
       receiver_map->has_external_array_elements() ||
@@ skipping 24 matching lines @@
 
 void StubCompiler::TailCallBuiltin(MacroAssembler* masm, Builtins::Name name) {
   Handle<Code> code(masm->isolate()->builtins()->builtin(name));
   GenerateTailCall(masm, code);
 }
 
 
 void BaseLoadStoreStubCompiler::InitializeRegisters() {
   if (kind_ == Code::LOAD_IC) {
     registers_ = LoadStubCompiler::registers();
-  } else if (kind_ == Code::KEYED_LOAD_IC) {
-    registers_ = KeyedLoadStubCompiler::registers();
   } else if (kind_ == Code::STORE_IC) {
     registers_ = StoreStubCompiler::registers();
   } else {
     registers_ = KeyedStoreStubCompiler::registers();
   }
 }
 
 
 Handle<Code> BaseLoadStoreStubCompiler::GetICCode(Code::Kind kind,
                                                   Code::StubType type,
@@ skipping 226 matching lines @@
           Handle<FunctionTemplateInfo>(
               FunctionTemplateInfo::cast(signature->receiver()));
     }
   }
 
   is_simple_api_call_ = true;
 }
 
 
 } }  // namespace v8::internal