From ff412d8c376347f178fa4ae8651735c984d9ed23 Mon Sep 17 00:00:00 2001 From: "verwaest@chromium.org" Date: Thu, 12 Sep 2013 16:57:37 +0000 Subject: [PATCH] Revert "Handle non-JSObject heap objects using slow-path IC stub guarded by the map." TBR=mstarzinger@chromium.org Review URL: https://chromiumcodereview.appspot.com/23475039 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@16692 ce2b1a6d-e550-0410-aec6-3dcde31c8c00 --- src/builtins.h | 4 +-- src/hydrogen.cc | 10 +----- src/ic.cc | 48 +++++++++++++++------------ src/ic.h | 19 +++++------ src/objects.cc | 13 ++++---- src/objects.h | 15 +++------ src/stub-cache.cc | 98 +++++++++++++++++++++++++++---------------------------- src/stub-cache.h | 8 ++--- 8 files changed, 101 insertions(+), 114 deletions(-) diff --git a/src/builtins.h b/src/builtins.h index c712f1e..fc97cd3 100644 --- a/src/builtins.h +++ b/src/builtins.h @@ -120,7 +120,7 @@ enum BuiltinExtraArguments { Code::kNoExtraICState) \ V(KeyedLoadIC_MissForceGeneric, BUILTIN, UNINITIALIZED, \ Code::kNoExtraICState) \ - V(KeyedLoadIC_Slow, STUB, MONOMORPHIC, \ + V(KeyedLoadIC_Slow, BUILTIN, UNINITIALIZED, \ Code::kNoExtraICState) \ V(StoreIC_Miss, BUILTIN, UNINITIALIZED, \ Code::kNoExtraICState) \ @@ -142,7 +142,7 @@ enum BuiltinExtraArguments { Code::kNoExtraICState) \ V(LoadIC_Getter_ForDeopt, LOAD_IC, MONOMORPHIC, \ Code::kNoExtraICState) \ - V(LoadIC_Slow, STUB, MONOMORPHIC, \ + V(LoadIC_Slow, LOAD_IC, GENERIC, \ Code::kNoExtraICState) \ \ V(KeyedLoadIC_Initialize, KEYED_LOAD_IC, UNINITIALIZED, \ diff --git a/src/hydrogen.cc b/src/hydrogen.cc index 5270030..7b623b5 100644 --- a/src/hydrogen.cc +++ b/src/hydrogen.cc @@ -4005,9 +4005,7 @@ void HOptimizedGraphBuilder::VisitRegExpLiteral(RegExpLiteral* expr) { static bool CanInlinePropertyAccess(Map* type) { - return type->IsJSObjectMap() && - !type->is_dictionary_map() && - !type->has_named_interceptor(); + return !type->is_dictionary_map() && !type->has_named_interceptor(); } @@ -5394,12 +5392,6 @@ HInstruction* HOptimizedGraphBuilder::BuildLoadNamedMonomorphic( return New(constant); } - if (lookup.IsFound()) { - // Cannot handle the property, do a generic load instead. - HValue* context = environment()->context(); - return new(zone()) HLoadNamedGeneric(context, object, name); - } - // Handle a load from a known field somewhere in the prototype chain. LookupInPrototypes(map, name, &lookup); if (lookup.IsField()) { diff --git a/src/ic.cc b/src/ic.cc index 5518751..7211ad9 100644 --- a/src/ic.cc +++ b/src/ic.cc @@ -996,7 +996,7 @@ static bool AddOneReceiverMapIfMissing(MapHandleList* receiver_maps, bool IC::UpdatePolymorphicIC(State state, - Handle receiver, + Handle receiver, Handle name, Handle code, StrictModeFlag strict_mode) { @@ -1077,44 +1077,44 @@ Handle StoreIC::ComputePolymorphicIC(MapHandleList* receiver_maps, } -void LoadIC::UpdateMonomorphicIC(Handle receiver, +void LoadIC::UpdateMonomorphicIC(Handle receiver, Handle handler, Handle name, StrictModeFlag strict_mode) { - if (handler->is_load_stub()) return set_target(*handler); + if (handler->type() == Code::NORMAL) return set_target(*handler); Handle ic = isolate()->stub_cache()->ComputeMonomorphicLoadIC( receiver, handler, name); set_target(*ic); } -void KeyedLoadIC::UpdateMonomorphicIC(Handle receiver, +void KeyedLoadIC::UpdateMonomorphicIC(Handle receiver, Handle handler, Handle name, StrictModeFlag strict_mode) { - if (handler->is_keyed_load_stub()) return set_target(*handler); + if (handler->type() == Code::NORMAL) return set_target(*handler); Handle ic = isolate()->stub_cache()->ComputeMonomorphicKeyedLoadIC( receiver, handler, name); set_target(*ic); } -void StoreIC::UpdateMonomorphicIC(Handle receiver, +void StoreIC::UpdateMonomorphicIC(Handle receiver, Handle handler, Handle name, StrictModeFlag strict_mode) { - if (handler->is_store_stub()) return set_target(*handler); + if (handler->type() == Code::NORMAL) return set_target(*handler); Handle ic = isolate()->stub_cache()->ComputeMonomorphicStoreIC( receiver, handler, name, strict_mode); set_target(*ic); } -void KeyedStoreIC::UpdateMonomorphicIC(Handle receiver, +void KeyedStoreIC::UpdateMonomorphicIC(Handle receiver, Handle handler, Handle name, StrictModeFlag strict_mode) { - if (handler->is_keyed_store_stub()) return set_target(*handler); + if (handler->type() == Code::NORMAL) return set_target(*handler); Handle ic = isolate()->stub_cache()->ComputeMonomorphicKeyedStoreIC( receiver, handler, name, strict_mode); set_target(*ic); @@ -1155,7 +1155,7 @@ bool IC::IsTransitionedMapOfMonomorphicTarget(Map* receiver_map) { // not necessarily equal to target()->state(). void IC::PatchCache(State state, StrictModeFlag strict_mode, - Handle receiver, + Handle receiver, Handle name, Handle code) { switch (state) { @@ -1265,26 +1265,32 @@ void LoadIC::UpdateCaches(LookupResult* lookup, State state, Handle object, Handle name) { - if (!object->IsHeapObject()) return; + // Bail out if the result is not cacheable. + if (!lookup->IsCacheable()) { + set_target(*generic_stub()); + return; + } - Handle receiver = Handle::cast(object); + // TODO(jkummerow): It would be nice to support non-JSObjects in + // UpdateCaches, then we wouldn't need to go generic here. + if (!object->IsJSObject()) { + set_target(*generic_stub()); + return; + } + Handle receiver = Handle::cast(object); Handle code; if (state == UNINITIALIZED) { // This is the first time we execute this inline cache. // Set the target to the pre monomorphic stub to delay // setting the monomorphic state. code = pre_monomorphic_stub(); - } else if (!lookup->IsCacheable()) { - // Bail out if the result is not cacheable. - code = slow_stub(); - } else if (!object->IsJSObject()) { - // TODO(jkummerow): It would be nice to support non-JSObjects in - // ComputeLoadHandler, then we wouldn't need to go generic here. - code = slow_stub(); } else { - code = ComputeLoadHandler(lookup, Handle::cast(receiver), name); - if (code.is_null()) code = slow_stub(); + code = ComputeLoadHandler(lookup, receiver, name); + if (code.is_null()) { + set_target(*generic_stub()); + return; + } } PatchCache(state, kNonStrictMode, receiver, name, code); diff --git a/src/ic.h b/src/ic.h index 8f09e1d..5c883cd 100644 --- a/src/ic.h +++ b/src/ic.h @@ -167,14 +167,14 @@ class IC { static inline void SetTargetAtAddress(Address address, Code* target); static void PostPatching(Address address, Code* target, Code* old_target); - virtual void UpdateMonomorphicIC(Handle receiver, + virtual void UpdateMonomorphicIC(Handle receiver, Handle handler, Handle name, StrictModeFlag strict_mode) { set_target(*handler); } bool UpdatePolymorphicIC(State state, - Handle receiver, + Handle receiver, Handle name, Handle code, StrictModeFlag strict_mode); @@ -192,7 +192,7 @@ class IC { bool IsTransitionedMapOfMonomorphicTarget(Map* receiver_map); void PatchCache(State state, StrictModeFlag strict_mode, - Handle receiver, + Handle receiver, Handle name, Handle code); virtual void UpdateMegamorphicCache(Map* map, Name* name, Code* code); @@ -388,7 +388,7 @@ class LoadIC: public IC { protected: virtual Code::Kind kind() const { return Code::LOAD_IC; } - virtual Handle slow_stub() const { + virtual Handle generic_stub() const { return isolate()->builtins()->LoadIC_Slow(); } @@ -403,7 +403,7 @@ class LoadIC: public IC { Handle object, Handle name); - virtual void UpdateMonomorphicIC(Handle receiver, + virtual void UpdateMonomorphicIC(Handle receiver, Handle handler, Handle name, StrictModeFlag strict_mode); @@ -483,12 +483,9 @@ class KeyedLoadIC: public LoadIC { virtual Handle generic_stub() const { return isolate()->builtins()->KeyedLoadIC_Generic(); } - virtual Handle slow_stub() const { - return isolate()->builtins()->KeyedLoadIC_Slow(); - } // Update the inline cache. - virtual void UpdateMonomorphicIC(Handle receiver, + virtual void UpdateMonomorphicIC(Handle receiver, Handle handler, Handle name, StrictModeFlag strict_mode); @@ -577,7 +574,7 @@ class StoreIC: public IC { return isolate()->builtins()->StoreIC_GlobalProxy_Strict(); } - virtual void UpdateMonomorphicIC(Handle receiver, + virtual void UpdateMonomorphicIC(Handle receiver, Handle handler, Handle name, StrictModeFlag strict_mode); @@ -692,7 +689,7 @@ class KeyedStoreIC: public StoreIC { KeyedAccessStoreMode store_mode, StrictModeFlag strict_mode); - virtual void UpdateMonomorphicIC(Handle receiver, + virtual void UpdateMonomorphicIC(Handle receiver, Handle handler, Handle name, StrictModeFlag strict_mode); diff --git a/src/objects.cc b/src/objects.cc index e37f6d1..068d347 100644 --- a/src/objects.cc +++ b/src/objects.cc @@ -4479,19 +4479,18 @@ void NormalizedMapCache::Clear() { } -void HeapObject::UpdateMapCodeCache(Handle object, - Handle name, - Handle code) { +void JSObject::UpdateMapCodeCache(Handle object, + Handle name, + Handle code) { Handle map(object->map()); if (map->is_shared()) { - Handle receiver = Handle::cast(object); // Fast case maps are never marked as shared. - ASSERT(!receiver->HasFastProperties()); + ASSERT(!object->HasFastProperties()); // Replace the map with an identical copy that can be safely modified. map = Map::CopyNormalized(map, KEEP_INOBJECT_PROPERTIES, UNIQUE_NORMALIZED_MAP); - receiver->GetIsolate()->counters()->normalized_maps()->Increment(); - receiver->set_map(*map); + object->GetIsolate()->counters()->normalized_maps()->Increment(); + object->set_map(*map); } Map::UpdateCodeCache(map, name, code); } diff --git a/src/objects.h b/src/objects.h index 74820c2..1e324e6 100644 --- a/src/objects.h +++ b/src/objects.h @@ -1756,13 +1756,6 @@ class HeapObject: public Object { // during marking GC. static inline Object** RawField(HeapObject* obj, int offset); - // Adds the |code| object related to |name| to the code cache of this map. If - // this map is a dictionary map that is shared, the map copied and installed - // onto the object. - static void UpdateMapCodeCache(Handle object, - Handle name, - Handle code); - // Casting. static inline HeapObject* cast(Object* obj); @@ -2574,6 +2567,10 @@ class JSObject: public JSReceiver { MUST_USE_RESULT MaybeObject* NormalizeElements(); + static void UpdateMapCodeCache(Handle object, + Handle name, + Handle code); + // Transform slow named properties to fast variants. // Returns failure if allocation failed. static void TransformToFastProperties(Handle object, @@ -5924,10 +5921,6 @@ class Map: public HeapObject { return instance_type() >= FIRST_JS_OBJECT_TYPE; } - bool IsJSObjectMap() { - return instance_type() >= FIRST_JS_OBJECT_TYPE; - } - // Fires when the layout of an object with a leaf map changes. // This includes adding transitions to the leaf map or changing // the descriptor array. diff --git a/src/stub-cache.cc b/src/stub-cache.cc index 7b23d0c..fd2160e 100644 --- a/src/stub-cache.cc +++ b/src/stub-cache.cc @@ -166,68 +166,68 @@ Handle StubCache::FindStoreHandler(Handle name, } -Handle StubCache::ComputeMonomorphicLoadIC(Handle receiver, +Handle StubCache::ComputeMonomorphicLoadIC(Handle receiver, Handle handler, Handle name) { - Handle map(receiver->map()); - Handle ic = FindIC(name, map, Code::LOAD_IC, handler->type()); + Handle ic = FindIC(name, receiver, Code::LOAD_IC, handler->type()); if (!ic.is_null()) return ic; LoadStubCompiler ic_compiler(isolate()); - ic = ic_compiler.CompileMonomorphicIC(map, handler, name); + ic = ic_compiler.CompileMonomorphicIC( + Handle(receiver->map()), handler, name); - HeapObject::UpdateMapCodeCache(receiver, name, ic); + JSObject::UpdateMapCodeCache(receiver, name, ic); return ic; } -Handle StubCache::ComputeMonomorphicKeyedLoadIC( - Handle receiver, - Handle handler, - Handle name) { - Handle map(receiver->map()); - Handle ic = FindIC(name, map, Code::KEYED_LOAD_IC, handler->type()); +Handle StubCache::ComputeMonomorphicKeyedLoadIC(Handle receiver, + Handle handler, + Handle name) { + Handle ic = FindIC( + name, receiver, Code::KEYED_LOAD_IC, handler->type()); if (!ic.is_null()) return ic; KeyedLoadStubCompiler ic_compiler(isolate()); - ic = ic_compiler.CompileMonomorphicIC(map, handler, name); + ic = ic_compiler.CompileMonomorphicIC( + Handle(receiver->map()), handler, name); - HeapObject::UpdateMapCodeCache(receiver, name, ic); + JSObject::UpdateMapCodeCache(receiver, name, ic); return ic; } -Handle StubCache::ComputeMonomorphicStoreIC(Handle receiver, +Handle StubCache::ComputeMonomorphicStoreIC(Handle receiver, Handle handler, Handle name, StrictModeFlag strict_mode) { - Handle map(receiver->map()); Handle ic = FindIC( - name, map, Code::STORE_IC, handler->type(), strict_mode); + name, receiver, Code::STORE_IC, handler->type(), strict_mode); if (!ic.is_null()) return ic; StoreStubCompiler ic_compiler(isolate(), strict_mode); - ic = ic_compiler.CompileMonomorphicIC(map, handler, name); + ic = ic_compiler.CompileMonomorphicIC( + Handle(receiver->map()), handler, name); - HeapObject::UpdateMapCodeCache(receiver, name, ic); + JSObject::UpdateMapCodeCache(receiver, name, ic); return ic; } Handle StubCache::ComputeMonomorphicKeyedStoreIC( - Handle receiver, + Handle receiver, Handle handler, Handle name, StrictModeFlag strict_mode) { - Handle map(receiver->map()); Handle ic = FindIC( - name, map, Code::KEYED_STORE_IC, handler->type(), strict_mode); + name, receiver, Code::KEYED_STORE_IC, handler->type(), strict_mode); if (!ic.is_null()) return ic; KeyedStoreStubCompiler ic_compiler(isolate(), strict_mode, STANDARD_STORE); - ic = ic_compiler.CompileMonomorphicIC(map, handler, name); + ic = ic_compiler.CompileMonomorphicIC( + Handle(receiver->map()), handler, name); - HeapObject::UpdateMapCodeCache(receiver, name, ic); + JSObject::UpdateMapCodeCache(receiver, name, ic); return ic; } @@ -264,7 +264,7 @@ Handle StubCache::ComputeLoadNonexistent(Handle name, LoadStubCompiler compiler(isolate_); handler = compiler.CompileLoadNonexistent(receiver, current, cache_name, global); - HeapObject::UpdateMapCodeCache(receiver, cache_name, handler); + JSObject::UpdateMapCodeCache(receiver, cache_name, handler); return handler; } @@ -289,7 +289,7 @@ Handle StubCache::ComputeLoadField(Handle name, LoadStubCompiler compiler(isolate_); Handle handler = compiler.CompileLoadField(receiver, holder, name, field, representation); - HeapObject::UpdateMapCodeCache(stub_holder, name, handler); + JSObject::UpdateMapCodeCache(stub_holder, name, handler); return handler; } @@ -308,7 +308,7 @@ Handle StubCache::ComputeLoadCallback( LoadStubCompiler compiler(isolate_); Handle handler = compiler.CompileLoadCallback(receiver, holder, name, callback); - HeapObject::UpdateMapCodeCache(stub_holder, name, handler); + JSObject::UpdateMapCodeCache(stub_holder, name, handler); return handler; } @@ -326,7 +326,7 @@ Handle StubCache::ComputeLoadCallback( LoadStubCompiler compiler(isolate_); Handle handler = compiler.CompileLoadCallback(receiver, holder, name, call_optimization); - HeapObject::UpdateMapCodeCache(stub_holder, name, handler); + JSObject::UpdateMapCodeCache(stub_holder, name, handler); return handler; } @@ -343,7 +343,7 @@ Handle StubCache::ComputeLoadViaGetter(Handle name, LoadStubCompiler compiler(isolate_); Handle handler = compiler.CompileLoadViaGetter(receiver, holder, name, getter); - HeapObject::UpdateMapCodeCache(stub_holder, name, handler); + JSObject::UpdateMapCodeCache(stub_holder, name, handler); return handler; } @@ -359,7 +359,7 @@ Handle StubCache::ComputeLoadConstant(Handle name, LoadStubCompiler compiler(isolate_); handler = compiler.CompileLoadConstant(receiver, holder, name, value); - HeapObject::UpdateMapCodeCache(stub_holder, name, handler); + JSObject::UpdateMapCodeCache(stub_holder, name, handler); return handler; } @@ -376,7 +376,7 @@ Handle StubCache::ComputeLoadInterceptor(Handle name, LoadStubCompiler compiler(isolate_); Handle handler = compiler.CompileLoadInterceptor(receiver, holder, name); - HeapObject::UpdateMapCodeCache(stub_holder, name, handler); + JSObject::UpdateMapCodeCache(stub_holder, name, handler); return handler; } @@ -399,7 +399,7 @@ Handle StubCache::ComputeLoadGlobal(Handle name, LoadStubCompiler compiler(isolate_); Handle ic = compiler.CompileLoadGlobal(receiver, holder, cell, name, is_dont_delete); - HeapObject::UpdateMapCodeCache(stub_holder, name, ic); + JSObject::UpdateMapCodeCache(stub_holder, name, ic); return ic; } @@ -425,7 +425,7 @@ Handle StubCache::ComputeKeyedLoadField(Handle name, KeyedLoadStubCompiler compiler(isolate_); Handle handler = compiler.CompileLoadField(receiver, holder, name, field, representation); - HeapObject::UpdateMapCodeCache(stub_holder, name, handler); + JSObject::UpdateMapCodeCache(stub_holder, name, handler); return handler; } @@ -442,7 +442,7 @@ Handle StubCache::ComputeKeyedLoadConstant(Handle name, KeyedLoadStubCompiler compiler(isolate_); handler = compiler.CompileLoadConstant(receiver, holder, name, value); - HeapObject::UpdateMapCodeCache(stub_holder, name, handler); + JSObject::UpdateMapCodeCache(stub_holder, name, handler); return handler; } @@ -458,7 +458,7 @@ Handle StubCache::ComputeKeyedLoadInterceptor(Handle name, KeyedLoadStubCompiler compiler(isolate_); Handle handler = compiler.CompileLoadInterceptor(receiver, holder, name); - HeapObject::UpdateMapCodeCache(stub_holder, name, handler); + JSObject::UpdateMapCodeCache(stub_holder, name, handler); return handler; } @@ -476,7 +476,7 @@ Handle StubCache::ComputeKeyedLoadCallback( KeyedLoadStubCompiler compiler(isolate_); Handle handler = compiler.CompileLoadCallback(receiver, holder, name, callback); - HeapObject::UpdateMapCodeCache(stub_holder, name, handler); + JSObject::UpdateMapCodeCache(stub_holder, name, handler); return handler; } @@ -494,7 +494,7 @@ Handle StubCache::ComputeKeyedLoadCallback( KeyedLoadStubCompiler compiler(isolate_); Handle handler = compiler.CompileLoadCallback(receiver, holder, name, call_optimization); - HeapObject::UpdateMapCodeCache(stub_holder, name, handler); + JSObject::UpdateMapCodeCache(stub_holder, name, handler); return handler; } @@ -509,7 +509,7 @@ Handle StubCache::ComputeStoreField(Handle name, StoreStubCompiler compiler(isolate_, strict_mode); Handle handler = compiler.CompileStoreField(receiver, lookup, name); - HeapObject::UpdateMapCodeCache(receiver, name, handler); + JSObject::UpdateMapCodeCache(receiver, name, handler); return handler; } @@ -526,7 +526,7 @@ Handle StubCache::ComputeStoreTransition(Handle name, StoreStubCompiler compiler(isolate_, strict_mode); Handle handler = compiler.CompileStoreTransition(receiver, lookup, transition, name); - HeapObject::UpdateMapCodeCache(receiver, name, handler); + JSObject::UpdateMapCodeCache(receiver, name, handler); return handler; } @@ -606,7 +606,7 @@ Handle StubCache::ComputeStoreGlobal(Handle name, Handle cell_map(isolate_->heap()->global_property_cell_map()); code->ReplaceNthObject(1, *cell_map, *cell); - HeapObject::UpdateMapCodeCache(receiver, name, code); + JSObject::UpdateMapCodeCache(receiver, name, code); return code; } @@ -626,7 +626,7 @@ Handle StubCache::ComputeStoreCallback( StoreStubCompiler compiler(isolate_, strict_mode); Handle handler = compiler.CompileStoreCallback( receiver, holder, name, callback); - HeapObject::UpdateMapCodeCache(receiver, name, handler); + JSObject::UpdateMapCodeCache(receiver, name, handler); return handler; } @@ -644,7 +644,7 @@ Handle StubCache::ComputeStoreCallback( StoreStubCompiler compiler(isolate_, strict_mode); Handle handler = compiler.CompileStoreCallback( receiver, holder, name, call_optimization); - HeapObject::UpdateMapCodeCache(receiver, name, handler); + JSObject::UpdateMapCodeCache(receiver, name, handler); return handler; } @@ -661,7 +661,7 @@ Handle StubCache::ComputeStoreViaSetter(Handle name, StoreStubCompiler compiler(isolate_, strict_mode); Handle handler = compiler.CompileStoreViaSetter( receiver, holder, name, setter); - HeapObject::UpdateMapCodeCache(receiver, name, handler); + JSObject::UpdateMapCodeCache(receiver, name, handler); return handler; } @@ -675,7 +675,7 @@ Handle StubCache::ComputeStoreInterceptor(Handle name, StoreStubCompiler compiler(isolate_, strict_mode); Handle handler = compiler.CompileStoreInterceptor(receiver, name); - HeapObject::UpdateMapCodeCache(receiver, name, handler); + JSObject::UpdateMapCodeCache(receiver, name, handler); return handler; } @@ -690,7 +690,7 @@ Handle StubCache::ComputeKeyedStoreField(Handle name, KeyedStoreStubCompiler compiler(isolate(), strict_mode, STANDARD_STORE); Handle handler = compiler.CompileStoreField(receiver, lookup, name); - HeapObject::UpdateMapCodeCache(receiver, name, handler); + JSObject::UpdateMapCodeCache(receiver, name, handler); return handler; } @@ -708,7 +708,7 @@ Handle StubCache::ComputeKeyedStoreTransition( KeyedStoreStubCompiler compiler(isolate(), strict_mode, STANDARD_STORE); Handle handler = compiler.CompileStoreTransition(receiver, lookup, transition, name); - HeapObject::UpdateMapCodeCache(receiver, name, handler); + JSObject::UpdateMapCodeCache(receiver, name, handler); return handler; } @@ -765,7 +765,7 @@ Handle StubCache::ComputeCallConstant(int argc, GDBJIT(AddCode(GDBJITInterface::CALL_IC, *name, *code)); if (CallStubCompiler::CanBeCached(function)) { - HeapObject::UpdateMapCodeCache(stub_holder, name, code); + JSObject::UpdateMapCodeCache(stub_holder, name, code); } return code; } @@ -806,7 +806,7 @@ Handle StubCache::ComputeCallField(int argc, PROFILE(isolate_, CodeCreateEvent(CALL_LOGGER_TAG(kind, CALL_IC_TAG), *code, *name)); GDBJIT(AddCode(GDBJITInterface::CALL_IC, *name, *code)); - HeapObject::UpdateMapCodeCache(stub_holder, name, code); + JSObject::UpdateMapCodeCache(stub_holder, name, code); return code; } @@ -845,7 +845,7 @@ Handle StubCache::ComputeCallInterceptor(int argc, PROFILE(isolate(), CodeCreateEvent(CALL_LOGGER_TAG(kind, CALL_IC_TAG), *code, *name)); GDBJIT(AddCode(GDBJITInterface::CALL_IC, *name, *code)); - HeapObject::UpdateMapCodeCache(stub_holder, name, code); + JSObject::UpdateMapCodeCache(stub_holder, name, code); return code; } @@ -876,7 +876,7 @@ Handle StubCache::ComputeCallGlobal(int argc, CodeCreateEvent(CALL_LOGGER_TAG(kind, CALL_IC_TAG), *code, *name)); GDBJIT(AddCode(GDBJITInterface::CALL_IC, *name, *code)); if (CallStubCompiler::CanBeCached(function)) { - HeapObject::UpdateMapCodeCache(stub_holder, name, code); + JSObject::UpdateMapCodeCache(stub_holder, name, code); } return code; } diff --git a/src/stub-cache.h b/src/stub-cache.h index 63cb42b..c2ff18a 100644 --- a/src/stub-cache.h +++ b/src/stub-cache.h @@ -104,20 +104,20 @@ class StubCache { Code::StubType type, StrictModeFlag strict_mode); - Handle ComputeMonomorphicLoadIC(Handle receiver, + Handle ComputeMonomorphicLoadIC(Handle receiver, Handle handler, Handle name); - Handle ComputeMonomorphicKeyedLoadIC(Handle receiver, + Handle ComputeMonomorphicKeyedLoadIC(Handle receiver, Handle handler, Handle name); - Handle ComputeMonomorphicStoreIC(Handle receiver, + Handle ComputeMonomorphicStoreIC(Handle receiver, Handle handler, Handle name, StrictModeFlag strict_mode); - Handle ComputeMonomorphicKeyedStoreIC(Handle receiver, + Handle ComputeMonomorphicKeyedStoreIC(Handle receiver, Handle handler, Handle name, StrictModeFlag strict_mode); -- 2.7.4