Restructure the IC / Handler compilers

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 83 matching lines @@
   }
   int secondary_offset = SecondaryOffset(name, flags, primary_offset);
   Entry* secondary = entry(secondary_, secondary_offset);
   if (secondary->key == name && secondary->map == map) {
     return secondary->value;
   }
   return NULL;
 }
 
 
-Handle<Code> StubCache::FindIC(Handle<Name> name, Handle<Map> stub_holder,
-                               Code::Kind kind, ExtraICState extra_state,
-                               CacheHolderFlag cache_holder) {
+Handle<Code> PropertyICCompiler::Find(Handle<Name> name,
+                                      Handle<Map> stub_holder, Code::Kind kind,
+                                      ExtraICState extra_state,
+                                      CacheHolderFlag cache_holder) {
   Code::Flags flags = Code::ComputeMonomorphicFlags(
       kind, extra_state, cache_holder);
-  Handle<Object> probe(stub_holder->FindInCodeCache(*name, flags), isolate_);
+  Handle<Object> probe(stub_holder->FindInCodeCache(*name, flags),
+                       name->GetIsolate());
   if (probe->IsCode()) return Handle<Code>::cast(probe);
   return Handle<Code>::null();
 }
 
 
-Handle<Code> StubCache::FindHandler(Handle<Name> name, Handle<Map> stub_holder,
-                                    Code::Kind kind,
-                                    CacheHolderFlag cache_holder,
-                                    Code::StubType type) {
+Handle<Code> PropertyHandlerCompiler::Find(Handle<Name> name,
+                                           Handle<Map> stub_holder,
+                                           Code::Kind kind,
+                                           CacheHolderFlag cache_holder,
+                                           Code::StubType type) {
   Code::Flags flags = Code::ComputeHandlerFlags(kind, type, cache_holder);
 
-  Handle<Object> probe(stub_holder->FindInCodeCache(*name, flags), isolate_);
+  Handle<Object> probe(stub_holder->FindInCodeCache(*name, flags),
+                       name->GetIsolate());
   if (probe->IsCode()) return Handle<Code>::cast(probe);
   return Handle<Code>::null();
 }
 
 
 Handle<Code> StubCache::ComputeMonomorphicIC(
     Code::Kind kind,
     Handle<Name> name,
     Handle<HeapType> type,
     Handle<Code> handler,
     ExtraICState extra_ic_state) {
   CacheHolderFlag flag;
   Handle<Map> stub_holder = IC::GetICCacheHolder(*type, isolate(), &flag);
 
   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);
+    ic =
+        PropertyICCompiler::Find(name, stub_holder, kind, extra_ic_state, flag);
     if (!ic.is_null()) return ic;
   }
 
-  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);
+#ifdef DEBUG
+  if (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);
   }
+#endif
+
+  PropertyICCompiler ic_compiler(isolate(), kind, extra_ic_state, flag);
+  ic = ic_compiler.CompileMonomorphic(type, handler, name, PROPERTY);
 
   if (can_be_cached) Map::UpdateCodeCache(stub_holder, name, ic);
   return ic;
 }
 
 
 Handle<Code> StubCache::ComputeLoadNonexistent(Handle<Name> name,
                                                Handle<HeapType> type) {
   Handle<Map> receiver_map = IC::TypeToMap(*type, isolate());
   if (receiver_map->prototype()->IsNull()) {
@@ skipping 19 matching lines @@
   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, handler_kind, flag, Code::FAST);
-  if (!handler.is_null()) {
-    return handler;
-  }
+  Handle<Code> handler = PropertyHandlerCompiler::Find(
+      cache_name, stub_holder_map, handler_kind, flag, Code::FAST);
+  if (!handler.is_null()) return handler;
 
-  LoadStubCompiler compiler(isolate_, handler_kind, kNoExtraICState, flag);
+  NamedLoadHandlerCompiler 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();
 
   Handle<Object> probe(receiver_map->FindInCodeCache(*name, flags), isolate_);
   if (probe->IsCode()) return Handle<Code>::cast(probe);
 
-  KeyedLoadStubCompiler compiler(isolate());
-  Handle<Code> code = compiler.CompileLoadElement(receiver_map);
+  ElementsKind elements_kind = receiver_map->elements_kind();
+  Handle<Code> stub;
+  if (receiver_map->has_fast_elements() ||
+      receiver_map->has_external_array_elements() ||
+      receiver_map->has_fixed_typed_array_elements()) {
+    stub = KeyedLoadFastElementStub(
+               isolate(), receiver_map->instance_type() == JS_ARRAY_TYPE,
+               elements_kind).GetCode();
+  } else {
+    stub = FLAG_compiled_keyed_dictionary_loads
+               ? KeyedLoadDictionaryElementStub(isolate()).GetCode()
+               : KeyedLoadDictionaryElementPlatformStub(isolate()).GetCode();
+  }
+  PropertyICCompiler compiler(isolate(), Code::KEYED_LOAD_IC);
+  Handle<Code> code =
+      compiler.CompileMonomorphic(HeapType::Class(receiver_map, isolate()),
+                                  stub, factory()->empty_string(), ELEMENT);
 
   Map::UpdateCodeCache(receiver_map, name, code);
   return code;
 }
 
 
 Handle<Code> StubCache::ComputeKeyedStoreElement(
     Handle<Map> receiver_map,
     StrictMode strict_mode,
     KeyedAccessStoreMode store_mode) {
   ExtraICState extra_state =
       KeyedStoreIC::ComputeExtraICState(strict_mode, store_mode);
   Code::Flags flags =
       Code::ComputeMonomorphicFlags(Code::KEYED_STORE_IC, extra_state);
 
   ASSERT(store_mode == STANDARD_STORE ||
          store_mode == STORE_AND_GROW_NO_TRANSITION ||
          store_mode == STORE_NO_TRANSITION_IGNORE_OUT_OF_BOUNDS ||
          store_mode == STORE_NO_TRANSITION_HANDLE_COW);
 
   Handle<String> name =
       isolate()->factory()->KeyedStoreElementMonomorphic_string();
   Handle<Object> probe(receiver_map->FindInCodeCache(*name, flags), isolate_);
   if (probe->IsCode()) return Handle<Code>::cast(probe);
 
-  KeyedStoreStubCompiler compiler(isolate(), extra_state);
-  Handle<Code> code = compiler.CompileStoreElement(receiver_map);
+  PropertyICCompiler compiler(isolate(), Code::KEYED_STORE_IC, extra_state);
+  Handle<Code> code =
+      compiler.CompileIndexedStoreMonomorphic(receiver_map, store_mode);
 
   Map::UpdateCodeCache(receiver_map, name, code);
   ASSERT(KeyedStoreIC::GetKeyedAccessStoreMode(code->extra_ic_state())
          == store_mode);
   return code;
 }
 
 
 #define CALL_LOGGER_TAG(kind, type) (Logger::KEYED_##type)
 
