src/stub-cache.h - Issue 12340112: Polymorphism support for load IC.

Unified Diff: src/stub-cache.h

Issue 12340112: Polymorphism support for load IC. (Closed) Base URL: https://v8.googlecode.com/svn/branches/bleeding_edge

Patch Set: Created 7 years, 10 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 775340648b6d5ddac46d01a61215141d48f0dd49..3cd9ef513b893019a69ee024693f8e32ed6ff6ea 100644

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

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

@@ -74,6 +74,26 @@ class StubCache {

void Initialize();

+ Handle<JSObject> StubHolder(Handle<JSObject> receiver,

+ Handle<JSObject> holder);

+ Handle<Code> FindStub(Handle<String> name,

+ Handle<JSObject> stub_holder,

+ Code::Kind kind,

+ Code::StubType type,

+ Code::IcFragment fragment);

+ Handle<Code> FindHandler(Handle<String> name,

+ Handle<JSObject> stub_holder,

+ Code::Kind kind,

+ Code::StubType type);

+ Handle<Code> ComputeMonomorphicIC(Handle<JSObject> receiver,

+ Handle<Code> handler,

+ Handle<String> name);

+ Handle<Code> ComputeKeyedMonomorphicIC(Handle<JSObject> receiver,

+ Handle<Code> handler,

+ Handle<String> name);

// Computes the right stub matching. Inserts the result in the

// cache before returning. This might compile a stub if needed.

@@ -104,7 +124,8 @@ class StubCache {

Handle<JSObject> object,

Handle<JSObject> holder);

- Handle<Code> ComputeLoadNormal();

+ Handle<Code> ComputeLoadNormal(Handle<String> name,

+ Handle<JSObject> object);

Handle<Code> ComputeLoadGlobal(Handle<String> name,

Handle<JSObject> object,

@@ -245,6 +266,10 @@ class StubCache {

KeyedAccessGrowMode grow_mode,

StrictModeFlag strict_mode);

+ Handle<Code> ComputePolymorphicIC(MapHandleList* receiver_maps,

+ CodeHandleList* handlers,

+ Handle<String> name);

// Finds the Code object stored in the Heap::non_monomorphic_cache().

Code* FindCallInitialize(int argc, RelocInfo::Mode mode, Code::Kind kind);

@@ -414,6 +439,10 @@ DECLARE_RUNTIME_FUNCTION(MaybeObject*, CallInterceptorProperty);

DECLARE_RUNTIME_FUNCTION(MaybeObject*, KeyedLoadPropertyWithInterceptor);

+enum PrototypeCheckType { CHECK_ALL_MAPS, SKIP_RECEIVER };

+enum IcCheckType { ELEMENT, PROPERTY };

// The stub compilers compile stubs for the stub cache.

class StubCompiler BASE_EMBEDDED {

public:

@@ -455,6 +484,11 @@ class StubCompiler BASE_EMBEDDED {

Handle<JSObject> holder,

PropertyIndex index);

+ static void DoGenerateFastPropertyLoad(MacroAssembler* masm,

+ Register dst,

+ Register src,

+ bool inobject,

+ int index);

static void GenerateLoadArrayLength(MacroAssembler* masm,

@@ -512,9 +546,10 @@ class StubCompiler BASE_EMBEDDED {

Handle<String> name,

- Label* miss) {

+ Label* miss,

+ PrototypeCheckType check = CHECK_ALL_MAPS) {

return CheckPrototypes(object, object_reg, holder, holder_reg, scratch1,

- scratch2, name, kInvalidProtoDepth, miss);

+ scratch2, name, kInvalidProtoDepth, miss, check);

}

@@ -525,7 +560,8 @@ class StubCompiler BASE_EMBEDDED {

Handle<String> name,

int save_at_depth,

- Label* miss);

+ Label* miss,

+ PrototypeCheckType check = CHECK_ALL_MAPS);

protected:

@@ -578,28 +614,36 @@ class BaseLoadStubCompiler: public StubCompiler {

Handle<JSObject> holder,

Handle<String> name);

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

+ Handle<Code> handler,

+ Handle<String> name);

+ Handle<Code> CompilePolymorphicIC(MapHandleList* receiver_maps,

+ CodeHandleList* handlers,

+ Handle<String> name,

+ Code::StubType type,

+ IcCheckType check);

protected:

- Register HandlerFrontendHeader(Handle<JSObject> object,

- Register object_reg,

- Handle<JSObject> holder,

- Handle<String> name,

- Label* success,

- FrontendCheckType check);

+ Register HandlerFrontendHeader(

+ Handle<JSObject> object,

Jakob Kummerow 2013/03/01 22:21:04 Why this reformatting?

Toon Verwaest 2013/03/04 10:54:08 Done.

+ Register object_reg,

+ Handle<JSObject> holder,

+ Handle<String> name,

+ Label* success);

void HandlerFrontendFooter(Label* success, Label* miss);

Handle<JSObject> holder,

Handle<String> name,

- Label* success,

- FrontendCheckType check);

