From e08fbabe15b304e05d947e778aff7c5b1d8c3c4d Mon Sep 17 00:00:00 2001 From: "verwaest@chromium.org" Date: Fri, 11 Oct 2013 13:54:14 +0000 Subject: [PATCH] Unify ComputeLoad/StoreHandler and dispatch on compile. BUG= R=ulan@chromium.org Review URL: https://chromiumcodereview.appspot.com/26831002 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@17162 ce2b1a6d-e550-0410-aec6-3dcde31c8c00 --- src/ic.cc | 74 ++++++++++++++++++++++++--------------------------------------- src/ic.h | 60 ++++++++++++++++++++++++++++++--------------------- 2 files changed, 64 insertions(+), 70 deletions(-) diff --git a/src/ic.cc b/src/ic.cc index 52578c5..80cd033 100644 --- a/src/ic.cc +++ b/src/ic.cc @@ -1137,8 +1137,13 @@ void LoadIC::UpdateCaches(LookupResult* lookup, // 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 if (!lookup->IsProperty()) { + code = kind() == Code::LOAD_IC + ? isolate()->stub_cache()->ComputeLoadNonexistent( + name, Handle::cast(receiver)) + : slow_stub(); } else { - code = ComputeLoadHandler(lookup, Handle::cast(receiver), name); + code = ComputeHandler(lookup, Handle::cast(receiver), name); } PatchCache(receiver, name, code); @@ -1153,20 +1158,15 @@ void IC::UpdateMegamorphicCache(Map* map, Name* name, Code* code) { } -Handle LoadIC::ComputeLoadHandler(LookupResult* lookup, - Handle receiver, - Handle name) { - if (!lookup->IsProperty()) { - return kind() == Code::LOAD_IC - ? isolate()->stub_cache()->ComputeLoadNonexistent(name, receiver) - : generic_stub(); - } - +Handle IC::ComputeHandler(LookupResult* lookup, + Handle receiver, + Handle name, + Handle value) { Handle code = isolate()->stub_cache()->FindHandler( name, receiver, kind()); if (!code.is_null()) return code; - code = CompileLoadHandler(lookup, receiver, name); + code = CompileHandler(lookup, receiver, name, value); if (code.is_null()) return slow_stub(); if (code->is_handler() && code->type() != Code::NORMAL) { @@ -1177,9 +1177,10 @@ Handle LoadIC::ComputeLoadHandler(LookupResult* lookup, } -Handle LoadIC::CompileLoadHandler(LookupResult* lookup, - Handle receiver, - Handle name) { +Handle LoadIC::CompileHandler(LookupResult* lookup, + Handle receiver, + Handle name, + Handle unused) { Handle holder(lookup->holder()); switch (lookup->type()) { case FIELD: @@ -1390,9 +1391,10 @@ MaybeObject* KeyedLoadIC::Load(Handle object, } -Handle KeyedLoadIC::CompileLoadHandler(LookupResult* lookup, - Handle receiver, - Handle name) { +Handle KeyedLoadIC::CompileHandler(LookupResult* lookup, + Handle receiver, + Handle name, + Handle value) { // Compute a monomorphic stub. Handle holder(lookup->holder(), isolate()); switch (lookup->type()) { @@ -1633,37 +1635,17 @@ void StoreIC::UpdateCaches(LookupResult* lookup, // These are not cacheable, so we never see such LookupResults here. ASSERT(!lookup->IsHandler()); - Handle code = ComputeStoreHandler(lookup, receiver, name, value); - if (code.is_null()) code = slow_stub(); + Handle code = ComputeHandler(lookup, receiver, name, value); PatchCache(receiver, name, code); TRACE_IC("StoreIC", name); } -Handle StoreIC::ComputeStoreHandler(LookupResult* lookup, - Handle receiver, - Handle name, - Handle value) { - Handle code = isolate()->stub_cache()->FindHandler( - name, receiver, kind(), strict_mode()); - if (!code.is_null()) return code; - - code = CompileStoreHandler(lookup, receiver, name, value); - if (code.is_null()) return generic_stub(); - - if (code->is_handler() && code->type() != Code::NORMAL) { - HeapObject::UpdateMapCodeCache(receiver, name, code); - } - - return code; -} - - -Handle StoreIC::CompileStoreHandler(LookupResult* lookup, - Handle receiver, - Handle name, - Handle value) { +Handle StoreIC::CompileHandler(LookupResult* lookup, + Handle receiver, + Handle name, + Handle value) { Handle holder(lookup->holder()); switch (lookup->type()) { case FIELD: @@ -2052,10 +2034,10 @@ MaybeObject* KeyedStoreIC::Store(Handle object, } -Handle KeyedStoreIC::CompileStoreHandler(LookupResult* lookup, - Handle receiver, - Handle name, - Handle value) { +Handle KeyedStoreIC::CompileHandler(LookupResult* lookup, + Handle receiver, + Handle name, + Handle value) { // If the property has a non-field type allowing map transitions // where there is extra room in the object, we leave the IC in its // current state. diff --git a/src/ic.h b/src/ic.h index 7e40131..eff9b54 100644 --- a/src/ic.h +++ b/src/ic.h @@ -173,6 +173,18 @@ class IC { static inline void SetTargetAtAddress(Address address, Code* target); static void PostPatching(Address address, Code* target, Code* old_target); + // Compute the handler either by compiling or by retrieving a cached version. + Handle ComputeHandler(LookupResult* lookup, + Handle receiver, + Handle name, + Handle value = Handle::null()); + virtual Handle CompileHandler(LookupResult* lookup, + Handle receiver, + Handle name, + Handle value) { + UNREACHABLE(); + return Handle::null(); + } void UpdateMonomorphicIC(Handle receiver, Handle handler, Handle name); @@ -187,6 +199,14 @@ class IC { Handle name, Handle code); virtual void UpdateMegamorphicCache(Map* map, Name* name, Code* code); + virtual Code::Kind kind() const { + UNREACHABLE(); + return Code::STUB; + } + virtual Handle slow_stub() const { + UNREACHABLE(); + return Handle::null(); + } virtual Handle megamorphic_stub() { UNREACHABLE(); return Handle::null(); @@ -395,12 +415,10 @@ class LoadIC: public IC { Handle object, Handle name); - Handle ComputeLoadHandler(LookupResult* lookup, - Handle receiver, - Handle name); - virtual Handle CompileLoadHandler(LookupResult* lookup, - Handle receiver, - Handle name); + virtual Handle CompileHandler(LookupResult* lookup, + Handle receiver, + Handle name, + Handle unused); private: // Stub accessors. @@ -475,9 +493,10 @@ class KeyedLoadIC: public LoadIC { return isolate()->builtins()->KeyedLoadIC_Slow(); } - virtual Handle CompileLoadHandler(LookupResult* lookup, - Handle receiver, - Handle name); + virtual Handle CompileHandler(LookupResult* lookup, + Handle receiver, + Handle name, + Handle unused); virtual void UpdateMegamorphicCache(Map* map, Name* name, Code* code) { } private: @@ -590,17 +609,10 @@ class StoreIC: public IC { Handle receiver, Handle name, Handle value); - // Compute the code stub for this store; used for rewriting to - // monomorphic state and making sure that the code stub is in the - // stub cache. - Handle ComputeStoreHandler(LookupResult* lookup, - Handle receiver, - Handle name, - Handle value); - virtual Handle CompileStoreHandler(LookupResult* lookup, - Handle receiver, - Handle name, - Handle value); + virtual Handle CompileHandler(LookupResult* lookup, + Handle receiver, + Handle name, + Handle value); private: void set_target(Code* code) { @@ -668,10 +680,10 @@ class KeyedStoreIC: public StoreIC { protected: virtual Code::Kind kind() const { return Code::KEYED_STORE_IC; } - virtual Handle CompileStoreHandler(LookupResult* lookup, - Handle receiver, - Handle name, - Handle value); + virtual Handle CompileHandler(LookupResult* lookup, + Handle receiver, + Handle name, + Handle value); virtual void UpdateMegamorphicCache(Map* map, Name* name, Code* code) { } virtual Handle pre_monomorphic_stub() { -- 2.7.4