@@ skipping 20 matching lines @@
 
 
 Handle<Code> StubCache::ComputeLoad(InlineCacheState ic_state,
                                     ExtraICState extra_state) {
   Code::Flags flags = Code::ComputeFlags(Code::LOAD_IC, ic_state, extra_state);
   Handle<UnseededNumberDictionary> cache =
       isolate_->factory()->non_monomorphic_cache();
   int entry = cache->FindEntry(isolate_, flags);
   if (entry != -1) return Handle<Code>(Code::cast(cache->ValueAt(entry)));
 
-  StubCompiler compiler(isolate_);
+  PropertyICCompiler compiler(isolate_, Code::LOAD_IC);
   Handle<Code> code;
   if (ic_state == UNINITIALIZED) {
     code = compiler.CompileLoadInitialize(flags);
   } else if (ic_state == PREMONOMORPHIC) {
     code = compiler.CompileLoadPreMonomorphic(flags);
   } else if (ic_state == MEGAMORPHIC) {
     code = compiler.CompileLoadMegamorphic(flags);
   } else {
     UNREACHABLE();
   }
   FillCache(isolate_, code);
   return code;
 }
 
 
 Handle<Code> StubCache::ComputeStore(InlineCacheState ic_state,
                                      ExtraICState extra_state) {
   Code::Flags flags = Code::ComputeFlags(Code::STORE_IC, ic_state, extra_state);
   Handle<UnseededNumberDictionary> cache =
       isolate_->factory()->non_monomorphic_cache();
   int entry = cache->FindEntry(isolate_, flags);
   if (entry != -1) return Handle<Code>(Code::cast(cache->ValueAt(entry)));
 
-  StubCompiler compiler(isolate_);
+  PropertyICCompiler compiler(isolate_, Code::STORE_IC);
   Handle<Code> code;
   if (ic_state == UNINITIALIZED) {
     code = compiler.CompileStoreInitialize(flags);
   } else if (ic_state == PREMONOMORPHIC) {
     code = compiler.CompileStorePreMonomorphic(flags);
   } else if (ic_state == GENERIC) {
     code = compiler.CompileStoreGeneric(flags);
   } else if (ic_state == MEGAMORPHIC) {
     code = compiler.CompileStoreMegamorphic(flags);
   } else {
     UNREACHABLE();
   }
 
   FillCache(isolate_, code);
   return code;
 }
 
 
 Handle<Code> StubCache::ComputeCompareNil(Handle<Map> receiver_map,
                                           CompareNilICStub* stub) {
   Handle<String> name(isolate_->heap()->empty_string());
   if (!receiver_map->is_shared()) {
-    Handle<Code> cached_ic = FindIC(name, receiver_map, Code::COMPARE_NIL_IC,
-                                    stub->GetExtraICState());
+    Handle<Code> cached_ic = PropertyICCompiler::Find(
+        name, receiver_map, Code::COMPARE_NIL_IC, stub->GetExtraICState());
     if (!cached_ic.is_null()) return cached_ic;
   }
 
   Code::FindAndReplacePattern pattern;
   pattern.Add(isolate_->factory()->meta_map(), receiver_map);
   Handle<Code> ic = stub->GetCodeCopy(pattern);
 
   if (!receiver_map->is_shared()) {
     Map::UpdateCodeCache(receiver_map, name, ic);
   }
 
   return ic;
 }
 
 
 // TODO(verwaest): Change this method so it takes in a TypeHandleList.
 Handle<Code> StubCache::ComputeLoadElementPolymorphic(
     MapHandleList* receiver_maps) {
   Code::Flags flags = Code::ComputeFlags(Code::KEYED_LOAD_IC, POLYMORPHIC);
   Handle<PolymorphicCodeCache> cache =
       isolate_->factory()->polymorphic_code_cache();
   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_);
+  IndexedHandlerCompiler compiler(isolate_);
   compiler.CompileElementHandlers(receiver_maps, &handlers);
