From 45a65d870d790b9e3fbb7315e332d7e16a8f841a Mon Sep 17 00:00:00 2001 From: "mstarzinger@chromium.org" Date: Wed, 11 Sep 2013 15:44:09 +0000 Subject: [PATCH] Unify computation of load stubs in stub cache. R=verwaest@chromium.org Review URL: https://codereview.chromium.org/23647011 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@16660 ce2b1a6d-e550-0410-aec6-3dcde31c8c00 --- src/ic.cc | 33 +++++------ src/stub-cache.cc | 164 ++++++++++++------------------------------------------ src/stub-cache.h | 137 ++++++++++++++++++++------------------------- 3 files changed, 114 insertions(+), 220 deletions(-) diff --git a/src/ic.cc b/src/ic.cc index 7211ad9..b98ac51 100644 --- a/src/ic.cc +++ b/src/ic.cc @@ -1318,7 +1318,7 @@ Handle LoadIC::ComputeLoadHandler(LookupResult* lookup, switch (lookup->type()) { case FIELD: return isolate()->stub_cache()->ComputeLoadField( - name, receiver, holder, + name, receiver, holder, Code::LOAD_IC, lookup->GetFieldIndex(), lookup->representation()); case CONSTANT: { Handle constant(lookup->GetConstant(), isolate()); @@ -1326,7 +1326,7 @@ Handle LoadIC::ComputeLoadHandler(LookupResult* lookup, // be embedded into code. if (constant->IsConsString()) return Handle::null(); return isolate()->stub_cache()->ComputeLoadConstant( - name, receiver, holder, constant); + name, receiver, holder, Code::LOAD_IC, constant); } case NORMAL: if (holder->IsGlobalObject()) { @@ -1350,7 +1350,7 @@ Handle LoadIC::ComputeLoadHandler(LookupResult* lookup, if (v8::ToCData
(info->getter()) == 0) break; if (!info->IsCompatibleReceiver(*receiver)) break; return isolate()->stub_cache()->ComputeLoadCallback( - name, receiver, holder, info); + name, receiver, holder, Code::LOAD_IC, info); } else if (callback->IsAccessorPair()) { Handle getter(Handle::cast(callback)->getter(), isolate()); @@ -1363,7 +1363,7 @@ Handle LoadIC::ComputeLoadHandler(LookupResult* lookup, call_optimization.IsCompatibleReceiver(*receiver) && FLAG_js_accessor_ics) { return isolate()->stub_cache()->ComputeLoadCallback( - name, receiver, holder, call_optimization); + name, receiver, holder, Code::LOAD_IC, call_optimization); } return isolate()->stub_cache()->ComputeLoadViaGetter( name, receiver, holder, function); @@ -1372,7 +1372,8 @@ Handle LoadIC::ComputeLoadHandler(LookupResult* lookup, PropertyIndex lengthIndex = PropertyIndex::NewHeaderIndex(JSArray::kLengthOffset / kPointerSize); return isolate()->stub_cache()->ComputeLoadField( - name, receiver, holder, lengthIndex, Representation::Tagged()); + name, receiver, holder, Code::LOAD_IC, + lengthIndex, Representation::Tagged()); } // TODO(dcarney): Handle correctly. if (callback->IsDeclaredAccessorInfo()) break; @@ -1383,7 +1384,7 @@ Handle LoadIC::ComputeLoadHandler(LookupResult* lookup, case INTERCEPTOR: ASSERT(HasInterceptorGetter(*holder)); return isolate()->stub_cache()->ComputeLoadInterceptor( - name, receiver, holder); + name, receiver, holder, Code::LOAD_IC); default: break; } @@ -1538,16 +1539,16 @@ Handle KeyedLoadIC::ComputeLoadHandler(LookupResult* lookup, Handle holder(lookup->holder(), isolate()); switch (lookup->type()) { case FIELD: - return isolate()->stub_cache()->ComputeKeyedLoadField( - name, receiver, holder, + return isolate()->stub_cache()->ComputeLoadField( + name, receiver, holder, Code::KEYED_LOAD_IC, lookup->GetFieldIndex(), lookup->representation()); case CONSTANT: { Handle constant(lookup->GetConstant(), isolate()); // TODO(2803): Don't compute a stub for cons strings because they cannot // be embedded into code. if (constant->IsConsString()) return Handle::null(); - return isolate()->stub_cache()->ComputeKeyedLoadConstant( - name, receiver, holder, constant); + return isolate()->stub_cache()->ComputeLoadConstant( + name, receiver, holder, Code::KEYED_LOAD_IC, constant); } case CALLBACKS: { Handle callback_object(lookup->GetCallbackObject(), isolate()); @@ -1557,8 +1558,8 @@ Handle KeyedLoadIC::ComputeLoadHandler(LookupResult* lookup, Handle::cast(callback_object); if (v8::ToCData
(callback->getter()) == 0) break; if (!callback->IsCompatibleReceiver(*receiver)) break; - return isolate()->stub_cache()->ComputeKeyedLoadCallback( - name, receiver, holder, callback); + return isolate()->stub_cache()->ComputeLoadCallback( + name, receiver, holder, Code::KEYED_LOAD_IC, callback); } else if (callback_object->IsAccessorPair()) { Handle getter( Handle::cast(callback_object)->getter(), @@ -1571,16 +1572,16 @@ Handle KeyedLoadIC::ComputeLoadHandler(LookupResult* lookup, if (call_optimization.is_simple_api_call() && call_optimization.IsCompatibleReceiver(*receiver) && FLAG_js_accessor_ics) { - return isolate()->stub_cache()->ComputeKeyedLoadCallback( - name, receiver, holder, call_optimization); + return isolate()->stub_cache()->ComputeLoadCallback( + name, receiver, holder, Code::KEYED_LOAD_IC, call_optimization); } } break; } case INTERCEPTOR: ASSERT(HasInterceptorGetter(lookup->holder())); - return isolate()->stub_cache()->ComputeKeyedLoadInterceptor( - name, receiver, holder); + return isolate()->stub_cache()->ComputeLoadInterceptor( + name, receiver, holder, Code::KEYED_LOAD_IC); default: // Always rewrite to the generic case so that we do not // repeatedly try to rewrite. diff --git a/src/stub-cache.cc b/src/stub-cache.cc index bdfb32f..ac5ee55 100644 --- a/src/stub-cache.cc +++ b/src/stub-cache.cc @@ -272,21 +272,29 @@ Handle StubCache::ComputeLoadNonexistent(Handle name, Handle StubCache::ComputeLoadField(Handle name, Handle receiver, Handle holder, + Code::Kind kind, PropertyIndex field, Representation representation) { if (receiver.is_identical_to(holder)) { - LoadFieldStub stub(field.is_inobject(holder), - field.translate(holder), - representation); - return stub.GetCode(isolate()); + if (kind == Code::LOAD_IC) { + LoadFieldStub stub(field.is_inobject(holder), + field.translate(holder), + representation); + return stub.GetCode(isolate()); + } else { + KeyedLoadFieldStub stub(field.is_inobject(holder), + field.translate(holder), + representation); + return stub.GetCode(isolate()); + } } Handle stub_holder = StubHolder(receiver, holder); Handle stub = FindLoadHandler( - name, receiver, stub_holder, Code::LOAD_IC, Code::FIELD); + name, receiver, stub_holder, kind, Code::FIELD); if (!stub.is_null()) return stub; - LoadStubCompiler compiler(isolate_); + BaseLoadStubCompiler compiler(isolate_, kind); Handle handler = compiler.CompileLoadField(receiver, holder, name, field, representation); JSObject::UpdateMapCodeCache(stub_holder, name, handler); @@ -298,14 +306,15 @@ Handle StubCache::ComputeLoadCallback( Handle name, Handle receiver, Handle holder, + Code::Kind kind, Handle callback) { ASSERT(v8::ToCData
(callback->getter()) != 0); Handle stub_holder = StubHolder(receiver, holder); Handle stub = FindLoadHandler( - name, receiver, stub_holder, Code::LOAD_IC, Code::CALLBACKS); + name, receiver, stub_holder, kind, Code::CALLBACKS); if (!stub.is_null()) return stub; - LoadStubCompiler compiler(isolate_); + BaseLoadStubCompiler compiler(isolate_, kind); Handle handler = compiler.CompileLoadCallback(receiver, holder, name, callback); JSObject::UpdateMapCodeCache(stub_holder, name, handler); @@ -317,13 +326,14 @@ Handle StubCache::ComputeLoadCallback( Handle name, Handle receiver, Handle holder, + Code::Kind kind, const CallOptimization& call_optimization) { Handle stub_holder = StubHolder(receiver, holder); Handle stub = FindLoadHandler( - name, receiver, stub_holder, Code::LOAD_IC, Code::CALLBACKS); + name, receiver, stub_holder, kind, Code::CALLBACKS); if (!stub.is_null()) return stub; - LoadStubCompiler compiler(isolate_); + BaseLoadStubCompiler compiler(isolate_, kind); Handle handler = compiler.CompileLoadCallback(receiver, holder, name, call_optimization); JSObject::UpdateMapCodeCache(stub_holder, name, handler); @@ -351,29 +361,30 @@ Handle StubCache::ComputeLoadViaGetter(Handle name, Handle StubCache::ComputeLoadConstant(Handle name, Handle receiver, Handle holder, + Code::Kind kind, Handle value) { Handle stub_holder = StubHolder(receiver, holder); Handle handler = FindLoadHandler( - name, receiver, stub_holder, Code::LOAD_IC, Code::CONSTANT); + name, receiver, stub_holder, kind, Code::CONSTANT); if (!handler.is_null()) return handler; - LoadStubCompiler compiler(isolate_); + BaseLoadStubCompiler compiler(isolate_, kind); handler = compiler.CompileLoadConstant(receiver, holder, name, value); JSObject::UpdateMapCodeCache(stub_holder, name, handler); - return handler; } Handle StubCache::ComputeLoadInterceptor(Handle name, Handle receiver, - Handle holder) { + Handle holder, + Code::Kind kind) { Handle stub_holder = StubHolder(receiver, holder); Handle stub = FindLoadHandler( - name, receiver, stub_holder, Code::LOAD_IC, Code::INTERCEPTOR); + name, receiver, stub_holder, kind, Code::INTERCEPTOR); if (!stub.is_null()) return stub; - LoadStubCompiler compiler(isolate_); + BaseLoadStubCompiler compiler(isolate_, kind); Handle handler = compiler.CompileLoadInterceptor(receiver, holder, name); JSObject::UpdateMapCodeCache(stub_holder, name, handler); @@ -404,101 +415,6 @@ Handle StubCache::ComputeLoadGlobal(Handle name, } -Handle StubCache::ComputeKeyedLoadField(Handle name, - Handle receiver, - Handle holder, - PropertyIndex field, - Representation representation) { - if (receiver.is_identical_to(holder)) { - // TODO(titzer): this should use an HObjectAccess - KeyedLoadFieldStub stub(field.is_inobject(holder), - field.translate(holder), - representation); - return stub.GetCode(isolate()); - } - - Handle stub_holder = StubHolder(receiver, holder); - Handle stub = FindLoadHandler( - name, receiver, stub_holder, Code::KEYED_LOAD_IC, Code::FIELD); - if (!stub.is_null()) return stub; - - KeyedLoadStubCompiler compiler(isolate_); - Handle handler = - compiler.CompileLoadField(receiver, holder, name, field, representation); - JSObject::UpdateMapCodeCache(stub_holder, name, handler); - return handler; -} - - -Handle StubCache::ComputeKeyedLoadConstant(Handle name, - Handle receiver, - Handle holder, - Handle value) { - Handle stub_holder = StubHolder(receiver, holder); - Handle handler = FindLoadHandler( - name, receiver, stub_holder, Code::KEYED_LOAD_IC, - Code::CONSTANT); - if (!handler.is_null()) return handler; - - KeyedLoadStubCompiler compiler(isolate_); - handler = compiler.CompileLoadConstant(receiver, holder, name, value); - JSObject::UpdateMapCodeCache(stub_holder, name, handler); - return handler; -} - - -Handle StubCache::ComputeKeyedLoadInterceptor(Handle name, - Handle receiver, - Handle holder) { - Handle stub_holder = StubHolder(receiver, holder); - Handle stub = FindLoadHandler( - name, receiver, stub_holder, Code::KEYED_LOAD_IC, Code::INTERCEPTOR); - if (!stub.is_null()) return stub; - - KeyedLoadStubCompiler compiler(isolate_); - Handle handler = - compiler.CompileLoadInterceptor(receiver, holder, name); - JSObject::UpdateMapCodeCache(stub_holder, name, handler); - return handler; -} - - -Handle StubCache::ComputeKeyedLoadCallback( - Handle name, - Handle receiver, - Handle holder, - Handle callback) { - Handle stub_holder = StubHolder(receiver, holder); - Handle stub = FindLoadHandler( - name, receiver, stub_holder, Code::KEYED_LOAD_IC, Code::CALLBACKS); - if (!stub.is_null()) return stub; - - KeyedLoadStubCompiler compiler(isolate_); - Handle handler = - compiler.CompileLoadCallback(receiver, holder, name, callback); - JSObject::UpdateMapCodeCache(stub_holder, name, handler); - return handler; -} - - -Handle StubCache::ComputeKeyedLoadCallback( - Handle name, - Handle receiver, - Handle holder, - const CallOptimization& call_optimization) { - Handle stub_holder = StubHolder(receiver, holder); - Handle stub = FindLoadHandler( - name, receiver, stub_holder, Code::KEYED_LOAD_IC, Code::CALLBACKS); - if (!stub.is_null()) return stub; - - KeyedLoadStubCompiler compiler(isolate_); - Handle handler = - compiler.CompileLoadCallback(receiver, holder, name, call_optimization); - JSObject::UpdateMapCodeCache(stub_holder, name, handler); - return handler; -} - - Handle StubCache::ComputeStoreField(Handle name, Handle receiver, LookupResult* lookup, @@ -1957,23 +1873,15 @@ void StubCompiler::TailCallBuiltin(MacroAssembler* masm, Builtins::Name name) { } -void LoadStubCompiler::JitEvent(Handle name, Handle code) { - GDBJIT(AddCode(GDBJITInterface::LOAD_IC, *name, *code)); -} - - -void KeyedLoadStubCompiler::JitEvent(Handle name, Handle code) { - GDBJIT(AddCode(GDBJITInterface::KEYED_LOAD_IC, *name, *code)); -} - - -void StoreStubCompiler::JitEvent(Handle name, Handle code) { - GDBJIT(AddCode(GDBJITInterface::STORE_IC, *name, *code)); -} - - -void KeyedStoreStubCompiler::JitEvent(Handle name, Handle code) { - GDBJIT(AddCode(GDBJITInterface::KEYED_STORE_IC, *name, *code)); +Register* BaseLoadStoreStubCompiler::GetRegisters(Code::Kind kind) { + switch (kind) { + case Code::LOAD_IC: return LoadStubCompiler::registers(); + case Code::STORE_IC: return StoreStubCompiler::registers(); + case Code::KEYED_LOAD_IC: return KeyedLoadStubCompiler::registers(); + case Code::KEYED_STORE_IC: return KeyedStoreStubCompiler::registers(); + default: UNREACHABLE(); + } + return NULL; } diff --git a/src/stub-cache.h b/src/stub-cache.h index 141e567..4d1ccf3 100644 --- a/src/stub-cache.h +++ b/src/stub-cache.h @@ -130,17 +130,20 @@ class StubCache { Handle ComputeLoadField(Handle name, Handle object, Handle holder, + Code::Kind kind, PropertyIndex field_index, Representation representation); Handle ComputeLoadCallback(Handle name, Handle object, Handle holder, + Code::Kind kind, Handle callback); Handle ComputeLoadCallback(Handle name, Handle object, Handle holder, + Code::Kind kind, const CallOptimization& call_optimization); Handle ComputeLoadViaGetter(Handle name, @@ -151,11 +154,13 @@ class StubCache { Handle ComputeLoadConstant(Handle name, Handle object, Handle holder, + Code::Kind kind, Handle value); Handle ComputeLoadInterceptor(Handle name, Handle object, - Handle holder); + Handle holder, + Code::Kind kind); Handle ComputeLoadNormal(Handle name, Handle object); @@ -168,35 +173,6 @@ class StubCache { // --- - Handle ComputeKeyedLoadField(Handle name, - Handle object, - Handle holder, - PropertyIndex field_index, - Representation representation); - - Handle ComputeKeyedLoadCallback( - Handle name, - Handle object, - Handle holder, - Handle callback); - - Handle ComputeKeyedLoadCallback( - Handle name, - Handle object, - Handle holder, - const CallOptimization& call_optimization); - - Handle ComputeKeyedLoadConstant(Handle name, - Handle object, - Handle holder, - Handle value); - - Handle ComputeKeyedLoadInterceptor(Handle name, - Handle object, - Handle holder); - - // --- - Handle ComputeStoreField(Handle name, Handle object, LookupResult* lookup, @@ -642,8 +618,10 @@ enum FrontendCheckType { PERFORM_INITIAL_CHECKS, SKIP_INITIAL_CHECKS }; class BaseLoadStoreStubCompiler: public StubCompiler { public: - BaseLoadStoreStubCompiler(Isolate* isolate, Register* registers) - : StubCompiler(isolate), registers_(registers) { } + BaseLoadStoreStubCompiler(Isolate* isolate, + Code::Kind kind, + Register* registers) + : StubCompiler(isolate), kind_(kind), registers_(registers) { } virtual ~BaseLoadStoreStubCompiler() { } Handle CompileMonomorphicIC(Handle receiver_map, @@ -671,6 +649,17 @@ class BaseLoadStoreStubCompiler: public StubCompiler { return Builtins::kLoadIC_Miss; } + static GDBJITInterface::CodeTag GetGDBJITCodeTag(Code::Kind kind) { + switch (kind) { + case Code::LOAD_IC: return GDBJITInterface::LOAD_IC; + case Code::STORE_IC: return GDBJITInterface::STORE_IC; + case Code::KEYED_LOAD_IC: return GDBJITInterface::KEYED_LOAD_IC; + case Code::KEYED_STORE_IC: return GDBJITInterface::KEYED_STORE_IC; + default: UNREACHABLE(); + } + return static_cast(0); + } + protected: virtual Register HandlerFrontendHeader(Handle object, Register object_reg, @@ -693,24 +682,48 @@ class BaseLoadStoreStubCompiler: public StubCompiler { Handle name, InlineCacheState state = MONOMORPHIC); + virtual Logger::LogEventsAndTags log_kind(Handle code) { + if (!code->is_inline_cache_stub()) return Logger::STUB_TAG; + switch (kind()) { + case Code::LOAD_IC: return code->ic_state() == MONOMORPHIC + ? Logger::LOAD_IC_TAG : Logger::LOAD_POLYMORPHIC_IC_TAG; + case Code::STORE_IC: return code->ic_state() == MONOMORPHIC + ? Logger::STORE_IC_TAG : Logger::STORE_POLYMORPHIC_IC_TAG; + case Code::KEYED_LOAD_IC: return code->ic_state() == MONOMORPHIC + ? Logger::KEYED_LOAD_IC_TAG : Logger::KEYED_LOAD_POLYMORPHIC_IC_TAG; + case Code::KEYED_STORE_IC: return code->ic_state() == MONOMORPHIC + ? Logger::KEYED_STORE_IC_TAG : Logger::KEYED_STORE_POLYMORPHIC_IC_TAG; + default: UNREACHABLE(); + } + return static_cast(0); + } + + void JitEvent(Handle name, Handle code) { + GDBJIT(AddCode(GetGDBJITCodeTag(kind()), *name, *code)); + } + + Code::Kind kind() const { return kind_; } + virtual Code::ExtraICState extra_state() { return Code::kNoExtraICState; } - virtual Logger::LogEventsAndTags log_kind(Handle code) = 0; - virtual void JitEvent(Handle name, Handle code) = 0; - virtual Code::Kind kind() = 0; virtual Register receiver() = 0; virtual Register name() = 0; virtual Register scratch1() = 0; virtual Register scratch2() = 0; virtual Register scratch3() = 0; + static Register* GetRegisters(Code::Kind kind); + + Code::Kind kind_; Register* registers_; }; class BaseLoadStubCompiler: public BaseLoadStoreStubCompiler { public: - BaseLoadStubCompiler(Isolate* isolate, Register* registers) - : BaseLoadStoreStubCompiler(isolate, registers) { } + BaseLoadStubCompiler(Isolate* isolate, Code::Kind kind) + : BaseLoadStoreStubCompiler(isolate, kind, GetRegisters(kind)) { } + BaseLoadStubCompiler(Isolate* isolate, Code::Kind kind, Register* registers) + : BaseLoadStoreStubCompiler(isolate, kind, registers) { } virtual ~BaseLoadStubCompiler() { } Handle CompileLoadField(Handle object, @@ -795,7 +808,7 @@ class BaseLoadStubCompiler: public BaseLoadStoreStubCompiler { class LoadStubCompiler: public BaseLoadStubCompiler { public: explicit LoadStubCompiler(Isolate* isolate) - : BaseLoadStubCompiler(isolate, registers()) { } + : BaseLoadStubCompiler(isolate, Code::LOAD_IC, registers()) { } Handle CompileLoadNonexistent(Handle object, Handle last, @@ -816,22 +829,14 @@ class LoadStubCompiler: public BaseLoadStubCompiler { Handle name, bool is_dont_delete); - private: static Register* registers(); - virtual Code::Kind kind() { return Code::LOAD_IC; } - virtual Logger::LogEventsAndTags log_kind(Handle code) { - if (!code->is_inline_cache_stub()) return Logger::STUB_TAG; - return code->ic_state() == MONOMORPHIC - ? Logger::LOAD_IC_TAG : Logger::LOAD_POLYMORPHIC_IC_TAG; - } - virtual void JitEvent(Handle name, Handle code); }; class KeyedLoadStubCompiler: public BaseLoadStubCompiler { public: explicit KeyedLoadStubCompiler(Isolate* isolate) - : BaseLoadStubCompiler(isolate, registers()) { } + : BaseLoadStubCompiler(isolate, Code::KEYED_LOAD_IC, registers()) { } Handle CompileLoadElement(Handle receiver_map); @@ -840,15 +845,9 @@ class KeyedLoadStubCompiler: public BaseLoadStubCompiler { static void GenerateLoadDictionaryElement(MacroAssembler* masm); - private: static Register* registers(); - virtual Code::Kind kind() { return Code::KEYED_LOAD_IC; } - virtual Logger::LogEventsAndTags log_kind(Handle code) { - if (!code->is_inline_cache_stub()) return Logger::STUB_TAG; - return code->ic_state() == MONOMORPHIC - ? Logger::KEYED_LOAD_IC_TAG : Logger::KEYED_LOAD_POLYMORPHIC_IC_TAG; - } - virtual void JitEvent(Handle name, Handle code); + + private: virtual void GenerateNameCheck(Handle name, Register name_reg, Label* miss); @@ -858,9 +857,9 @@ class KeyedLoadStubCompiler: public BaseLoadStubCompiler { class BaseStoreStubCompiler: public BaseLoadStoreStubCompiler { public: BaseStoreStubCompiler(Isolate* isolate, - StrictModeFlag strict_mode, - Register* registers) - : BaseLoadStoreStubCompiler(isolate, registers), + Code::Kind kind, + StrictModeFlag strict_mode) + : BaseLoadStoreStubCompiler(isolate, kind, GetRegisters(kind)), strict_mode_(strict_mode) { } virtual ~BaseStoreStubCompiler() { } @@ -958,7 +957,7 @@ class BaseStoreStubCompiler: public BaseLoadStoreStubCompiler { class StoreStubCompiler: public BaseStoreStubCompiler { public: StoreStubCompiler(Isolate* isolate, StrictModeFlag strict_mode) - : BaseStoreStubCompiler(isolate, strict_mode, registers()) { } + : BaseStoreStubCompiler(isolate, Code::STORE_IC, strict_mode) { } Handle CompileStoreCallback(Handle object, @@ -982,15 +981,7 @@ class StoreStubCompiler: public BaseStoreStubCompiler { Handle CompileStoreInterceptor(Handle object, Handle name); - private: static Register* registers(); - virtual Code::Kind kind() { return Code::STORE_IC; } - virtual Logger::LogEventsAndTags log_kind(Handle code) { - if (!code->is_inline_cache_stub()) return Logger::STUB_TAG; - return code->ic_state() == MONOMORPHIC - ? Logger::STORE_IC_TAG : Logger::STORE_POLYMORPHIC_IC_TAG; - } - virtual void JitEvent(Handle name, Handle code); }; @@ -999,7 +990,7 @@ class KeyedStoreStubCompiler: public BaseStoreStubCompiler { KeyedStoreStubCompiler(Isolate* isolate, StrictModeFlag strict_mode, KeyedAccessStoreMode store_mode) - : BaseStoreStubCompiler(isolate, strict_mode, registers()), + : BaseStoreStubCompiler(isolate, Code::KEYED_STORE_IC, strict_mode), store_mode_(store_mode) { } Handle CompileStoreElement(Handle receiver_map); @@ -1012,6 +1003,8 @@ class KeyedStoreStubCompiler: public BaseStoreStubCompiler { static void GenerateStoreDictionaryElement(MacroAssembler* masm); + static Register* registers(); + protected: virtual Code::ExtraICState extra_state() { return Code::ComputeExtraICState(store_mode_, strict_mode()); @@ -1022,14 +1015,6 @@ class KeyedStoreStubCompiler: public BaseStoreStubCompiler { return registers()[3]; } - static Register* registers(); - virtual Code::Kind kind() { return Code::KEYED_STORE_IC; } - virtual Logger::LogEventsAndTags log_kind(Handle code) { - if (!code->is_inline_cache_stub()) return Logger::STUB_TAG; - return code->ic_state() == MONOMORPHIC - ? Logger::KEYED_STORE_IC_TAG : Logger::KEYED_STORE_POLYMORPHIC_IC_TAG; - } - virtual void JitEvent(Handle name, Handle code); virtual void GenerateNameCheck(Handle name, Register name_reg, Label* miss); -- 2.7.4