- Register CallbackHandlerFrontend(Handle<JSObject> object,

- Register object_reg,

- Handle<JSObject> holder,

- Handle<String> name,

- Label* success,

- FrontendCheckType check,

- Handle<ExecutableAccessorInfo> callback);

+ Label* success);

+ Register CallbackHandlerFrontend(

+ Handle<JSObject> object,

Jakob Kummerow 2013/03/01 22:21:04 Why this reformatting?

Toon Verwaest 2013/03/04 10:54:08 Done.

+ Register object_reg,

+ Handle<JSObject> holder,

+ Handle<String> name,

+ Label* success,

+ Handle<ExecutableAccessorInfo> callback);

void NonexistentHandlerFrontend(Handle<JSObject> object,

Handle<JSObject> last,

Handle<String> name,

@@ -622,6 +666,10 @@ class BaseLoadStubCompiler: public StubCompiler {

Handle<String> name,

LookupResult* lookup);

+ Handle<Code> GetCode(Code::IcFragment fragment,

+ Code::StubType type,

+ Handle<String> name,

+ InlineCacheState state = MONOMORPHIC);

@@ -632,12 +680,11 @@ class BaseLoadStubCompiler: public StubCompiler {

private:

virtual Code::Kind kind() = 0;

+ virtual Logger::LogEventsAndTags log_kind(Handle<Code> code) = 0;

+ virtual void JitEvent(Handle<String> name, Handle<Code> code) = 0;

virtual void GenerateNameCheck(Handle<String> name,

Label* miss) { }

- virtual Handle<Code> GetCode(Code::StubType type,

- Handle<String> name,

- InlineCacheState state = MONOMORPHIC) = 0;

};

@@ -666,12 +713,16 @@ class LoadStubCompiler: public BaseLoadStubCompiler {

Handle<String> name,

bool is_dont_delete);

+ static Register receiver() { return registers()[0]; }

private:

- Register* registers();

+ static Register* registers();

virtual Code::Kind kind() { return Code::LOAD_IC; }

- virtual Handle<Code> GetCode(Code::StubType type,

- Handle<String> name,

- InlineCacheState state = MONOMORPHIC);

+ virtual Logger::LogEventsAndTags log_kind(Handle<Code> code) {

+ return code->ic_state() == MONOMORPHIC

+ ? Logger::LOAD_IC_TAG : Logger::LOAD_POLYMORPHIC_IC_TAG;

+ }

+ virtual void JitEvent(Handle<String> name, Handle<Code> code);

};

@@ -682,19 +733,23 @@ class KeyedLoadStubCompiler: public BaseLoadStubCompiler {

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

- Handle<Code> CompileLoadPolymorphic(MapHandleList* receiver_maps,

- CodeHandleList* handler_ics);

+ void CompileElementHandlers(MapHandleList* receiver_maps,

+ CodeHandleList* handlers);

Handle<Code> CompileLoadElementPolymorphic(MapHandleList* receiver_maps);

static void GenerateLoadDictionaryElement(MacroAssembler* masm);

+ static Register receiver() { return registers()[0]; }

private:

- Register* registers();

+ static Register* registers();

virtual Code::Kind kind() { return Code::KEYED_LOAD_IC; }

- virtual Handle<Code> GetCode(Code::StubType type,

- Handle<String> name,

- InlineCacheState state = MONOMORPHIC);

+ virtual Logger::LogEventsAndTags log_kind(Handle<Code> code) {

+ return code->ic_state() == MONOMORPHIC

+ ? Logger::KEYED_LOAD_IC_TAG : Logger::KEYED_LOAD_POLYMORPHIC_IC_TAG;

+ }

+ virtual void JitEvent(Handle<String> name, Handle<Code> code);

virtual void GenerateNameCheck(Handle<String> name,

Label* miss);

« src/ic.cc ('K') | « src/property.h ('k') | src/stub-cache.cc » ('j') | src/stub-cache.cc » ('J')