-  LoadStubCompiler ic_compiler(isolate_, Code::KEYED_LOAD_IC);
-  Handle<Code> code = ic_compiler.CompilePolymorphicIC(
+  PropertyICCompiler ic_compiler(isolate_, Code::KEYED_LOAD_IC);
+  Handle<Code> code = ic_compiler.CompilePolymorphic(
       &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_, 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);
-  }
+  ASSERT(kind == Code::LOAD_IC || kind == Code::STORE_IC);
+  PropertyICCompiler ic_compiler(isolate_, kind, extra_ic_state);
+  return ic_compiler.CompilePolymorphic(types, handlers, name, type, PROPERTY);
 }
 
 
 Handle<Code> StubCache::ComputeStoreElementPolymorphic(
     MapHandleList* receiver_maps,
     KeyedAccessStoreMode store_mode,
     StrictMode strict_mode) {
   ASSERT(store_mode == STANDARD_STORE ||
          store_mode == STORE_AND_GROW_NO_TRANSITION ||
          store_mode == STORE_NO_TRANSITION_IGNORE_OUT_OF_BOUNDS ||
          store_mode == STORE_NO_TRANSITION_HANDLE_COW);
   Handle<PolymorphicCodeCache> cache =
       isolate_->factory()->polymorphic_code_cache();
   ExtraICState extra_state = KeyedStoreIC::ComputeExtraICState(
       strict_mode, store_mode);
   Code::Flags flags =
       Code::ComputeFlags(Code::KEYED_STORE_IC, POLYMORPHIC, extra_state);
   Handle<Object> probe = cache->Lookup(receiver_maps, flags);
   if (probe->IsCode()) return Handle<Code>::cast(probe);
 
-  KeyedStoreStubCompiler compiler(isolate_, extra_state);
-  Handle<Code> code = compiler.CompileStoreElementPolymorphic(receiver_maps);
+  PropertyICCompiler compiler(isolate_, Code::KEYED_STORE_IC, extra_state);
+  Handle<Code> code =
+      compiler.CompileIndexedStorePolymorphic(receiver_maps, store_mode);
   PolymorphicCodeCache::Update(cache, receiver_maps, flags, code);
   return code;
 }
 
 
 void StubCache::Clear() {
   Code* empty = isolate_->builtins()->builtin(Builtins::kIllegal);
   for (int i = 0; i < kPrimaryTableSize; i++) {
     primary_[i].key = heap()->empty_string();
     primary_[i].map = NULL;
@@ skipping 190 matching lines @@
   ASSERT(args.smi_at(1) >= 0);
   uint32_t index = args.smi_at(1);
   Handle<Object> result;
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
       isolate, result,
       JSObject::GetElementWithInterceptor(receiver, receiver, index));
   return *result;
 }
 
 
