From e9c4a498665dc998ff4b9d1f3b4c9733be9d4501 Mon Sep 17 00:00:00 2001 From: "verwaest@chromium.org" Date: Thu, 12 Sep 2013 22:04:04 +0000 Subject: [PATCH] Reland Handle non-JSObject heap objects using slow-path IC stub guarded by the map. R=mstarzinger@chromium.org Review URL: https://chromiumcodereview.appspot.com/23578030 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@16696 ce2b1a6d-e550-0410-aec6-3dcde31c8c00 --- src/builtins.h | 4 +-- src/hydrogen.cc | 24 ++++++++++---- src/hydrogen.h | 2 +- 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 ++--- 9 files changed, 123 insertions(+), 108 deletions(-) diff --git a/src/builtins.h b/src/builtins.h index fc97cd3..c712f1e 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, BUILTIN, UNINITIALIZED, \ + V(KeyedLoadIC_Slow, STUB, MONOMORPHIC, \ 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, LOAD_IC, GENERIC, \ + V(LoadIC_Slow, STUB, MONOMORPHIC, \ Code::kNoExtraICState) \ \ V(KeyedLoadIC_Initialize, KEYED_LOAD_IC, UNINITIALIZED, \ diff --git a/src/hydrogen.cc b/src/hydrogen.cc index 7b623b5..23c373f 100644 --- a/src/hydrogen.cc +++ b/src/hydrogen.cc @@ -4005,7 +4005,9 @@ void HOptimizedGraphBuilder::VisitRegExpLiteral(RegExpLiteral* expr) { static bool CanInlinePropertyAccess(Map* type) { - return !type->is_dictionary_map() && !type->has_named_interceptor(); + return type->IsJSObjectMap() && + !type->is_dictionary_map() && + !type->has_named_interceptor(); } @@ -5381,6 +5383,7 @@ HInstruction* HOptimizedGraphBuilder::BuildLoadNamedMonomorphic( map->LookupDescriptor(NULL, *name, &lookup); if (lookup.IsField()) { HCheckMaps* checked_object = AddCheckMap(object, map); + ASSERT(map->IsJSObjectMap()); return BuildLoadNamedField( checked_object, HObjectAccess::ForField(map, &lookup, name)); } @@ -5392,6 +5395,12 @@ 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()) { @@ -5484,6 +5493,7 @@ HInstruction* HOptimizedGraphBuilder::TryBuildConsolidatedElementLoad( Handle most_general_consolidated_map; for (int i = 0; i < maps->length(); ++i) { Handle map = maps->at(i); + if (!map->IsJSObjectMap()) return NULL; // Don't allow mixing of JSArrays with JSObjects. if (map->instance_type() == JS_ARRAY_TYPE) { if (has_non_js_array_access) return NULL; @@ -5536,7 +5546,7 @@ HValue* HOptimizedGraphBuilder::HandlePolymorphicElementAccess( HValue* object, HValue* key, HValue* val, - Expression* prop, + SmallMapList* maps, BailoutId ast_id, int position, bool is_store, @@ -5544,7 +5554,6 @@ HValue* HOptimizedGraphBuilder::HandlePolymorphicElementAccess( bool* has_side_effects) { *has_side_effects = false; BuildCheckHeapObject(object); - SmallMapList* maps = prop->GetReceiverTypes(); if (!is_store) { HInstruction* consolidated_load = @@ -5600,7 +5609,8 @@ HValue* HOptimizedGraphBuilder::HandlePolymorphicElementAccess( if (untransitionable_maps.length() == 1) { Handle untransitionable_map = untransitionable_maps[0]; HInstruction* instr = NULL; - if (untransitionable_map->has_slow_elements_kind()) { + if (untransitionable_map->has_slow_elements_kind() || + !untransitionable_map->IsJSObjectMap()) { instr = AddInstruction(is_store ? BuildStoreKeyedGeneric(object, key, val) : BuildLoadKeyedGeneric(object, key)); } else { @@ -5617,6 +5627,7 @@ HValue* HOptimizedGraphBuilder::HandlePolymorphicElementAccess( for (int i = 0; i < untransitionable_maps.length(); ++i) { Handle map = untransitionable_maps[i]; + if (!map->IsJSObjectMap()) continue; ElementsKind elements_kind = map->elements_kind(); HBasicBlock* this_map = graph()->CreateBasicBlock(); HBasicBlock* other_map = graph()->CreateBasicBlock(); @@ -5689,10 +5700,9 @@ HValue* HOptimizedGraphBuilder::HandleKeyedElementAccess( instr = BuildMonomorphicElementAccess( obj, key, val, NULL, map, is_store, expr->GetStoreMode()); } - } else if (expr->GetReceiverTypes() != NULL && - !expr->GetReceiverTypes()->is_empty()) { + } else if (types != NULL && !types->is_empty()) { return HandlePolymorphicElementAccess( - obj, key, val, expr, ast_id, position, is_store, + obj, key, val, types, ast_id, position, is_store, expr->GetStoreMode(), has_side_effects); } else { if (is_store) { diff --git a/src/hydrogen.h b/src/hydrogen.h index 979a350..c1dafa8 100644 --- a/src/hydrogen.h +++ b/src/hydrogen.h @@ -2008,7 +2008,7 @@ class HOptimizedGraphBuilder V8_FINAL HValue* HandlePolymorphicElementAccess(HValue* object, HValue* key, HValue* val, - Expression* prop, + SmallMapList* maps, BailoutId ast_id, int position, bool is_store, diff --git a/src/ic.cc b/src/ic.cc index 7211ad9..5518751 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->type() == Code::NORMAL) return set_target(*handler); + if (handler->is_load_stub()) 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->type() == Code::NORMAL) return set_target(*handler); + if (handler->is_keyed_load_stub()) 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->type() == Code::NORMAL) return set_target(*handler); + if (handler->is_store_stub()) 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->type() == Code::NORMAL) return set_target(*handler); + if (handler->is_keyed_store_stub()) 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,32 +1265,26 @@ void LoadIC::UpdateCaches(LookupResult* lookup, State state, Handle object, Handle name) { - // Bail out if the result is not cacheable. - if (!lookup->IsCacheable()) { - set_target(*generic_stub()); - return; - } + if (!object->IsHeapObject()) return; - // 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 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, receiver, name); - if (code.is_null()) { - set_target(*generic_stub()); - return; - } + code = ComputeLoadHandler(lookup, Handle::cast(receiver), name); + if (code.is_null()) code = slow_stub(); } PatchCache(state, kNonStrictMode, receiver, name, code); diff --git a/src/ic.h b/src/ic.h index 5c883cd..8f09e1d 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 generic_stub() const { + virtual Handle slow_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,9 +483,12 @@ 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); @@ -574,7 +577,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); @@ -689,7 +692,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 068d347..e37f6d1 100644 --- a/src/objects.cc +++ b/src/objects.cc @@ -4479,18 +4479,19 @@ void NormalizedMapCache::Clear() { } -void JSObject::UpdateMapCodeCache(Handle object, - Handle name, - Handle code) { +void HeapObject::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(!object->HasFastProperties()); + ASSERT(!receiver->HasFastProperties()); // Replace the map with an identical copy that can be safely modified. map = Map::CopyNormalized(map, KEEP_INOBJECT_PROPERTIES, UNIQUE_NORMALIZED_MAP); - object->GetIsolate()->counters()->normalized_maps()->Increment(); - object->set_map(*map); + receiver->GetIsolate()->counters()->normalized_maps()->Increment(); + receiver->set_map(*map); } Map::UpdateCodeCache(map, name, code); } diff --git a/src/objects.h b/src/objects.h index 71d395e..d3593b6 100644 --- a/src/objects.h +++ b/src/objects.h @@ -1758,6 +1758,13 @@ 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); @@ -2569,10 +2576,6 @@ 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, @@ -5923,6 +5926,10 @@ 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 fd2160e..7b23d0c 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 ic = FindIC(name, receiver, Code::LOAD_IC, handler->type()); + Handle map(receiver->map()); + Handle ic = FindIC(name, map, Code::LOAD_IC, handler->type()); if (!ic.is_null()) return ic; LoadStubCompiler ic_compiler(isolate()); - ic = ic_compiler.CompileMonomorphicIC( - Handle(receiver->map()), handler, name); + ic = ic_compiler.CompileMonomorphicIC(map, handler, name); - JSObject::UpdateMapCodeCache(receiver, name, ic); + HeapObject::UpdateMapCodeCache(receiver, name, ic); return ic; } -Handle StubCache::ComputeMonomorphicKeyedLoadIC(Handle receiver, - Handle handler, - Handle name) { - Handle ic = FindIC( - name, receiver, Code::KEYED_LOAD_IC, handler->type()); +Handle StubCache::ComputeMonomorphicKeyedLoadIC( + Handle receiver, + Handle handler, + Handle name) { + Handle map(receiver->map()); + Handle ic = FindIC(name, map, Code::KEYED_LOAD_IC, handler->type()); if (!ic.is_null()) return ic; KeyedLoadStubCompiler ic_compiler(isolate()); - ic = ic_compiler.CompileMonomorphicIC( - Handle(receiver->map()), handler, name); + ic = ic_compiler.CompileMonomorphicIC(map, handler, name); - JSObject::UpdateMapCodeCache(receiver, name, ic); + HeapObject::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, receiver, Code::STORE_IC, handler->type(), strict_mode); + name, map, Code::STORE_IC, handler->type(), strict_mode); if (!ic.is_null()) return ic; StoreStubCompiler ic_compiler(isolate(), strict_mode); - ic = ic_compiler.CompileMonomorphicIC( - Handle(receiver->map()), handler, name); + ic = ic_compiler.CompileMonomorphicIC(map, handler, name); - JSObject::UpdateMapCodeCache(receiver, name, ic); + HeapObject::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, receiver, Code::KEYED_STORE_IC, handler->type(), strict_mode); + name, map, 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( - Handle(receiver->map()), handler, name); + ic = ic_compiler.CompileMonomorphicIC(map, handler, name); - JSObject::UpdateMapCodeCache(receiver, name, ic); + HeapObject::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); - JSObject::UpdateMapCodeCache(receiver, cache_name, handler); + HeapObject::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); - JSObject::UpdateMapCodeCache(stub_holder, name, handler); + HeapObject::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); - JSObject::UpdateMapCodeCache(stub_holder, name, handler); + HeapObject::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); - JSObject::UpdateMapCodeCache(stub_holder, name, handler); + HeapObject::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); - JSObject::UpdateMapCodeCache(stub_holder, name, handler); + HeapObject::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); - JSObject::UpdateMapCodeCache(stub_holder, name, handler); + HeapObject::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); - JSObject::UpdateMapCodeCache(stub_holder, name, handler); + HeapObject::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); - JSObject::UpdateMapCodeCache(stub_holder, name, ic); + HeapObject::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); - JSObject::UpdateMapCodeCache(stub_holder, name, handler); + HeapObject::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); - JSObject::UpdateMapCodeCache(stub_holder, name, handler); + HeapObject::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); - JSObject::UpdateMapCodeCache(stub_holder, name, handler); + HeapObject::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); - JSObject::UpdateMapCodeCache(stub_holder, name, handler); + HeapObject::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); - JSObject::UpdateMapCodeCache(stub_holder, name, handler); + HeapObject::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); - JSObject::UpdateMapCodeCache(receiver, name, handler); + HeapObject::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); - JSObject::UpdateMapCodeCache(receiver, name, handler); + HeapObject::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); - JSObject::UpdateMapCodeCache(receiver, name, code); + HeapObject::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); - JSObject::UpdateMapCodeCache(receiver, name, handler); + HeapObject::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); - JSObject::UpdateMapCodeCache(receiver, name, handler); + HeapObject::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); - JSObject::UpdateMapCodeCache(receiver, name, handler); + HeapObject::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); - JSObject::UpdateMapCodeCache(receiver, name, handler); + HeapObject::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); - JSObject::UpdateMapCodeCache(receiver, name, handler); + HeapObject::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); - JSObject::UpdateMapCodeCache(receiver, name, handler); + HeapObject::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)) { - JSObject::UpdateMapCodeCache(stub_holder, name, code); + HeapObject::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)); - JSObject::UpdateMapCodeCache(stub_holder, name, code); + HeapObject::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)); - JSObject::UpdateMapCodeCache(stub_holder, name, code); + HeapObject::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)) { - JSObject::UpdateMapCodeCache(stub_holder, name, code); + HeapObject::UpdateMapCodeCache(stub_holder, name, code); } return code; } diff --git a/src/stub-cache.h b/src/stub-cache.h index c2ff18a..63cb42b 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