Revision: 17046
Author: [email protected]
Date: Tue Oct 1 13:17:04 2013 UTC
Log: Encapsulate extra_ic_state in CallICs.
[email protected]
Review URL: https://chromiumcodereview.appspot.com/25263002
http://code.google.com/p/v8/source/detail?r=17046
Modified:
/branches/bleeding_edge/src/ic-inl.h
/branches/bleeding_edge/src/ic.cc
/branches/bleeding_edge/src/ic.h
/branches/bleeding_edge/src/stub-cache.cc
/branches/bleeding_edge/src/stub-cache.h
=======================================
--- /branches/bleeding_edge/src/ic-inl.h Thu Sep 5 11:27:22 2013 UTC
+++ /branches/bleeding_edge/src/ic-inl.h Tue Oct 1 13:17:04 2013 UTC
@@ -102,31 +102,13 @@
InlineCacheHolderFlag IC::GetCodeCacheForObject(Object* object,
JSObject* holder) {
- if (object->IsJSObject()) {
- return GetCodeCacheForObject(JSObject::cast(object), holder);
- }
+ if (object->IsJSObject()) return OWN_MAP;
+
// If the object is a value, we use the prototype map for the cache.
ASSERT(object->IsString() || object->IsSymbol() ||
object->IsNumber() || object->IsBoolean());
return PROTOTYPE_MAP;
}
-
-
-InlineCacheHolderFlag IC::GetCodeCacheForObject(JSObject* object,
- JSObject* holder) {
- // Fast-properties and global objects store stubs in their own maps.
- // Slow properties objects use prototype's map (unless the property is
its own
- // when holder == object). It works because slow properties objects
having
- // the same prototype (or a prototype with the same map) and not having
- // the property are interchangeable for such a stub.
- if (holder != object &&
- !object->HasFastProperties() &&
- !object->IsJSGlobalProxy() &&
- !object->IsJSGlobalObject()) {
- return PROTOTYPE_MAP;
- }
- return OWN_MAP;
-}
JSObject* IC::GetCodeCacheHolder(Isolate* isolate,
=======================================
--- /branches/bleeding_edge/src/ic.cc Tue Oct 1 09:55:15 2013 UTC
+++ /branches/bleeding_edge/src/ic.cc Tue Oct 1 13:17:04 2013 UTC
@@ -192,15 +192,18 @@
InlineCacheHolderFlag cache_holder =
Code::ExtractCacheHolderFromFlags(target()->flags());
- if (cache_holder == OWN_MAP && !receiver->IsJSObject()) {
- // The stub was generated for JSObject but called for non-JSObject.
- // IC::GetCodeCacheHolder is not applicable.
- return false;
- } else if (cache_holder == PROTOTYPE_MAP &&
- receiver->GetPrototype(isolate())->IsNull()) {
- // IC::GetCodeCacheHolder is not applicable.
- return false;
+ switch (cache_holder) {
+ case OWN_MAP:
+ // The stub was generated for JSObject but called for non-JSObject.
+ // IC::GetCodeCacheHolder is not applicable.
+ if (!receiver->IsJSObject()) return false;
+ break;
+ case PROTOTYPE_MAP:
+ // IC::GetCodeCacheHolder is not applicable.
+ if (receiver->GetPrototype(isolate())->IsNull()) return false;
+ break;
}
+
Map* map = IC::GetCodeCacheHolder(isolate(), receiver,
cache_holder)->map();
// Decide whether the inline cache failed because of changes to the
@@ -449,6 +452,11 @@
static bool HasInterceptorGetter(JSObject* object) {
return !object->GetNamedInterceptor()->getter()->IsUndefined();
}
+
+
+static bool HasInterceptorSetter(JSObject* object) {
+ return !object->GetNamedInterceptor()->setter()->IsUndefined();
+}
static void LookupForRead(Handle<Object> object,
@@ -531,8 +539,7 @@
}
-MaybeObject* CallICBase::LoadFunction(Code::ExtraICState extra_ic_state,
- Handle<Object> object,
+MaybeObject* CallICBase::LoadFunction(Handle<Object> object,
Handle<String> name) {
bool use_ic = FLAG_use_ic;
if (object->IsJSObject()) {
@@ -577,7 +584,7 @@
}
// Lookup is valid: Update inline cache and stub cache.
- if (use_ic) UpdateCaches(&lookup, extra_ic_state, object, name);
+ if (use_ic) UpdateCaches(&lookup, object, name);
// Get the property.
PropertyAttributes attr;
@@ -622,10 +629,8 @@
}
-bool CallICBase::TryUpdateExtraICState(LookupResult* lookup,
- Handle<Object> object,
- Code::ExtraICState* extra_ic_state)
{
- ASSERT(kind_ == Code::CALL_IC);
+bool CallIC::TryUpdateExtraICState(LookupResult* lookup,
+ Handle<Object> object) {
if (!lookup->IsConstantFunction()) return false;
JSFunction* function = lookup->GetConstantFunction();
if (!function->shared()->HasBuiltinFunctionId()) return false;
@@ -647,12 +652,12 @@
ASSERT(string == args[0] || string ==
JSValue::cast(args[0])->value());
// If we're in the default (fastest) state and the index is
// out of bounds, update the state to record this fact.
- if (StringStubState::decode(*extra_ic_state) ==
DEFAULT_STRING_STUB &&
+ if (StringStubState::decode(extra_ic_state()) ==
DEFAULT_STRING_STUB &&
argc >= 1 && args[1]->IsNumber()) {
double index = DoubleToInteger(args.number_at(1));
if (index < 0 || index >= string->length()) {
- *extra_ic_state =
- StringStubState::update(*extra_ic_state,
+ extra_ic_state_ =
+ StringStubState::update(extra_ic_state(),
STRING_INDEX_OUT_OF_BOUNDS);
return true;
}
@@ -722,7 +727,6 @@
void CallICBase::UpdateCaches(LookupResult* lookup,
- Code::ExtraICState extra_ic_state,
Handle<Object> object,
Handle<String> name) {
// Bail out if we didn't find a result.
@@ -736,20 +740,20 @@
// Set the target to the pre monomorphic stub to delay
// setting the monomorphic state.
code = isolate()->stub_cache()->ComputeCallPreMonomorphic(
- argc, kind_, extra_ic_state);
+ argc, kind_, extra_ic_state());
} else if (state() == MONOMORPHIC) {
if (kind_ == Code::CALL_IC &&
- TryUpdateExtraICState(lookup, object, &extra_ic_state)) {
- code = ComputeMonomorphicStub(lookup, extra_ic_state, object, name);
+ static_cast<CallIC*>(this)->TryUpdateExtraICState(lookup, object))
{
+ code = ComputeMonomorphicStub(lookup, extra_ic_state(), object,
name);
} else if (TryRemoveInvalidPrototypeDependentStub(*object, *name)) {
MarkMonomorphicPrototypeFailure();
- code = ComputeMonomorphicStub(lookup, extra_ic_state, object, name);
+ code = ComputeMonomorphicStub(lookup, extra_ic_state(), object,
name);
} else {
code = isolate()->stub_cache()->ComputeCallMegamorphic(
- argc, kind_, extra_ic_state);
+ argc, kind_, extra_ic_state());
}
} else {
- code = ComputeMonomorphicStub(lookup, extra_ic_state, object, name);
+ code = ComputeMonomorphicStub(lookup, extra_ic_state(), object, name);
}
// If there's no appropriate stub we simply avoid updating the caches.
@@ -789,9 +793,7 @@
MaybeObject* KeyedCallIC::LoadFunction(Handle<Object> object,
Handle<Object> key) {
if (key->IsInternalizedString()) {
- return CallICBase::LoadFunction(Code::kNoExtraICState,
- object,
- Handle<String>::cast(key));
+ return CallICBase::LoadFunction(object, Handle<String>::cast(key));
}
bool use_ic = FLAG_use_ic && !object->IsAccessCheckNeeded();
@@ -1469,8 +1471,7 @@
if (lookup->IsReadOnly() || !lookup->IsCacheable()) return false;
if (lookup->holder() == *receiver) {
- if (lookup->IsInterceptor() &&
- receiver->GetNamedInterceptor()->setter()->IsUndefined()) {
+ if (lookup->IsInterceptor() && !HasInterceptorSetter(*receiver)) {
receiver->LocalLookupRealNamedProperty(*name, lookup);
return lookup->IsFound() &&
!lookup->IsReadOnly() &&
@@ -1651,7 +1652,7 @@
// These are not cacheable, so we never see such LookupResults here.
ASSERT(!lookup->IsHandler());
- Handle<Code> code = ComputeStoreMonomorphic(lookup, receiver, name,
value);
+ Handle<Code> code = ComputeStoreHandler(lookup, receiver, name, value);
if (code.is_null()) {
set_target(*generic_stub());
return;
@@ -1662,10 +1663,10 @@
}
-Handle<Code> StoreIC::ComputeStoreMonomorphic(LookupResult* lookup,
- Handle<JSObject> receiver,
- Handle<String> name,
- Handle<Object> value) {
+Handle<Code> StoreIC::ComputeStoreHandler(LookupResult* lookup,
+ Handle<JSObject> receiver,
+ Handle<String> name,
+ Handle<Object> value) {
Handle<JSObject> holder(lookup->holder());
switch (lookup->type()) {
case FIELD:
@@ -1718,7 +1719,7 @@
break;
}
case INTERCEPTOR:
- ASSERT(!receiver->GetNamedInterceptor()->setter()->IsUndefined());
+ ASSERT(HasInterceptorSetter(*receiver));
return isolate()->stub_cache()->ComputeStoreInterceptor(
name, receiver, strict_mode());
case CONSTANT:
@@ -2051,10 +2052,10 @@
}
-Handle<Code> KeyedStoreIC::ComputeStoreMonomorphic(LookupResult* lookup,
- Handle<JSObject>
receiver,
- Handle<String> name,
- Handle<Object> value) {
+Handle<Code> KeyedStoreIC::ComputeStoreHandler(LookupResult* lookup,
+ Handle<JSObject> receiver,
+ Handle<String> name,
+ Handle<Object> 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.
@@ -2107,9 +2108,7 @@
ASSERT(args.length() == 2);
CallIC ic(isolate);
ic.UpdateState(args[0], args[1]);
- Code::ExtraICState extra_ic_state = ic.target()->extra_ic_state();
- MaybeObject* maybe_result = ic.LoadFunction(extra_ic_state,
- args.at<Object>(0),
+ MaybeObject* maybe_result = ic.LoadFunction(args.at<Object>(0),
args.at<String>(1));
JSFunction* raw_function;
if (!maybe_result->To(&raw_function)) return maybe_result;
@@ -2313,11 +2312,10 @@
HandleScope scope(isolate);
ASSERT(args.length() == 3);
StoreIC ic(IC::NO_EXTRA_FRAME, isolate);
- Code::ExtraICState extra_ic_state = ic.target()->extra_ic_state();
Handle<Object> object = args.at<Object>(0);
Handle<Object> key = args.at<Object>(1);
Handle<Object> value = args.at<Object>(2);
- StrictModeFlag strict_mode = Code::GetStrictMode(extra_ic_state);
+ StrictModeFlag strict_mode = ic.strict_mode();
return Runtime::SetObjectProperty(isolate,
object,
key,
@@ -2331,11 +2329,10 @@
HandleScope scope(isolate);
ASSERT(args.length() == 3);
KeyedStoreIC ic(IC::NO_EXTRA_FRAME, isolate);
- Code::ExtraICState extra_ic_state = ic.target()->extra_ic_state();
Handle<Object> object = args.at<Object>(0);
Handle<Object> key = args.at<Object>(1);
Handle<Object> value = args.at<Object>(2);
- StrictModeFlag strict_mode = Code::GetStrictMode(extra_ic_state);
+ StrictModeFlag strict_mode = ic.strict_mode();
return Runtime::SetObjectProperty(isolate,
object,
key,
@@ -2361,11 +2358,10 @@
HandleScope scope(isolate);
ASSERT(args.length() == 4);
KeyedStoreIC ic(IC::EXTRA_CALL_FRAME, isolate);
- Code::ExtraICState extra_ic_state = ic.target()->extra_ic_state();
Handle<Object> value = args.at<Object>(0);
Handle<Object> key = args.at<Object>(2);
Handle<Object> object = args.at<Object>(3);
- StrictModeFlag strict_mode = Code::GetStrictMode(extra_ic_state);
+ StrictModeFlag strict_mode = ic.strict_mode();
return Runtime::SetObjectProperty(isolate,
object,
key,
=======================================
--- /branches/bleeding_edge/src/ic.h Tue Oct 1 09:55:15 2013 UTC
+++ /branches/bleeding_edge/src/ic.h Tue Oct 1 13:17:04 2013 UTC
@@ -134,8 +134,6 @@
// These methods should not be called with undefined or null.
static inline InlineCacheHolderFlag GetCodeCacheForObject(Object* object,
JSObject*
holder);
- static inline InlineCacheHolderFlag GetCodeCacheForObject(JSObject*
object,
- JSObject*
holder);
static inline JSObject* GetCodeCacheHolder(Isolate* isolate,
Object* object,
InlineCacheHolderFlag holder);
@@ -244,17 +242,14 @@
class StringStubState: public BitField<StringStubFeedback, 1, 1> {};
// Returns a JSFunction or a Failure.
- MUST_USE_RESULT MaybeObject* LoadFunction(Code::ExtraICState
extra_ic_state,
- Handle<Object> object,
+ MUST_USE_RESULT MaybeObject* LoadFunction(Handle<Object> object,
Handle<String> name);
protected:
CallICBase(Code::Kind kind, Isolate* isolate)
: IC(EXTRA_CALL_FRAME, isolate), kind_(kind) {}
- bool TryUpdateExtraICState(LookupResult* lookup,
- Handle<Object> object,
- Code::ExtraICState* extra_ic_state);
+ virtual Code::ExtraICState extra_ic_state() { return
Code::kNoExtraICState; }
// Compute a monomorphic stub if possible, otherwise return a null
handle.
Handle<Code> ComputeMonomorphicStub(LookupResult* lookup,
@@ -265,7 +260,6 @@
// Update the inline cache and the global stub cache based on the lookup
// result.
void UpdateCaches(LookupResult* lookup,
- Code::ExtraICState extra_ic_state,
Handle<Object> object,
Handle<String> name);
@@ -300,7 +294,9 @@
class CallIC: public CallICBase {
public:
- explicit CallIC(Isolate* isolate) : CallICBase(Code::CALL_IC, isolate) {
+ explicit CallIC(Isolate* isolate)
+ : CallICBase(Code::CALL_IC, isolate),
+ extra_ic_state_(target()->extra_ic_state()) {
ASSERT(target()->is_call_stub());
}
@@ -325,6 +321,13 @@
CallICBase::GenerateNormal(masm, argc);
GenerateMiss(masm, argc, Code::kNoExtraICState);
}
+ bool TryUpdateExtraICState(LookupResult* lookup, Handle<Object> object);
+
+ protected:
+ virtual Code::ExtraICState extra_ic_state() { return extra_ic_state_; }
+
+ private:
+ Code::ExtraICState extra_ic_state_;
};
@@ -578,10 +581,10 @@
// 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.
- virtual Handle<Code> ComputeStoreMonomorphic(LookupResult* lookup,
- Handle<JSObject> receiver,
- Handle<String> name,
- Handle<Object> value);
+ virtual Handle<Code> ComputeStoreHandler(LookupResult* lookup,
+ Handle<JSObject> receiver,
+ Handle<String> name,
+ Handle<Object> value);
private:
void set_target(Code* code) {
@@ -649,10 +652,10 @@
protected:
virtual Code::Kind kind() const { return Code::KEYED_STORE_IC; }
- virtual Handle<Code> ComputeStoreMonomorphic(LookupResult* lookup,
- Handle<JSObject> receiver,
- Handle<String> name,
- Handle<Object> value);
+ virtual Handle<Code> ComputeStoreHandler(LookupResult* lookup,
+ Handle<JSObject> receiver,
+ Handle<String> name,
+ Handle<Object> value);
virtual void UpdateMegamorphicCache(Map* map, Name* name, Code* code) { }
virtual Handle<Code> pre_monomorphic_stub() {
=======================================
--- /branches/bleeding_edge/src/stub-cache.cc Tue Oct 1 09:47:18 2013 UTC
+++ /branches/bleeding_edge/src/stub-cache.cc Tue Oct 1 13:17:04 2013 UTC
@@ -97,15 +97,6 @@
isolate()->counters()->megamorphic_stub_cache_updates()->Increment();
return code;
}
-
-
-Handle<JSObject> StubCache::StubHolder(Handle<JSObject> receiver,
- Handle<JSObject> holder) {
- InlineCacheHolderFlag cache_holder =
- IC::GetCodeCacheForObject(*receiver, *holder);
- return Handle<JSObject>(IC::GetCodeCacheHolder(
- isolate_, *receiver, cache_holder));
-}
Handle<Code> StubCache::FindIC(Handle<Name> name,
@@ -133,15 +124,12 @@
Handle<Code> StubCache::FindLoadHandler(Handle<Name> name,
Handle<JSObject> receiver,
- Handle<JSObject> stub_holder,
Code::Kind kind,
Code::StubType type) {
- InlineCacheHolderFlag holder_flag = receiver.is_identical_to(stub_holder)
- ? OWN_MAP : PROTOTYPE_MAP;
ASSERT(type != Code::NORMAL);
Code::Flags flags = Code::ComputeMonomorphicFlags(
- Code::HANDLER, Code::kNoExtraICState, type, kind, holder_flag);
- Handle<Object> probe(stub_holder->map()->FindInCodeCache(*name, flags),
+ Code::HANDLER, Code::kNoExtraICState, type, kind);
+ Handle<Object> probe(receiver->map()->FindInCodeCache(*name, flags),
isolate_);
if (probe->IsCode()) return Handle<Code>::cast(probe);
return Handle<Code>::null();
@@ -220,7 +208,7 @@
// Compile the stub that is either shared for all names or
// name specific if there are global objects involved.
Handle<Code> handler = FindLoadHandler(
- cache_name, receiver, receiver, Code::LOAD_IC, Code::NONEXISTENT);
+ cache_name, receiver, Code::LOAD_IC, Code::NONEXISTENT);
if (!handler.is_null()) return handler;
LoadStubCompiler compiler(isolate_);
@@ -243,15 +231,14 @@
return stub.GetCode(isolate());
}
- Handle<JSObject> stub_holder = StubHolder(receiver, holder);
Handle<Code> stub = FindLoadHandler(
- name, receiver, stub_holder, Code::LOAD_IC, Code::FIELD);
+ name, receiver, Code::LOAD_IC, Code::FIELD);
if (!stub.is_null()) return stub;
LoadStubCompiler compiler(isolate_);
Handle<Code> handler =
compiler.CompileLoadField(receiver, holder, name, field,
representation);
- HeapObject::UpdateMapCodeCache(stub_holder, name, handler);
+ HeapObject::UpdateMapCodeCache(receiver, name, handler);
return handler;
}
@@ -262,15 +249,14 @@
Handle<JSObject> holder,
Handle<ExecutableAccessorInfo> callback) {
ASSERT(v8::ToCData<Address>(callback->getter()) != 0);
- Handle<JSObject> stub_holder = StubHolder(receiver, holder);
Handle<Code> stub = FindLoadHandler(
- name, receiver, stub_holder, Code::LOAD_IC, Code::CALLBACKS);
+ name, receiver, Code::LOAD_IC, Code::CALLBACKS);
if (!stub.is_null()) return stub;
LoadStubCompiler compiler(isolate_);
Handle<Code> handler =
compiler.CompileLoadCallback(receiver, holder, name, callback);
- HeapObject::UpdateMapCodeCache(stub_holder, name, handler);
+ HeapObject::UpdateMapCodeCache(receiver, name, handler);
return handler;
}
@@ -280,15 +266,14 @@
Handle<JSObject> receiver,
Handle<JSObject> holder,
const CallOptimization& call_optimization) {
- Handle<JSObject> stub_holder = StubHolder(receiver, holder);
Handle<Code> stub = FindLoadHandler(
- name, receiver, stub_holder, Code::LOAD_IC, Code::CALLBACKS);
+ name, receiver, Code::LOAD_IC, Code::CALLBACKS);
if (!stub.is_null()) return stub;
LoadStubCompiler compiler(isolate_);
Handle<Code> handler =
compiler.CompileLoadCallback(receiver, holder, name,
call_optimization);
- HeapObject::UpdateMapCodeCache(stub_holder, name, handler);
+ HeapObject::UpdateMapCodeCache(receiver, name, handler);
return handler;
}
@@ -297,15 +282,14 @@
Handle<JSObject> receiver,
Handle<JSObject> holder,
Handle<JSFunction> getter) {
- Handle<JSObject> stub_holder = StubHolder(receiver, holder);
Handle<Code> stub = FindLoadHandler(
- name, receiver, stub_holder, Code::LOAD_IC, Code::CALLBACKS);
+ name, receiver, Code::LOAD_IC, Code::CALLBACKS);
if (!stub.is_null()) return stub;
LoadStubCompiler compiler(isolate_);
Handle<Code> handler =
compiler.CompileLoadViaGetter(receiver, holder, name, getter);
- HeapObject::UpdateMapCodeCache(stub_holder, name, handler);
+ HeapObject::UpdateMapCodeCache(receiver, name, handler);
return handler;
}
@@ -314,14 +298,13 @@
Handle<JSObject> receiver,
Handle<JSObject> holder,
Handle<Object> value) {
- Handle<JSObject> stub_holder = StubHolder(receiver, holder);
Handle<Code> handler = FindLoadHandler(
- name, receiver, stub_holder, Code::LOAD_IC, Code::CONSTANT);
+ name, receiver, Code::LOAD_IC, Code::CONSTANT);
if (!handler.is_null()) return handler;
LoadStubCompiler compiler(isolate_);
handler = compiler.CompileLoadConstant(receiver, holder, name, value);
- HeapObject::UpdateMapCodeCache(stub_holder, name, handler);
+ HeapObject::UpdateMapCodeCache(receiver, name, handler);
return handler;
}
@@ -330,15 +313,14 @@
Handle<Code> StubCache::ComputeLoadInterceptor(Handle<Name> name,
Handle<JSObject> receiver,
Handle<JSObject> holder) {
- Handle<JSObject> stub_holder = StubHolder(receiver, holder);
Handle<Code> stub = FindLoadHandler(
- name, receiver, stub_holder, Code::LOAD_IC, Code::INTERCEPTOR);
+ name, receiver, Code::LOAD_IC, Code::INTERCEPTOR);
if (!stub.is_null()) return stub;
LoadStubCompiler compiler(isolate_);
Handle<Code> handler =
compiler.CompileLoadInterceptor(receiver, holder, name);
- HeapObject::UpdateMapCodeCache(stub_holder, name, handler);
+ HeapObject::UpdateMapCodeCache(receiver, name, handler);
return handler;
}
@@ -354,14 +336,13 @@
Handle<GlobalObject> holder,
Handle<PropertyCell> cell,
bool is_dont_delete) {
- Handle<JSObject> stub_holder = StubHolder(receiver, holder);
- Handle<Code> stub = FindIC(name, stub_holder, Code::LOAD_IC,
Code::NORMAL);
+ Handle<Code> stub = FindIC(name, receiver, Code::LOAD_IC, Code::NORMAL);
if (!stub.is_null()) return stub;
LoadStubCompiler compiler(isolate_);
Handle<Code> ic =
compiler.CompileLoadGlobal(receiver, holder, cell, name,
is_dont_delete);
- HeapObject::UpdateMapCodeCache(stub_holder, name, ic);
+ HeapObject::UpdateMapCodeCache(receiver, name, ic);
return ic;
}
@@ -379,15 +360,14 @@
return stub.GetCode(isolate());
}
- Handle<JSObject> stub_holder = StubHolder(receiver, holder);
Handle<Code> stub = FindLoadHandler(
- name, receiver, stub_holder, Code::KEYED_LOAD_IC, Code::FIELD);
+ name, receiver, Code::KEYED_LOAD_IC, Code::FIELD);
if (!stub.is_null()) return stub;
KeyedLoadStubCompiler compiler(isolate_);
Handle<Code> handler =
compiler.CompileLoadField(receiver, holder, name, field,
representation);
- HeapObject::UpdateMapCodeCache(stub_holder, name, handler);
+ HeapObject::UpdateMapCodeCache(receiver, name, handler);
return handler;
}
@@ -396,15 +376,13 @@
Handle<JSObject> receiver,
Handle<JSObject> holder,
Handle<Object> value) {
- Handle<JSObject> stub_holder = StubHolder(receiver, holder);
Handle<Code> handler = FindLoadHandler(
- name, receiver, stub_holder, Code::KEYED_LOAD_IC,
- Code::CONSTANT);
+ name, receiver, Code::KEYED_LOAD_IC, Code::CONSTANT);
if (!handler.is_null()) return handler;
KeyedLoadStubCompiler compiler(isolate_);
handler = compiler.CompileLoadConstant(receiver, holder, name, value);
- HeapObject::UpdateMapCodeCache(stub_holder, name, handler);
+ HeapObject::UpdateMapCodeCache(receiver, name, handler);
return handler;
}
@@ -412,15 +390,14 @@
Handle<Code> StubCache::ComputeKeyedLoadInterceptor(Handle<Name> name,
Handle<JSObject>
receiver,
Handle<JSObject>
holder) {
- Handle<JSObject> stub_holder = StubHolder(receiver, holder);
Handle<Code> stub = FindLoadHandler(
- name, receiver, stub_holder, Code::KEYED_LOAD_IC, Code::INTERCEPTOR);
+ name, receiver, Code::KEYED_LOAD_IC, Code::INTERCEPTOR);
if (!stub.is_null()) return stub;
KeyedLoadStubCompiler compiler(isolate_);
Handle<Code> handler =
compiler.CompileLoadInterceptor(receiver, holder, name);
- HeapObject::UpdateMapCodeCache(stub_holder, name, handler);
+ HeapObject::UpdateMapCodeCache(receiver, name, handler);
return handler;
}
@@ -430,15 +407,14 @@
Handle<JSObject> receiver,
Handle<JSObject> holder,
Handle<ExecutableAccessorInfo> callback) {
- Handle<JSObject> stub_holder = StubHolder(receiver, holder);
Handle<Code> stub = FindLoadHandler(
- name, receiver, stub_holder, Code::KEYED_LOAD_IC, Code::CALLBACKS);
+ name, receiver, Code::KEYED_LOAD_IC, Code::CALLBACKS);
if (!stub.is_null()) return stub;
KeyedLoadStubCompiler compiler(isolate_);
Handle<Code> handler =
compiler.CompileLoadCallback(receiver, holder, name, callback);
- HeapObject::UpdateMapCodeCache(stub_holder, name, handler);
+ HeapObject::UpdateMapCodeCache(receiver, name, handler);
return handler;
}
@@ -448,15 +424,14 @@
Handle<JSObject> receiver,
Handle<JSObject> holder,
const CallOptimization& call_optimization) {
- Handle<JSObject> stub_holder = StubHolder(receiver, holder);
Handle<Code> stub = FindLoadHandler(
- name, receiver, stub_holder, Code::KEYED_LOAD_IC, Code::CALLBACKS);
+ name, receiver, Code::KEYED_LOAD_IC, Code::CALLBACKS);
if (!stub.is_null()) return stub;
KeyedLoadStubCompiler compiler(isolate_);
Handle<Code> handler =
compiler.CompileLoadCallback(receiver, holder, name,
call_optimization);
- HeapObject::UpdateMapCodeCache(stub_holder, name, handler);
+ HeapObject::UpdateMapCodeCache(receiver, name, handler);
return handler;
}
@@ -820,17 +795,13 @@
Handle<GlobalObject> holder,
Handle<PropertyCell> cell,
Handle<JSFunction> function) {
- InlineCacheHolderFlag cache_holder =
- IC::GetCodeCacheForObject(*receiver, *holder);
- Handle<JSObject> stub_holder(IC::GetCodeCacheHolder(
- isolate_, *receiver, cache_holder));
Code::Flags flags = Code::ComputeMonomorphicFlags(
- kind, extra_state, Code::NORMAL, argc, cache_holder);
- Handle<Object> probe(stub_holder->map()->FindInCodeCache(*name, flags),
+ kind, extra_state, Code::NORMAL, argc);
+ Handle<Object> probe(receiver->map()->FindInCodeCache(*name, flags),
isolate_);
if (probe->IsCode()) return Handle<Code>::cast(probe);
- CallStubCompiler compiler(isolate(), argc, kind, extra_state,
cache_holder);
+ CallStubCompiler compiler(isolate(), argc, kind, extra_state);
Handle<Code> code =
compiler.CompileCallGlobal(receiver, holder, cell, function, name);
ASSERT(flags == code->flags());
@@ -838,7 +809,7 @@
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);
+ HeapObject::UpdateMapCodeCache(receiver, name, code);
}
return code;
}
=======================================
--- /branches/bleeding_edge/src/stub-cache.h Tue Oct 1 09:30:07 2013 UTC
+++ /branches/bleeding_edge/src/stub-cache.h Tue Oct 1 13:17:04 2013 UTC
@@ -94,7 +94,6 @@
Handle<Code> FindLoadHandler(Handle<Name> name,
Handle<JSObject> receiver,
- Handle<JSObject> stub_holder,
Code::Kind kind,
Code::StubType type);
@@ -1047,7 +1046,7 @@
int argc,
Code::Kind kind,
Code::ExtraICState extra_state,
- InlineCacheHolderFlag cache_holder);
+ InlineCacheHolderFlag cache_holder = OWN_MAP);
Handle<Code> CompileCallField(Handle<JSObject> object,
Handle<JSObject> holder,
--
--
v8-dev mailing list
[email protected]
http://groups.google.com/group/v8-dev
---
You received this message because you are subscribed to the Google Groups "v8-dev" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to [email protected].
For more options, visit https://groups.google.com/groups/opt_out.