-Handle<Code> StubCompiler::CompileLoadInitialize(Code::Flags flags) {
+Handle<Code> PropertyICCompiler::CompileLoadInitialize(Code::Flags flags) {
   LoadIC::GenerateInitialize(masm());
   Handle<Code> code = GetCodeWithFlags(flags, "CompileLoadInitialize");
   PROFILE(isolate(),
           CodeCreateEvent(Logger::LOAD_INITIALIZE_TAG, *code, 0));
   return code;
 }
 
 
-Handle<Code> StubCompiler::CompileLoadPreMonomorphic(Code::Flags flags) {
+Handle<Code> PropertyICCompiler::CompileLoadPreMonomorphic(Code::Flags flags) {
   LoadIC::GeneratePreMonomorphic(masm());
   Handle<Code> code = GetCodeWithFlags(flags, "CompileLoadPreMonomorphic");
   PROFILE(isolate(),
           CodeCreateEvent(Logger::LOAD_PREMONOMORPHIC_TAG, *code, 0));
   return code;
 }
 
 
-Handle<Code> StubCompiler::CompileLoadMegamorphic(Code::Flags flags) {
+Handle<Code> PropertyICCompiler::CompileLoadMegamorphic(Code::Flags flags) {
   LoadIC::GenerateMegamorphic(masm());
   Handle<Code> code = GetCodeWithFlags(flags, "CompileLoadMegamorphic");
   PROFILE(isolate(),
           CodeCreateEvent(Logger::LOAD_MEGAMORPHIC_TAG, *code, 0));
   return code;
 }
 
 
-Handle<Code> StubCompiler::CompileStoreInitialize(Code::Flags flags) {
+Handle<Code> PropertyICCompiler::CompileStoreInitialize(Code::Flags flags) {
   StoreIC::GenerateInitialize(masm());
   Handle<Code> code = GetCodeWithFlags(flags, "CompileStoreInitialize");
   PROFILE(isolate(),
           CodeCreateEvent(Logger::STORE_INITIALIZE_TAG, *code, 0));
   return code;
 }
 
 
-Handle<Code> StubCompiler::CompileStorePreMonomorphic(Code::Flags flags) {
+Handle<Code> PropertyICCompiler::CompileStorePreMonomorphic(Code::Flags flags) {
   StoreIC::GeneratePreMonomorphic(masm());
   Handle<Code> code = GetCodeWithFlags(flags, "CompileStorePreMonomorphic");
   PROFILE(isolate(),
           CodeCreateEvent(Logger::STORE_PREMONOMORPHIC_TAG, *code, 0));
   return code;
 }
 
 
-Handle<Code> StubCompiler::CompileStoreGeneric(Code::Flags flags) {
+Handle<Code> PropertyICCompiler::CompileStoreGeneric(Code::Flags flags) {
   ExtraICState extra_state = Code::ExtractExtraICStateFromFlags(flags);
   StrictMode strict_mode = StoreIC::GetStrictMode(extra_state);
   StoreIC::GenerateRuntimeSetProperty(masm(), strict_mode);
   Handle<Code> code = GetCodeWithFlags(flags, "CompileStoreGeneric");
   PROFILE(isolate(),
           CodeCreateEvent(Logger::STORE_GENERIC_TAG, *code, 0));
   return code;
 }
 
 
-Handle<Code> StubCompiler::CompileStoreMegamorphic(Code::Flags flags) {
+Handle<Code> PropertyICCompiler::CompileStoreMegamorphic(Code::Flags flags) {
   StoreIC::GenerateMegamorphic(masm());
   Handle<Code> code = GetCodeWithFlags(flags, "CompileStoreMegamorphic");
   PROFILE(isolate(),
           CodeCreateEvent(Logger::STORE_MEGAMORPHIC_TAG, *code, 0));
   return code;
 }
 
 
 #undef CALL_LOGGER_TAG
 
 
-Handle<Code> StubCompiler::GetCodeWithFlags(Code::Flags flags,
-                                            const char* name) {
+Handle<Code> PropertyAccessCompiler::GetCodeWithFlags(Code::Flags flags,
+                                                      const char* name) {
   // Create code object in the heap.
   CodeDesc desc;
-  masm_.GetCode(&desc);
-  Handle<Code> code = factory()->NewCode(desc, flags, masm_.CodeObject());
+  masm()->GetCode(&desc);
+  Handle<Code> code = factory()->NewCode(desc, flags, masm()->CodeObject());
   if (code->IsCodeStubOrIC()) code->set_stub_key(CodeStub::NoCacheKey());
 #ifdef ENABLE_DISASSEMBLER
   if (FLAG_print_code_stubs) {
     OFStream os(stdout);
     code->Disassemble(name, os);
   }
 #endif
   return code;
 }
 
 
-Handle<Code> StubCompiler::GetCodeWithFlags(Code::Flags flags,
-                                            Handle<Name> name) {
+Handle<Code> PropertyAccessCompiler::GetCodeWithFlags(Code::Flags flags,
+                                                      Handle<Name> name) {
   return (FLAG_print_code_stubs && !name.is_null() && name->IsString())
       ? GetCodeWithFlags(flags, Handle<String>::cast(name)->ToCString().get())
       : GetCodeWithFlags(flags, NULL);
 }
 
 
-void StubCompiler::LookupPostInterceptor(Handle<JSObject> holder,
-                                         Handle<Name> name,
-                                         LookupResult* lookup) {
-  holder->LookupOwnRealNamedProperty(name, lookup);
-  if (lookup->IsFound()) return;
-  PrototypeIterator iter(holder->GetIsolate(), holder);
-  if (iter.IsAtEnd()) return;
-  PrototypeIterator::GetCurrent(iter)->Lookup(name, lookup);
-}
-
-
 #define __ ACCESS_MASM(masm())
 
 
-Register LoadStubCompiler::HandlerFrontendHeader(
-    Handle<HeapType> type,
-    Register object_reg,
-    Handle<JSObject> holder,
-    Handle<Name> name,
-    Label* miss) {
+Register NamedLoadHandlerCompiler::FrontendHeader(Handle<HeapType> type,
+                                                  Register object_reg,
+                                                  Handle<JSObject> holder,
+                                                  Handle<Name> name,
+                                                  Label* miss) {
   PrototypeCheckType check_type = CHECK_ALL_MAPS;
   int function_index = -1;
   if (type->Is(HeapType::String())) {
     function_index = Context::STRING_FUNCTION_INDEX;
   } else if (type->Is(HeapType::Symbol())) {
     function_index = Context::SYMBOL_FUNCTION_INDEX;
   } else if (type->Is(HeapType::Number())) {
     function_index = Context::NUMBER_FUNCTION_INDEX;
   } else if (type->Is(HeapType::Boolean())) {
     function_index = Context::BOOLEAN_FUNCTION_INDEX;
@@ skipping 10 matching lines @@
     object_reg = scratch1();
   }
 
   // Check that the maps starting from the prototype haven't changed.
   return CheckPrototypes(
       type, object_reg, holder, scratch1(), scratch2(), scratch3(),
       name, miss, check_type);
 }
 
 
-// HandlerFrontend for store uses the name register. It has to be restored
-// before a miss.
-Register StoreStubCompiler::HandlerFrontendHeader(
-    Handle<HeapType> type,
-    Register object_reg,
-    Handle<JSObject> holder,
-    Handle<Name> name,
-    Label* miss) {
+// Frontend for store uses the name register. It has to be restored before a
+// miss.
+Register NamedStoreHandlerCompiler::FrontendHeader(Handle<HeapType> type,
+                                                   Register object_reg,
+                                                   Handle<JSObject> holder,
+                                                   Handle<Name> name,
+                                                   Label* miss) {
   return CheckPrototypes(type, object_reg, holder, this->name(),
                          scratch1(), scratch2(), name, miss, SKIP_RECEIVER);
 }
 
 
-bool BaseLoadStoreStubCompiler::IncludesNumberType(TypeHandleList* types) {
+bool PropertyICCompiler::IncludesNumberType(TypeHandleList* types) {
   for (int i = 0; i < types->length(); ++i) {
     if (types->at(i)->Is(HeapType::Number())) return true;
   }
   return false;
 }
 
 
-Register BaseLoadStoreStubCompiler::HandlerFrontend(Handle<HeapType> type,
-                                                    Register object_reg,
-                                                    Handle<JSObject> holder,
-                                                    Handle<Name> name) {
+Register PropertyHandlerCompiler::Frontend(Handle<HeapType> type,
+                                           Register object_reg,
+                                           Handle<JSObject> holder,
+                                           Handle<Name> name) {
   Label miss;
-
-  Register reg = HandlerFrontendHeader(type, object_reg, holder, name, &miss);
-
-  HandlerFrontendFooter(name, &miss);
-
+  Register reg = FrontendHeader(type, object_reg, holder, name, &miss);
+  FrontendFooter(name, &miss);
   return reg;
 }
 
 
-void LoadStubCompiler::NonexistentHandlerFrontend(Handle<HeapType> type,
-                                                  Handle<JSObject> last,
-                                                  Handle<Name> name) {
+void NamedLoadHandlerCompiler::NonexistentFrontend(Handle<HeapType> type,
+                                                   Handle<JSObject> last,
+                                                   Handle<Name> name) {
   Label miss;
 
   Register holder;
   Handle<Map> last_map;
   if (last.is_null()) {
     holder = receiver();
     last_map = IC::TypeToMap(*type, isolate());
     // If |type| has null as its prototype, |last| is Handle<JSObject>::null().
     ASSERT(last_map->prototype() == isolate()->heap()->null_value());
   } else {
-    holder = HandlerFrontendHeader(type, receiver(), last, name, &miss);
+    holder = FrontendHeader(type, receiver(), last, name, &miss);
     last_map = handle(last->map());
   }
 
   if (last_map->is_dictionary_map() &&
       !last_map->IsJSGlobalObjectMap() &&
       !last_map->IsJSGlobalProxyMap()) {
     if (!name->IsUniqueName()) {
       ASSERT(name->IsString());
       name = factory()->InternalizeString(Handle<String>::cast(name));
     }
     ASSERT(last.is_null() ||
            last->property_dictionary()->FindEntry(name) ==
                NameDictionary::kNotFound);
     GenerateDictionaryNegativeLookup(masm(), &miss, holder, name,
                                      scratch2(), scratch3());
   }
 
   // If the last object in the prototype chain is a global object,
   // check that the global property cell is empty.
   if (last_map->IsJSGlobalObjectMap()) {
     Handle<JSGlobalObject> global = last.is_null()
         ? Handle<JSGlobalObject>::cast(type->AsConstant()->Value())
         : Handle<JSGlobalObject>::cast(last);
     GenerateCheckPropertyCell(masm(), global, name, scratch2(), &miss);
   }
 
-  HandlerFrontendFooter(name, &miss);
+  FrontendFooter(name, &miss);
 }
 
 
-Handle<Code> LoadStubCompiler::CompileLoadField(
-    Handle<HeapType> type,
-    Handle<JSObject> holder,
-    Handle<Name> name,
-    FieldIndex field,
-    Representation representation) {
-  Register reg = HandlerFrontend(type, receiver(), holder, name);
+Handle<Code> NamedLoadHandlerCompiler::CompileLoadField(
+    Handle<HeapType> type, Handle<JSObject> holder, Handle<Name> name,
+    FieldIndex field, Representation representation) {
+  Register reg = Frontend(type, receiver(), holder, name);
   GenerateLoadField(reg, holder, field, representation);
-
-  // Return the generated code.
   return GetCode(kind(), Code::FAST, name);
 }
 
 
-Handle<Code> LoadStubCompiler::CompileLoadConstant(
-    Handle<HeapType> type,
-    Handle<JSObject> holder,
-    Handle<Name> name,
+Handle<Code> NamedLoadHandlerCompiler::CompileLoadConstant(
+    Handle<HeapType> type, Handle<JSObject> holder, Handle<Name> name,
     Handle<Object> value) {
-  HandlerFrontend(type, receiver(), holder, name);
+  Frontend(type, receiver(), holder, name);
   GenerateLoadConstant(value);
-
-  // Return the generated code.
   return GetCode(kind(), Code::FAST, name);
 }
 
 
-Handle<Code> LoadStubCompiler::CompileLoadCallback(
-    Handle<HeapType> type,
-    Handle<JSObject> holder,
-    Handle<Name> name,
+Handle<Code> NamedLoadHandlerCompiler::CompileLoadCallback(
+    Handle<HeapType> type, Handle<JSObject> holder, Handle<Name> name,
     Handle<ExecutableAccessorInfo> callback) {
-  Register reg = CallbackHandlerFrontend(
-      type, receiver(), holder, name, callback);
+  Register reg = CallbackFrontend(type, receiver(), holder, name, callback);
   GenerateLoadCallback(reg, callback);
-
-  // Return the generated code.
   return GetCode(kind(), Code::FAST, name);
 }
 
 
-Handle<Code> LoadStubCompiler::CompileLoadCallback(
-    Handle<HeapType> type,
-    Handle<JSObject> holder,
-    Handle<Name> name,
+Handle<Code> NamedLoadHandlerCompiler::CompileLoadCallback(
+    Handle<HeapType> type, Handle<JSObject> holder, Handle<Name> name,
     const CallOptimization& call_optimization) {
   ASSERT(call_optimization.is_simple_api_call());
   Handle<JSFunction> callback = call_optimization.constant_function();
-  CallbackHandlerFrontend(type, receiver(), holder, name, callback);
+  CallbackFrontend(type, receiver(), holder, name, callback);
   Handle<Map>receiver_map = IC::TypeToMap(*type, isolate());
   GenerateFastApiCall(
       masm(), call_optimization, receiver_map,
       receiver(), scratch1(), false, 0, NULL);
-  // Return the generated code.
   return GetCode(kind(), Code::FAST, name);
 }
 
 
-Handle<Code> LoadStubCompiler::CompileLoadInterceptor(
-    Handle<HeapType> type,
-    Handle<JSObject> holder,
-    Handle<Name> name) {
+Handle<Code> NamedLoadHandlerCompiler::CompileLoadInterceptor(
+    Handle<HeapType> type, Handle<JSObject> holder, Handle<Name> name) {
+  // Perform a lookup after the interceptor.
   LookupResult lookup(isolate());
-  LookupPostInterceptor(holder, name, &lookup);
+  holder->LookupOwnRealNamedProperty(name, &lookup);
+  if (!lookup.IsFound()) {
+    PrototypeIterator iter(holder->GetIsolate(), holder);
+    if (!iter.IsAtEnd()) {
+      PrototypeIterator::GetCurrent(iter)->Lookup(name, &lookup);
+    }
+  }
 
-  Register reg = HandlerFrontend(type, receiver(), holder, name);
+  Register reg = Frontend(type, receiver(), holder, name);
   // TODO(368): Compile in the whole chain: all the interceptors in
   // prototypes and ultimate answer.
   GenerateLoadInterceptor(reg, type, holder, &lookup, name);
-
-  // Return the generated code.
   return GetCode(kind(), Code::FAST, name);
 }
 
 
-void LoadStubCompiler::GenerateLoadPostInterceptor(
-    Register interceptor_reg,
-    Handle<JSObject> interceptor_holder,
-    Handle<Name> name,
-    LookupResult* lookup) {
+void NamedLoadHandlerCompiler::GenerateLoadPostInterceptor(
+    Register interceptor_reg, Handle<JSObject> interceptor_holder,
+    Handle<Name> name, LookupResult* lookup) {
   Handle<JSObject> holder(lookup->holder());
   if (lookup->IsField()) {
     FieldIndex field = lookup->GetFieldIndex();
     if (interceptor_holder.is_identical_to(holder)) {
       GenerateLoadField(
           interceptor_reg, holder, field, lookup->representation());
     } else {
       // We found FIELD property in prototype chain of interceptor's holder.
       // Retrieve a field from field's holder.
-      Register reg = HandlerFrontend(
-          IC::CurrentTypeOf(interceptor_holder, isolate()),
-          interceptor_reg, holder, name);
+      Register reg = Frontend(IC::CurrentTypeOf(interceptor_holder, isolate()),
+                              interceptor_reg, holder, name);
       GenerateLoadField(
           reg, holder, field, lookup->representation());
     }
   } else {
     // We found CALLBACKS property in prototype chain of interceptor's
     // holder.
     ASSERT(lookup->type() == CALLBACKS);
     Handle<ExecutableAccessorInfo> callback(
         ExecutableAccessorInfo::cast(lookup->GetCallbackObject()));
     ASSERT(callback->getter() != NULL);
 
-    Register reg = CallbackHandlerFrontend(
-        IC::CurrentTypeOf(interceptor_holder, isolate()),
-        interceptor_reg, holder, name, callback);
+    Register reg =
+        CallbackFrontend(IC::CurrentTypeOf(interceptor_holder, isolate()),
+                         interceptor_reg, holder, name, callback);
     GenerateLoadCallback(reg, callback);
   }
 }
 
 
-Handle<Code> BaseLoadStoreStubCompiler::CompileMonomorphicIC(
-    Handle<HeapType> type,
-    Handle<Code> handler,
-    Handle<Name> name) {
+Handle<Code> PropertyICCompiler::CompileMonomorphic(Handle<HeapType> type,
+                                                    Handle<Code> handler,
+                                                    Handle<Name> name,
+                                                    IcCheckType check) {
   TypeHandleList types(1);
   CodeHandleList handlers(1);
   types.Add(type);
   handlers.Add(handler);
   Code::StubType stub_type = handler->type();
-  return CompilePolymorphicIC(&types, &handlers, name, stub_type, PROPERTY);
+  return CompilePolymorphic(&types, &handlers, name, stub_type, check);
 }
 
 
-Handle<Code> LoadStubCompiler::CompileLoadViaGetter(
-    Handle<HeapType> type,
-    Handle<JSObject> holder,
-    Handle<Name> name,
+Handle<Code> NamedLoadHandlerCompiler::CompileLoadViaGetter(
+    Handle<HeapType> type, Handle<JSObject> holder, Handle<Name> name,
     Handle<JSFunction> getter) {
-  HandlerFrontend(type, receiver(), holder, name);
+  Frontend(type, receiver(), holder, name);
   GenerateLoadViaGetter(masm(), type, receiver(), getter);
-
-  // Return the generated code.
   return GetCode(kind(), Code::FAST, name);
 }
 
 
-Handle<Code> StoreStubCompiler::CompileStoreTransition(
-    Handle<JSObject> object,
-    LookupResult* lookup,
-    Handle<Map> transition,
+Handle<Code> NamedStoreHandlerCompiler::CompileStoreTransition(
+    Handle<JSObject> object, LookupResult* lookup, Handle<Map> transition,
     Handle<Name> name) {
   Label miss, slow;
 
   // Ensure no transitions to deprecated maps are followed.
   __ CheckMapDeprecated(transition, scratch1(), &miss);
 
   // Check that we are allowed to write this.
   PrototypeIterator iter(object->GetIsolate(), object);
   if (!iter.IsAtEnd()) {
     Handle<JSObject> holder;
     // holder == object indicates that no property was found.
     if (lookup->holder() != *object) {
       holder = Handle<JSObject>(lookup->holder());
     } else {
       // Find the top object.
       do {
         holder = Handle<JSObject>::cast(PrototypeIterator::GetCurrent(iter));
         iter.Advance();
       } while (!iter.IsAtEnd());
     }
 
-    Register holder_reg = HandlerFrontendHeader(
-        IC::CurrentTypeOf(object, isolate()), receiver(), holder, name, &miss);
+    Register holder_reg = FrontendHeader(IC::CurrentTypeOf(object, isolate()),
+                                         receiver(), holder, name, &miss);
 
     // If no property was found, and the holder (the last object in the
     // prototype chain) is in slow mode, we need to do a negative lookup on the
     // holder.
     if (lookup->holder() == *object) {
       GenerateNegativeHolderLookup(masm(), holder, holder_reg, name, &miss);
     }
   }
 
   GenerateStoreTransition(masm(),
                           object,
                           lookup,
                           transition,
                           name,
                           receiver(), this->name(), value(),
                           scratch1(), scratch2(), scratch3(),
                           &miss,
                           &slow);
 
   // Handle store cache miss.
   GenerateRestoreName(masm(), &miss, name);
   TailCallBuiltin(masm(), MissBuiltin(kind()));
 
   GenerateRestoreName(masm(), &slow, name);
   TailCallBuiltin(masm(), SlowBuiltin(kind()));
-
-  // Return the generated code.
   return GetCode(kind(), Code::FAST, name);
 }
 
 
-Handle<Code> StoreStubCompiler::CompileStoreField(Handle<JSObject> object,
-                                                  LookupResult* lookup,
-                                                  Handle<Name> name) {
+Handle<Code> NamedStoreHandlerCompiler::CompileStoreField(
+    Handle<JSObject> object, LookupResult* lookup, Handle<Name> name) {
   Label miss;
 
-  HandlerFrontendHeader(IC::CurrentTypeOf(object, isolate()),
-                        receiver(), object, name, &miss);
+  FrontendHeader(IC::CurrentTypeOf(object, isolate()), receiver(), object, name,
+                 &miss);
 
   // Generate store field code.
   GenerateStoreField(masm(),
                      object,
                      lookup,
                      receiver(), this->name(), value(), scratch1(), scratch2(),
                      &miss);
 
   // Handle store cache miss.
   __ bind(&miss);
   TailCallBuiltin(masm(), MissBuiltin(kind()));
-
-  // Return the generated code.
   return GetCode(kind(), Code::FAST, name);
 }
 
 
-Handle<Code> StoreStubCompiler::CompileStoreArrayLength(Handle<JSObject> object,
-                                                        LookupResult* lookup,
-                                                        Handle<Name> name) {
+Handle<Code> NamedStoreHandlerCompiler::CompileStoreArrayLength(
+    Handle<JSObject> object, LookupResult* lookup, Handle<Name> name) {
   // This accepts as a receiver anything JSArray::SetElementsLength accepts
   // (currently anything except for external arrays which means anything with
   // elements of FixedArray type).  Value must be a number, but only smis are
   // accepted as the most common case.
   Label miss;
 
   // Check that value is a smi.
   __ JumpIfNotSmi(value(), &miss);
 
   // Generate tail call to StoreIC_ArrayLength.
   GenerateStoreArrayLength();
 
   // Handle miss case.
   __ bind(&miss);
   TailCallBuiltin(masm(), MissBuiltin(kind()));
-
-  // Return the generated code.
   return GetCode(kind(), Code::FAST, name);
 }
 
 
-Handle<Code> StoreStubCompiler::CompileStoreViaSetter(
-    Handle<JSObject> object,
-    Handle<JSObject> holder,
-    Handle<Name> name,
+Handle<Code> NamedStoreHandlerCompiler::CompileStoreViaSetter(
+    Handle<JSObject> object, Handle<JSObject> holder, Handle<Name> name,
     Handle<JSFunction> setter) {
   Handle<HeapType> type = IC::CurrentTypeOf(object, isolate());
-  HandlerFrontend(type, receiver(), holder, name);
+  Frontend(type, receiver(), holder, name);
   GenerateStoreViaSetter(masm(), type, receiver(), setter);
 
   return GetCode(kind(), Code::FAST, name);
 }
 
 
-Handle<Code> StoreStubCompiler::CompileStoreCallback(
-    Handle<JSObject> object,
-    Handle<JSObject> holder,
-    Handle<Name> name,
+Handle<Code> NamedStoreHandlerCompiler::CompileStoreCallback(
+    Handle<JSObject> object, Handle<JSObject> holder, Handle<Name> name,
     const CallOptimization& call_optimization) {
-  HandlerFrontend(IC::CurrentTypeOf(object, isolate()),
-                  receiver(), holder, name);
+  Frontend(IC::CurrentTypeOf(object, isolate()), receiver(), holder, name);
   Register values[] = { value() };
   GenerateFastApiCall(
       masm(), call_optimization, handle(object->map()),
       receiver(), scratch1(), true, 1, values);
-  // Return the generated code.
   return GetCode(kind(), Code::FAST, name);
 }
 
 
-Handle<Code> KeyedLoadStubCompiler::CompileLoadElement(
-    Handle<Map> receiver_map) {
-  ElementsKind elements_kind = receiver_map->elements_kind();
-  if (receiver_map->has_fast_elements() ||
-      receiver_map->has_external_array_elements() ||
-      receiver_map->has_fixed_typed_array_elements()) {
-    Handle<Code> stub = KeyedLoadFastElementStub(
-        isolate(),
-        receiver_map->instance_type() == JS_ARRAY_TYPE,
-        elements_kind).GetCode();
-    __ DispatchMap(receiver(), scratch1(), receiver_map, stub, DO_SMI_CHECK);
-  } 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.
-  Code::Flags flags = Code::ComputeFlags(Code::KEYED_LOAD_IC, MONOMORPHIC,
-                                         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) {
+Handle<Code> PropertyICCompiler::CompileIndexedStoreMonomorphic(
+    Handle<Map> receiver_map, KeyedAccessStoreMode store_mode) {
   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() ||
       receiver_map->has_fixed_typed_array_elements()) {
-    stub = KeyedStoreFastElementStub(
-        isolate(),
-        is_jsarray,
-        elements_kind,
-        store_mode()).GetCode();
+    stub = KeyedStoreFastElementStub(isolate(), is_jsarray, elements_kind,
+                                     store_mode).GetCode();
   } else {
-    stub = KeyedStoreElementStub(isolate(),
-                                 is_jsarray,
-                                 elements_kind,
-                                 store_mode()).GetCode();
+    stub = KeyedStoreElementStub(isolate(), is_jsarray, elements_kind,
+                                 store_mode).GetCode();
   }
 
   __ DispatchMap(receiver(), scratch1(), receiver_map, stub, DO_SMI_CHECK);
 
   TailCallBuiltin(masm(), Builtins::kKeyedStoreIC_Miss);
 
-  // Return the generated code.
-  return GetICCode(kind(), Code::NORMAL, factory()->empty_string());
+  return GetCode(kind(), Code::NORMAL, factory()->empty_string());
 }
 
 
 #undef __
 
 
-void StubCompiler::TailCallBuiltin(MacroAssembler* masm, Builtins::Name name) {
+void PropertyAccessCompiler::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::STORE_IC) {
-    registers_ = StoreStubCompiler::registers();
+Register* PropertyAccessCompiler::GetCallingConvention(Code::Kind kind) {
+  if (kind == Code::LOAD_IC || kind == Code::KEYED_LOAD_IC) {
+    return load_calling_convention();
+  } else if (kind == Code::STORE_IC) {
+    return store_calling_convention();
   } else {
-    registers_ = KeyedStoreStubCompiler::registers();
+    ASSERT_EQ(Code::KEYED_STORE_IC, kind);
+    return keyed_store_calling_convention();
   }
 }
 
 
-Handle<Code> BaseLoadStoreStubCompiler::GetICCode(Code::Kind kind,
-                                                  Code::StubType type,
-                                                  Handle<Name> name,
-                                                  InlineCacheState state) {
-  Code::Flags flags = Code::ComputeFlags(kind, state, extra_state(), type);
+Handle<Code> PropertyICCompiler::GetCode(Code::Kind kind, Code::StubType type,
+                                         Handle<Name> name,
+                                         InlineCacheState state) {
+  Code::Flags flags =
+      Code::ComputeFlags(kind, state, extra_state(), type, cache_holder());
   Handle<Code> code = GetCodeWithFlags(flags, name);
   IC::RegisterWeakMapDependency(code);
   PROFILE(isolate(), CodeCreateEvent(log_kind(code), *code, *name));
   return code;
 }
 
 
-Handle<Code> BaseLoadStoreStubCompiler::GetCode(Code::Kind kind,
-                                                Code::StubType type,
-                                                Handle<Name> name) {
+Handle<Code> PropertyHandlerCompiler::GetCode(Code::Kind kind,
+                                              Code::StubType type,
+                                              Handle<Name> name) {
   ASSERT_EQ(kNoExtraICState, extra_state());
-  Code::Flags flags = Code::ComputeHandlerFlags(kind, type, cache_holder_);
+  Code::Flags flags = Code::ComputeHandlerFlags(kind, type, cache_holder());
   Handle<Code> code = GetCodeWithFlags(flags, name);
-  PROFILE(isolate(), CodeCreateEvent(log_kind(code), *code, *name));
+  PROFILE(isolate(), CodeCreateEvent(Logger::STUB_TAG, *code, *name));
   return code;
 }
 
 
-void KeyedLoadStubCompiler::CompileElementHandlers(MapHandleList* receiver_maps,
-                                                   CodeHandleList* handlers) {
+void IndexedHandlerCompiler::CompileElementHandlers(
+    MapHandleList* receiver_maps, CodeHandleList* handlers) {
   for (int i = 0; i < receiver_maps->length(); ++i) {
     Handle<Map> receiver_map = receiver_maps->at(i);
     Handle<Code> cached_stub;
 
     if ((receiver_map->instance_type() & kNotStringTag) == 0) {
       cached_stub = isolate()->builtins()->KeyedLoadIC_String();
     } else if (receiver_map->instance_type() < FIRST_JS_RECEIVER_TYPE) {
       cached_stub = isolate()->builtins()->KeyedLoadIC_Slow();
     } else {
       bool is_js_array = receiver_map->instance_type() == JS_ARRAY_TYPE;
@@ skipping 13 matching lines @@
         cached_stub =
             KeyedLoadDictionaryElementStub(isolate()).GetCode();
       }
     }
 
     handlers->Add(cached_stub);
   }
 }
 
 
-Handle<Code> KeyedStoreStubCompiler::CompileStoreElementPolymorphic(
-    MapHandleList* receiver_maps) {
+Handle<Code> PropertyICCompiler::CompileIndexedStorePolymorphic(
+    MapHandleList* receiver_maps, KeyedAccessStoreMode store_mode) {
   // Collect MONOMORPHIC stubs for all |receiver_maps|.
   CodeHandleList handlers(receiver_maps->length());
   MapHandleList transitioned_maps(receiver_maps->length());
   for (int i = 0; i < receiver_maps->length(); ++i) {
     Handle<Map> receiver_map(receiver_maps->at(i));
     Handle<Code> cached_stub;
     Handle<Map> transitioned_map =
         receiver_map->FindTransitionedMap(receiver_maps);
 
     // TODO(mvstanton): The code below is doing pessimistic elements
     // transitions. I would like to stop doing that and rely on Allocation Site
     // Tracking to do a better job of ensuring the data types are what they need
     // to be. Not all the elements are in place yet, pessimistic elements
     // transitions are still important for performance.
     bool is_js_array = receiver_map->instance_type() == JS_ARRAY_TYPE;
     ElementsKind elements_kind = receiver_map->elements_kind();
     if (!transitioned_map.is_null()) {
-      cached_stub = ElementsTransitionAndStoreStub(
-          isolate(),
-          elements_kind,
-          transitioned_map->elements_kind(),
-          is_js_array,
-          store_mode()).GetCode();
+      cached_stub =
+          ElementsTransitionAndStoreStub(isolate(), elements_kind,
+                                         transitioned_map->elements_kind(),
+                                         is_js_array, store_mode).GetCode();
     } else if (receiver_map->instance_type() < FIRST_JS_RECEIVER_TYPE) {
       cached_stub = isolate()->builtins()->KeyedStoreIC_Slow();
     } else {
       if (receiver_map->has_fast_elements() ||
           receiver_map->has_external_array_elements() ||
           receiver_map->has_fixed_typed_array_elements()) {
-        cached_stub = KeyedStoreFastElementStub(
-            isolate(),
-            is_js_array,
-            elements_kind,
-            store_mode()).GetCode();
+        cached_stub =
+            KeyedStoreFastElementStub(isolate(), is_js_array, elements_kind,
+                                      store_mode).GetCode();
       } else {
-        cached_stub = KeyedStoreElementStub(
-            isolate(),
-            is_js_array,
-            elements_kind,
-            store_mode()).GetCode();
+        cached_stub =
+            KeyedStoreElementStub(isolate(), is_js_array, elements_kind,
+                                  store_mode).GetCode();
       }
     }
     ASSERT(!cached_stub.is_null());
     handlers.Add(cached_stub);
     transitioned_maps.Add(transitioned_map);
   }
-  Handle<Code> code =
-      CompileStorePolymorphic(receiver_maps, &handlers, &transitioned_maps);
+
+  Handle<Code> code = CompileIndexedStorePolymorphic(receiver_maps, &handlers,
+                                                     &transitioned_maps);
   isolate()->counters()->keyed_store_polymorphic_stubs()->Increment();
-  PROFILE(isolate(),
-          CodeCreateEvent(Logger::KEYED_STORE_POLYMORPHIC_IC_TAG, *code, 0));
+  PROFILE(isolate(), CodeCreateEvent(log_kind(code), *code, 0));
   return code;
 }
 
 
-void KeyedStoreStubCompiler::GenerateStoreDictionaryElement(
+void IndexedHandlerCompiler::GenerateStoreDictionaryElement(
     MacroAssembler* masm) {
   KeyedStoreIC::GenerateSlow(masm);
 }
 
 
 CallOptimization::CallOptimization(LookupResult* lookup) {
   if (lookup->IsFound() &&
       lookup->IsCacheable() &&
       lookup->IsConstantFunction()) {
     // We only optimize constant function calls.
@@ skipping 102 matching lines @@
           Handle<FunctionTemplateInfo>(
               FunctionTemplateInfo::cast(signature->receiver()));
     }
   }
 
   is_simple_api_call_ = true;
 }
 
 
 } }  // namespace v8::internal