src/stub-cache.h - Issue 23647011: Unify computation of load stubs in stub cache.

Unified Diff: src/stub-cache.h

Issue 23647011: Unify computation of load stubs in stub cache. (Closed) Base URL: https://v8.googlecode.com/svn/branches/bleeding_edge

Patch Set: Created 7 years, 3 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

Index: src/stub-cache.h

diff --git a/src/stub-cache.h b/src/stub-cache.h

index a267100df58b9460f646e9f9176082518e9bb0f2..021c2463e19b2bdf5ff217b9e59f570e2df4860f 100644

--- a/src/stub-cache.h

+++ b/src/stub-cache.h

@@ -130,17 +130,20 @@ class StubCache {

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,

@@ -151,11 +154,13 @@ class StubCache {

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);

+ Handle<JSObject> holder,

+ Code::Kind kind);

Handle<Code> ComputeLoadNormal(Handle<Name> name,

Handle<JSObject> object);

@@ -168,35 +173,6 @@ class StubCache {

// ---

- 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,

Handle<JSObject> object,

LookupResult* lookup,

@@ -636,8 +612,10 @@ enum FrontendCheckType { PERFORM_INITIAL_CHECKS, SKIP_INITIAL_CHECKS };

class BaseLoadStoreStubCompiler: public StubCompiler {

public:

- BaseLoadStoreStubCompiler(Isolate* isolate, Register* registers)

- : StubCompiler(isolate), registers_(registers) { }

+ BaseLoadStoreStubCompiler(Isolate* isolate,

+ Code::Kind kind,

+ Register* registers)

+ : StubCompiler(isolate), kind_(kind), registers_(registers) { }

virtual ~BaseLoadStoreStubCompiler() { }

Handle<Code> CompileMonomorphicIC(Handle<Map> receiver_map,

@@ -665,6 +643,17 @@ class BaseLoadStoreStubCompiler: public StubCompiler {

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::LOAD_IC;

Toon Verwaest 2013/09/07 13:14:46 GDB..::STORE_IC

Michael Starzinger 2013/09/11 15:22:40 Done. Phew, that's nasty. Thanks for catching that

+ 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,

@@ -687,24 +676,48 @@ class BaseLoadStoreStubCompiler: public StubCompiler {

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_;

};

class BaseLoadStubCompiler: public BaseLoadStoreStubCompiler {

public:

- BaseLoadStubCompiler(Isolate* isolate, Register* registers)

- : BaseLoadStoreStubCompiler(isolate, registers) { }

+ BaseLoadStubCompiler(Isolate* isolate, Code::Kind kind)

+ : BaseLoadStoreStubCompiler(isolate, kind, GetRegisters(kind)) { }

+ BaseLoadStubCompiler(Isolate* isolate, Code::Kind kind, Register* registers)

+ : BaseLoadStoreStubCompiler(isolate, kind, registers) { }

virtual ~BaseLoadStubCompiler() { }

Handle<Code> CompileLoadField(Handle<JSObject> object,

@@ -789,7 +802,7 @@ class BaseLoadStubCompiler: public BaseLoadStoreStubCompiler {

class LoadStubCompiler: public BaseLoadStubCompiler {

public:

explicit LoadStubCompiler(Isolate* isolate)

- : BaseLoadStubCompiler(isolate, registers()) { }

+ : BaseLoadStubCompiler(isolate, Code::LOAD_IC, registers()) { }

Handle<Code> CompileLoadNonexistent(Handle<JSObject> object,

Handle<JSObject> last,

@@ -810,22 +823,14 @@ class LoadStubCompiler: public BaseLoadStubCompiler {

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, registers()) { }

+ : BaseLoadStubCompiler(isolate, Code::KEYED_LOAD_IC, registers()) { }

Handle<Code> CompileLoadElement(Handle<Map> receiver_map);

@@ -834,15 +839,9 @@ class KeyedLoadStubCompiler: public BaseLoadStubCompiler {

static void GenerateLoadDictionaryElement(MacroAssembler* masm);

- private:

static Register* registers();

- 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);

+ private:

virtual void GenerateNameCheck(Handle<Name> name,

Label* miss);

@@ -852,9 +851,9 @@ class KeyedLoadStubCompiler: public BaseLoadStubCompiler {

class BaseStoreStubCompiler: public BaseLoadStoreStubCompiler {

public:

BaseStoreStubCompiler(Isolate* isolate,

- StrictModeFlag strict_mode,

- Register* registers)

- : BaseLoadStoreStubCompiler(isolate, registers),

+ Code::Kind kind,

+ StrictModeFlag strict_mode)

+ : BaseLoadStoreStubCompiler(isolate, kind, GetRegisters(kind)),

strict_mode_(strict_mode) { }

virtual ~BaseStoreStubCompiler() { }

@@ -952,7 +951,7 @@ class BaseStoreStubCompiler: public BaseLoadStoreStubCompiler {

class StoreStubCompiler: public BaseStoreStubCompiler {

public:

StoreStubCompiler(Isolate* isolate, StrictModeFlag strict_mode)

- : BaseStoreStubCompiler(isolate, strict_mode, registers()) { }

+ : BaseStoreStubCompiler(isolate, Code::STORE_IC, strict_mode) { }

Handle<Code> CompileStoreCallback(Handle<JSObject> object,

@@ -975,15 +974,7 @@ class StoreStubCompiler: public BaseStoreStubCompiler {

Handle<PropertyCell> holder,

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);

};

@@ -992,7 +983,7 @@ class KeyedStoreStubCompiler: public BaseStoreStubCompiler {

KeyedStoreStubCompiler(Isolate* isolate,

StrictModeFlag strict_mode,

KeyedAccessStoreMode store_mode)

- : BaseStoreStubCompiler(isolate, strict_mode, registers()),

+ : BaseStoreStubCompiler(isolate, Code::KEYED_STORE_IC, strict_mode),

store_mode_(store_mode) { }

Handle<Code> CompileStoreElement(Handle<Map> receiver_map);

@@ -1005,6 +996,8 @@ class KeyedStoreStubCompiler: public BaseStoreStubCompiler {

static void GenerateStoreDictionaryElement(MacroAssembler* masm);

+ static Register* registers();

protected:

virtual Code::ExtraICState extra_state() {

return Code::ComputeExtraICState(store_mode_, strict_mode());

@@ -1015,14 +1008,6 @@ class KeyedStoreStubCompiler: public BaseStoreStubCompiler {

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,

Label* miss);

« no previous file with comments | « src/ic.cc ('k') | src/stub-cache.cc » ('j') | no next file with comments »