Revision: 16661
Author: [email protected]
Date: Wed Sep 11 16:27:41 2013 UTC
Log: Revert "Unify computation of load stubs in stub cache."
[email protected]
Review URL: https://codereview.chromium.org/24095005
http://code.google.com/p/v8/source/detail?r=16661
Modified:
/branches/bleeding_edge/src/ic.cc
/branches/bleeding_edge/src/stub-cache.cc
/branches/bleeding_edge/src/stub-cache.h
=======================================
--- /branches/bleeding_edge/src/ic.cc Wed Sep 11 15:44:09 2013 UTC
+++ /branches/bleeding_edge/src/ic.cc Wed Sep 11 16:27:41 2013 UTC
@@ -1318,7 +1318,7 @@
switch (lookup->type()) {
case FIELD:
return isolate()->stub_cache()->ComputeLoadField(
- name, receiver, holder, Code::LOAD_IC,
+ name, receiver, holder,
lookup->GetFieldIndex(), lookup->representation());
case CONSTANT: {
Handle<Object> constant(lookup->GetConstant(), isolate());
@@ -1326,7 +1326,7 @@
// be embedded into code.
if (constant->IsConsString()) return Handle<Code>::null();
return isolate()->stub_cache()->ComputeLoadConstant(
- name, receiver, holder, Code::LOAD_IC, constant);
+ name, receiver, holder, constant);
}
case NORMAL:
if (holder->IsGlobalObject()) {
@@ -1350,7 +1350,7 @@
if (v8::ToCData<Address>(info->getter()) == 0) break;
if (!info->IsCompatibleReceiver(*receiver)) break;
return isolate()->stub_cache()->ComputeLoadCallback(
- name, receiver, holder, Code::LOAD_IC, info);
+ name, receiver, holder, info);
} else if (callback->IsAccessorPair()) {
Handle<Object>
getter(Handle<AccessorPair>::cast(callback)->getter(),
isolate());
@@ -1363,7 +1363,7 @@
call_optimization.IsCompatibleReceiver(*receiver) &&
FLAG_js_accessor_ics) {
return isolate()->stub_cache()->ComputeLoadCallback(
- name, receiver, holder, Code::LOAD_IC, call_optimization);
+ name, receiver, holder, call_optimization);
}
return isolate()->stub_cache()->ComputeLoadViaGetter(
name, receiver, holder, function);
@@ -1372,8 +1372,7 @@
PropertyIndex lengthIndex =
PropertyIndex::NewHeaderIndex(JSArray::kLengthOffset /
kPointerSize);
return isolate()->stub_cache()->ComputeLoadField(
- name, receiver, holder, Code::LOAD_IC,
- lengthIndex, Representation::Tagged());
+ name, receiver, holder, lengthIndex, Representation::Tagged());
}
// TODO(dcarney): Handle correctly.
if (callback->IsDeclaredAccessorInfo()) break;
@@ -1384,7 +1383,7 @@
case INTERCEPTOR:
ASSERT(HasInterceptorGetter(*holder));
return isolate()->stub_cache()->ComputeLoadInterceptor(
- name, receiver, holder, Code::LOAD_IC);
+ name, receiver, holder);
default:
break;
}
@@ -1539,16 +1538,16 @@
Handle<JSObject> holder(lookup->holder(), isolate());
switch (lookup->type()) {
case FIELD:
- return isolate()->stub_cache()->ComputeLoadField(
- name, receiver, holder, Code::KEYED_LOAD_IC,
+ return isolate()->stub_cache()->ComputeKeyedLoadField(
+ name, receiver, holder,
lookup->GetFieldIndex(), lookup->representation());
case CONSTANT: {
Handle<Object> 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<Code>::null();
- return isolate()->stub_cache()->ComputeLoadConstant(
- name, receiver, holder, Code::KEYED_LOAD_IC, constant);
+ return isolate()->stub_cache()->ComputeKeyedLoadConstant(
+ name, receiver, holder, constant);
}
case CALLBACKS: {
Handle<Object> callback_object(lookup->GetCallbackObject(),
isolate());
@@ -1558,8 +1557,8 @@
Handle<ExecutableAccessorInfo>::cast(callback_object);
if (v8::ToCData<Address>(callback->getter()) == 0) break;
if (!callback->IsCompatibleReceiver(*receiver)) break;
- return isolate()->stub_cache()->ComputeLoadCallback(
- name, receiver, holder, Code::KEYED_LOAD_IC, callback);
+ return isolate()->stub_cache()->ComputeKeyedLoadCallback(
+ name, receiver, holder, callback);
} else if (callback_object->IsAccessorPair()) {
Handle<Object> getter(
Handle<AccessorPair>::cast(callback_object)->getter(),
@@ -1572,16 +1571,16 @@
if (call_optimization.is_simple_api_call() &&
call_optimization.IsCompatibleReceiver(*receiver) &&
FLAG_js_accessor_ics) {
- return isolate()->stub_cache()->ComputeLoadCallback(
- name, receiver, holder, Code::KEYED_LOAD_IC,
call_optimization);
+ return isolate()->stub_cache()->ComputeKeyedLoadCallback(
+ name, receiver, holder, call_optimization);
}
}
break;
}
case INTERCEPTOR:
ASSERT(HasInterceptorGetter(lookup->holder()));
- return isolate()->stub_cache()->ComputeLoadInterceptor(
- name, receiver, holder, Code::KEYED_LOAD_IC);
+ return isolate()->stub_cache()->ComputeKeyedLoadInterceptor(
+ name, receiver, holder);
default:
// Always rewrite to the generic case so that we do not
// repeatedly try to rewrite.
=======================================
--- /branches/bleeding_edge/src/stub-cache.cc Wed Sep 11 15:44:09 2013 UTC
+++ /branches/bleeding_edge/src/stub-cache.cc Wed Sep 11 16:27:41 2013 UTC
@@ -272,29 +272,21 @@
Handle<Code> StubCache::ComputeLoadField(Handle<Name> name,
Handle<JSObject> receiver,
Handle<JSObject> holder,
- Code::Kind kind,
PropertyIndex field,
Representation representation) {
if (receiver.is_identical_to(holder)) {
- 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());
- }
+ LoadFieldStub stub(field.is_inobject(holder),
+ field.translate(holder),
+ representation);
+ return stub.GetCode(isolate());
}
Handle<JSObject> stub_holder = StubHolder(receiver, holder);
Handle<Code> stub = FindLoadHandler(
- name, receiver, stub_holder, kind, Code::FIELD);
+ name, receiver, stub_holder, Code::LOAD_IC, Code::FIELD);
if (!stub.is_null()) return stub;
- BaseLoadStubCompiler compiler(isolate_, kind);
+ LoadStubCompiler compiler(isolate_);
Handle<Code> handler =
compiler.CompileLoadField(receiver, holder, name, field,
representation);
JSObject::UpdateMapCodeCache(stub_holder, name, handler);
@@ -306,15 +298,14 @@
Handle<Name> name,
Handle<JSObject> receiver,
Handle<JSObject> holder,
- Code::Kind kind,
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, kind, Code::CALLBACKS);
+ name, receiver, stub_holder, Code::LOAD_IC, Code::CALLBACKS);
if (!stub.is_null()) return stub;
- BaseLoadStubCompiler compiler(isolate_, kind);
+ LoadStubCompiler compiler(isolate_);
Handle<Code> handler =
compiler.CompileLoadCallback(receiver, holder, name, callback);
JSObject::UpdateMapCodeCache(stub_holder, name, handler);
@@ -326,14 +317,13 @@
Handle<Name> name,
Handle<JSObject> receiver,
Handle<JSObject> holder,
- Code::Kind kind,
const CallOptimization& call_optimization) {
Handle<JSObject> stub_holder = StubHolder(receiver, holder);
Handle<Code> stub = FindLoadHandler(
- name, receiver, stub_holder, kind, Code::CALLBACKS);
+ name, receiver, stub_holder, Code::LOAD_IC, Code::CALLBACKS);
if (!stub.is_null()) return stub;
- BaseLoadStubCompiler compiler(isolate_, kind);
+ LoadStubCompiler compiler(isolate_);
Handle<Code> handler =
compiler.CompileLoadCallback(receiver, holder, name,
call_optimization);
JSObject::UpdateMapCodeCache(stub_holder, name, handler);
@@ -361,30 +351,29 @@
Handle<Code> StubCache::ComputeLoadConstant(Handle<Name> name,
Handle<JSObject> receiver,
Handle<JSObject> holder,
- Code::Kind kind,
Handle<Object> value) {
Handle<JSObject> stub_holder = StubHolder(receiver, holder);
Handle<Code> handler = FindLoadHandler(
- name, receiver, stub_holder, kind, Code::CONSTANT);
+ name, receiver, stub_holder, Code::LOAD_IC, Code::CONSTANT);
if (!handler.is_null()) return handler;
- BaseLoadStubCompiler compiler(isolate_, kind);
+ LoadStubCompiler compiler(isolate_);
handler = compiler.CompileLoadConstant(receiver, holder, name, value);
JSObject::UpdateMapCodeCache(stub_holder, name, handler);
+
return handler;
}
Handle<Code> StubCache::ComputeLoadInterceptor(Handle<Name> name,
Handle<JSObject> receiver,
- Handle<JSObject> holder,
- Code::Kind kind) {
+ Handle<JSObject> holder) {
Handle<JSObject> stub_holder = StubHolder(receiver, holder);
Handle<Code> stub = FindLoadHandler(
- name, receiver, stub_holder, kind, Code::INTERCEPTOR);
+ name, receiver, stub_holder, Code::LOAD_IC, Code::INTERCEPTOR);
if (!stub.is_null()) return stub;
- BaseLoadStubCompiler compiler(isolate_, kind);
+ LoadStubCompiler compiler(isolate_);
Handle<Code> handler =
compiler.CompileLoadInterceptor(receiver, holder, name);
JSObject::UpdateMapCodeCache(stub_holder, name, handler);
@@ -413,7 +402,102 @@
JSObject::UpdateMapCodeCache(stub_holder, name, ic);
return ic;
}
+
+
+Handle<Code> StubCache::ComputeKeyedLoadField(Handle<Name> name,
+ Handle<JSObject> receiver,
+ Handle<JSObject> 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<JSObject> stub_holder = StubHolder(receiver, holder);
+ Handle<Code> stub = FindLoadHandler(
+ name, receiver, stub_holder, 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);
+ JSObject::UpdateMapCodeCache(stub_holder, name, handler);
+ return handler;
+}
+
+Handle<Code> StubCache::ComputeKeyedLoadConstant(Handle<Name> name,
+ 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);
+ 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<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);
+ if (!stub.is_null()) return stub;
+
+ KeyedLoadStubCompiler compiler(isolate_);
+ Handle<Code> handler =
+ compiler.CompileLoadInterceptor(receiver, holder, name);
+ JSObject::UpdateMapCodeCache(stub_holder, name, handler);
+ return handler;
+}
+
+
+Handle<Code> StubCache::ComputeKeyedLoadCallback(
+ Handle<Name> name,
+ 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);
+ if (!stub.is_null()) return stub;
+
+ KeyedLoadStubCompiler compiler(isolate_);
+ Handle<Code> handler =
+ compiler.CompileLoadCallback(receiver, holder, name, callback);
+ JSObject::UpdateMapCodeCache(stub_holder, name, handler);
+ return handler;
+}
+
+
+Handle<Code> StubCache::ComputeKeyedLoadCallback(
+ Handle<Name> name,
+ 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);
+ if (!stub.is_null()) return stub;
+
+ KeyedLoadStubCompiler compiler(isolate_);
+ Handle<Code> handler =
+ compiler.CompileLoadCallback(receiver, holder, name,
call_optimization);
+ JSObject::UpdateMapCodeCache(stub_holder, name, handler);
+ return handler;
+}
+
Handle<Code> StubCache::ComputeStoreField(Handle<Name> name,
Handle<JSObject> receiver,
@@ -1873,15 +1957,23 @@
}
-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;
+void LoadStubCompiler::JitEvent(Handle<Name> name, Handle<Code> code) {
+ GDBJIT(AddCode(GDBJITInterface::LOAD_IC, *name, *code));
+}
+
+
+void KeyedLoadStubCompiler::JitEvent(Handle<Name> name, Handle<Code> code)
{
+ GDBJIT(AddCode(GDBJITInterface::KEYED_LOAD_IC, *name, *code));
+}
+
+
+void StoreStubCompiler::JitEvent(Handle<Name> name, Handle<Code> code) {
+ GDBJIT(AddCode(GDBJITInterface::STORE_IC, *name, *code));
+}
+
+
+void KeyedStoreStubCompiler::JitEvent(Handle<Name> name, Handle<Code>
code) {
+ GDBJIT(AddCode(GDBJITInterface::KEYED_STORE_IC, *name, *code));
}
=======================================
--- /branches/bleeding_edge/src/stub-cache.h Wed Sep 11 15:44:09 2013 UTC
+++ /branches/bleeding_edge/src/stub-cache.h Wed Sep 11 16:27:41 2013 UTC
@@ -130,20 +130,17 @@
Handle<Code> ComputeLoadField(Handle<Name> name,
Handle<JSObject> object,
Handle<JSObject> holder,
- Code::Kind kind,
PropertyIndex field_index,
Representation representation);
Handle<Code> ComputeLoadCallback(Handle<Name> name,
Handle<JSObject> object,
Handle<JSObject> holder,
- Code::Kind kind,
Handle<ExecutableAccessorInfo>
callback);
Handle<Code> ComputeLoadCallback(Handle<Name> name,
Handle<JSObject> object,
Handle<JSObject> holder,
- Code::Kind kind,
const CallOptimization&
call_optimization);
Handle<Code> ComputeLoadViaGetter(Handle<Name> name,
@@ -154,13 +151,11 @@
Handle<Code> ComputeLoadConstant(Handle<Name> name,
Handle<JSObject> object,
Handle<JSObject> holder,
- Code::Kind kind,
Handle<Object> value);
Handle<Code> ComputeLoadInterceptor(Handle<Name> name,
Handle<JSObject> object,
- Handle<JSObject> holder,
- Code::Kind kind);
+ Handle<JSObject> holder);
Handle<Code> ComputeLoadNormal(Handle<Name> name,
Handle<JSObject> object);
@@ -171,6 +166,35 @@
Handle<PropertyCell> cell,
bool is_dont_delete);
+ // ---
+
+ Handle<Code> ComputeKeyedLoadField(Handle<Name> name,
+ Handle<JSObject> object,
+ Handle<JSObject> holder,
+ PropertyIndex field_index,
+ Representation representation);
+
+ Handle<Code> ComputeKeyedLoadCallback(
+ Handle<Name> name,
+ Handle<JSObject> object,
+ Handle<JSObject> holder,
+ Handle<ExecutableAccessorInfo> callback);
+
+ Handle<Code> ComputeKeyedLoadCallback(
+ Handle<Name> name,
+ Handle<JSObject> object,
+ Handle<JSObject> holder,
+ const CallOptimization& call_optimization);
+
+ Handle<Code> ComputeKeyedLoadConstant(Handle<Name> name,
+ Handle<JSObject> object,
+ Handle<JSObject> holder,
+ Handle<Object> value);
+
+ Handle<Code> ComputeKeyedLoadInterceptor(Handle<Name> name,
+ Handle<JSObject> object,
+ Handle<JSObject> holder);
+
// ---
Handle<Code> ComputeStoreField(Handle<Name> name,
@@ -618,10 +642,8 @@
class BaseLoadStoreStubCompiler: public StubCompiler {
public:
- BaseLoadStoreStubCompiler(Isolate* isolate,
- Code::Kind kind,
- Register* registers)
- : StubCompiler(isolate), kind_(kind), registers_(registers) { }
+ BaseLoadStoreStubCompiler(Isolate* isolate, Register* registers)
+ : StubCompiler(isolate), registers_(registers) { }
virtual ~BaseLoadStoreStubCompiler() { }
Handle<Code> CompileMonomorphicIC(Handle<Map> receiver_map,
@@ -648,17 +670,6 @@
}
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<GDBJITInterface::CodeTag>(0);
- }
protected:
virtual Register HandlerFrontendHeader(Handle<JSObject> object,
@@ -682,48 +693,24 @@
Handle<Name> name,
InlineCacheState state = MONOMORPHIC);
- virtual Logger::LogEventsAndTags log_kind(Handle<Code> 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<Logger::LogEventsAndTags>(0);
- }
-
- void JitEvent(Handle<Name> name, Handle<Code> 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> code) = 0;
+ virtual void JitEvent(Handle<Name> name, Handle<Code> 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, Code::Kind kind)
- : BaseLoadStoreStubCompiler(isolate, kind, GetRegisters(kind)) { }
- BaseLoadStubCompiler(Isolate* isolate, Code::Kind kind, Register*
registers)
- : BaseLoadStoreStubCompiler(isolate, kind, registers) { }
+ BaseLoadStubCompiler(Isolate* isolate, Register* registers)
+ : BaseLoadStoreStubCompiler(isolate, registers) { }
virtual ~BaseLoadStubCompiler() { }
Handle<Code> CompileLoadField(Handle<JSObject> object,
@@ -808,7 +795,7 @@
class LoadStubCompiler: public BaseLoadStubCompiler {
public:
explicit LoadStubCompiler(Isolate* isolate)
- : BaseLoadStubCompiler(isolate, Code::LOAD_IC, registers()) { }
+ : BaseLoadStubCompiler(isolate, registers()) { }
Handle<Code> CompileLoadNonexistent(Handle<JSObject> object,
Handle<JSObject> last,
@@ -829,14 +816,22 @@
Handle<Name> name,
bool is_dont_delete);
+ private:
static Register* registers();
+ virtual Code::Kind kind() { return Code::LOAD_IC; }
+ virtual Logger::LogEventsAndTags log_kind(Handle<Code> 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> name, Handle<Code> code);
};
class KeyedLoadStubCompiler: public BaseLoadStubCompiler {
public:
explicit KeyedLoadStubCompiler(Isolate* isolate)
- : BaseLoadStubCompiler(isolate, Code::KEYED_LOAD_IC, registers()) { }
+ : BaseLoadStubCompiler(isolate, registers()) { }
Handle<Code> CompileLoadElement(Handle<Map> receiver_map);
@@ -845,9 +840,15 @@
static void GenerateLoadDictionaryElement(MacroAssembler* masm);
+ private:
static Register* registers();
-
- private:
+ virtual Code::Kind kind() { return Code::KEYED_LOAD_IC; }
+ virtual Logger::LogEventsAndTags log_kind(Handle<Code> 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> name, Handle<Code> code);
virtual void GenerateNameCheck(Handle<Name> name,
Register name_reg,
Label* miss);
@@ -857,9 +858,9 @@
class BaseStoreStubCompiler: public BaseLoadStoreStubCompiler {
public:
BaseStoreStubCompiler(Isolate* isolate,
- Code::Kind kind,
- StrictModeFlag strict_mode)
- : BaseLoadStoreStubCompiler(isolate, kind, GetRegisters(kind)),
+ StrictModeFlag strict_mode,
+ Register* registers)
+ : BaseLoadStoreStubCompiler(isolate, registers),
strict_mode_(strict_mode) { }
virtual ~BaseStoreStubCompiler() { }
@@ -957,7 +958,7 @@
class StoreStubCompiler: public BaseStoreStubCompiler {
public:
StoreStubCompiler(Isolate* isolate, StrictModeFlag strict_mode)
- : BaseStoreStubCompiler(isolate, Code::STORE_IC, strict_mode) { }
+ : BaseStoreStubCompiler(isolate, strict_mode, registers()) { }
Handle<Code> CompileStoreCallback(Handle<JSObject> object,
@@ -981,7 +982,15 @@
Handle<Code> CompileStoreInterceptor(Handle<JSObject> object,
Handle<Name> name);
+ private:
static Register* registers();
+ virtual Code::Kind kind() { return Code::STORE_IC; }
+ virtual Logger::LogEventsAndTags log_kind(Handle<Code> 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> name, Handle<Code> code);
};
@@ -990,7 +999,7 @@
KeyedStoreStubCompiler(Isolate* isolate,
StrictModeFlag strict_mode,
KeyedAccessStoreMode store_mode)
- : BaseStoreStubCompiler(isolate, Code::KEYED_STORE_IC, strict_mode),
+ : BaseStoreStubCompiler(isolate, strict_mode, registers()),
store_mode_(store_mode) { }
Handle<Code> CompileStoreElement(Handle<Map> receiver_map);
@@ -1003,8 +1012,6 @@
static void GenerateStoreDictionaryElement(MacroAssembler* masm);
- static Register* registers();
-
protected:
virtual Code::ExtraICState extra_state() {
return Code::ComputeExtraICState(store_mode_, strict_mode());
@@ -1015,6 +1022,14 @@
return registers()[3];
}
+ static Register* registers();
+ virtual Code::Kind kind() { return Code::KEYED_STORE_IC; }
+ virtual Logger::LogEventsAndTags log_kind(Handle<Code> 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> name, Handle<Code> code);
virtual void GenerateNameCheck(Handle<Name> name,
Register name_reg,
Label* miss);
--
--
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.
