src/stub-cache.h - Issue 112863002: Merge bleeding_edge 18021:18297

Unified Diff: src/stub-cache.h

Issue 112863002: Merge bleeding_edge 18021:18297 (Closed) Base URL: https://v8.googlecode.com/svn/branches/experimental/parser

Patch Set: Created 7 years 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 91f340933cfc7c4dc512085aa123c3d3b5df480a..ebf0bd3c917b5e06ba80f0a4bedb5bd1703def23 100644

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

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

@@ -83,21 +83,20 @@ class StubCache {

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

Handle<Map> stub_holder_map,

Code::Kind kind,

- Code::ExtraICState extra_state = Code::kNoExtraICState,

+ ExtraICState extra_state = kNoExtraICState,

InlineCacheHolderFlag cache_holder = OWN_MAP);

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

- Handle<HeapObject> stub_holder,

+ Handle<Map> map,

Code::Kind kind,

- InlineCacheHolderFlag cache_holder = OWN_MAP,

- StrictModeFlag strict_mode = kNonStrictMode);

+ InlineCacheHolderFlag cache_holder = OWN_MAP);

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

Handle<Type> type,

Handle<Code> handler,

- StrictModeFlag strict_mode);

+ ExtraICState extra_ic_state);

- Handle<Code> ComputeLoadNonexistent(Handle<Name> name, Handle<Object> object);

+ Handle<Code> ComputeLoadNonexistent(Handle<Name> name, Handle<Type> type);

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

@@ -107,7 +106,7 @@ class StubCache {

Handle<Code> ComputeCallField(int argc,

Code::Kind,

- Code::ExtraICState extra_state,

+ ExtraICState extra_state,

Handle<Name> name,

Handle<Object> object,

Handle<JSObject> holder,

@@ -115,7 +114,7 @@ class StubCache {

Handle<Code> ComputeCallConstant(int argc,

Code::Kind,

- Code::ExtraICState extra_state,

+ ExtraICState extra_state,

Handle<Name> name,

Handle<Object> object,

Handle<JSObject> holder,

@@ -123,14 +122,14 @@ class StubCache {

Handle<Code> ComputeCallInterceptor(int argc,

Code::Kind,

- Code::ExtraICState extra_state,

+ ExtraICState extra_state,

Handle<Name> name,

Handle<Object> object,

Handle<JSObject> holder);

Handle<Code> ComputeCallGlobal(int argc,

Code::Kind,

- Code::ExtraICState extra_state,

+ ExtraICState extra_state,

Handle<Name> name,

Handle<JSObject> object,

Handle<GlobalObject> holder,

@@ -145,21 +144,21 @@ class StubCache {

Handle<Code> ComputeCallPreMonomorphic(int argc,

Code::Kind kind,

- Code::ExtraICState extra_state);

+ ExtraICState extra_state);

Handle<Code> ComputeCallNormal(int argc,

Code::Kind kind,

- Code::ExtraICState state);

+ ExtraICState state);

Handle<Code> ComputeCallArguments(int argc);

Handle<Code> ComputeCallMegamorphic(int argc,

Code::Kind kind,

- Code::ExtraICState state);

+ ExtraICState state);

Handle<Code> ComputeCallMiss(int argc,

Code::Kind kind,

- Code::ExtraICState state);

+ ExtraICState state);

// ---

@@ -177,7 +176,7 @@ class StubCache {

CodeHandleList* handlers,

int number_of_valid_maps,

Handle<Name> name,

- StrictModeFlag strict_mode);

+ ExtraICState extra_ic_state);

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

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

@@ -365,8 +364,10 @@ enum IcCheckType { ELEMENT, PROPERTY };

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

class StubCompiler BASE_EMBEDDED {

public:

- explicit StubCompiler(Isolate* isolate)

- : isolate_(isolate), masm_(isolate, NULL, 256), failure_(NULL) { }

+ explicit StubCompiler(Isolate* isolate,

+ ExtraICState extra_ic_state = kNoExtraICState)

+ : isolate_(isolate), extra_ic_state_(extra_ic_state),

+ masm_(isolate, NULL, 256), failure_(NULL) { }

// Functions to compile either CallIC or KeyedCallIC. The specific kind

// is extracted from the code flags.

@@ -443,15 +444,6 @@ class StubCompiler BASE_EMBEDDED {

Label* miss);

- // Calls GenerateCheckPropertyCell for each global object in the prototype

- // chain from object to (but not including) holder.

- static void GenerateCheckPropertyCells(MacroAssembler* masm,

- Handle<JSObject> object,

- Handle<JSObject> holder,

- Handle<Name> name,

- Register scratch,

- Label* miss);

static void TailCallBuiltin(MacroAssembler* masm, Builtins::Name name);

// Generates code that verifies that the property holder has not changed

@@ -469,7 +461,7 @@ class StubCompiler BASE_EMBEDDED {

// The function can optionally (when save_at_depth !=

// kInvalidProtoDepth) save the object at the given depth by moving

// it to [esp + kPointerSize].

- Register CheckPrototypes(Handle<JSObject> object,

+ Register CheckPrototypes(Handle<Type> type,

Handle<JSObject> holder,

@@ -478,11 +470,11 @@ class StubCompiler BASE_EMBEDDED {

Handle<Name> name,

Label* miss,

PrototypeCheckType check = CHECK_ALL_MAPS) {

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

+ return CheckPrototypes(type, object_reg, holder, holder_reg, scratch1,

scratch2, name, kInvalidProtoDepth, miss, check);

}

- Register CheckPrototypes(Handle<JSObject> object,

+ Register CheckPrototypes(Handle<Type> type,

Handle<JSObject> holder,

@@ -499,6 +491,8 @@ class StubCompiler BASE_EMBEDDED {

Handle<Code> GetCodeWithFlags(Code::Flags flags, const char* name);

Handle<Code> GetCodeWithFlags(Code::Flags flags, Handle<Name> name);

+ ExtraICState extra_state() { return extra_ic_state_; }

MacroAssembler* masm() { return &masm_; }

void set_failure(Failure* failure) { failure_ = failure; }

@@ -514,6 +508,7 @@ class StubCompiler BASE_EMBEDDED {

private:

Isolate* isolate_;

+ const ExtraICState extra_ic_state_;

MacroAssembler masm_;

Failure* failure_;

};

@@ -526,8 +521,11 @@ class BaseLoadStoreStubCompiler: public StubCompiler {

public:

BaseLoadStoreStubCompiler(Isolate* isolate,

Code::Kind kind,

+ ExtraICState extra_ic_state = kNoExtraICState,

InlineCacheHolderFlag cache_holder = OWN_MAP)

- : StubCompiler(isolate), kind_(kind), cache_holder_(cache_holder) {

+ : StubCompiler(isolate, extra_ic_state),

+ kind_(kind),

+ cache_holder_(cache_holder) {

InitializeRegisters();

}

virtual ~BaseLoadStoreStubCompiler() { }

@@ -558,7 +556,7 @@ class BaseLoadStoreStubCompiler: public StubCompiler {

}

protected:

- virtual Register HandlerFrontendHeader(Handle<Object> object,

+ virtual Register HandlerFrontendHeader(Handle<Type> type,

Handle<JSObject> holder,

Handle<Name> name,

@@ -566,7 +564,7 @@ class BaseLoadStoreStubCompiler: public StubCompiler {

virtual void HandlerFrontendFooter(Handle<Name> name, Label* miss) = 0;

- Register HandlerFrontend(Handle<Object> object,

+ Register HandlerFrontend(Handle<Type> type,

Handle<JSObject> holder,

Handle<Name> name);

@@ -599,7 +597,6 @@ class BaseLoadStoreStubCompiler: public StubCompiler {

}

void JitEvent(Handle<Name> name, Handle<Code> code);

- virtual Code::ExtraICState extra_state() { return Code::kNoExtraICState; }

virtual Register receiver() = 0;

virtual Register name() = 0;

virtual Register scratch1() = 0;

@@ -619,37 +616,39 @@ class BaseLoadStoreStubCompiler: public StubCompiler {

class LoadStubCompiler: public BaseLoadStoreStubCompiler {

public:

LoadStubCompiler(Isolate* isolate,

+ ExtraICState extra_ic_state = kNoExtraICState,

InlineCacheHolderFlag cache_holder = OWN_MAP,

Code::Kind kind = Code::LOAD_IC)

- : BaseLoadStoreStubCompiler(isolate, kind, cache_holder) { }

+ : BaseLoadStoreStubCompiler(isolate, kind, extra_ic_state,

+ cache_holder) { }

virtual ~LoadStubCompiler() { }

- Handle<Code> CompileLoadField(Handle<Object> object,

+ Handle<Code> CompileLoadField(Handle<Type> type,

Handle<JSObject> holder,

Handle<Name> name,

PropertyIndex index,

Representation representation);

- Handle<Code> CompileLoadCallback(Handle<Object> object,

+ Handle<Code> CompileLoadCallback(Handle<Type> type,

Handle<JSObject> holder,

Handle<Name> name,

Handle<ExecutableAccessorInfo> callback);

- Handle<Code> CompileLoadCallback(Handle<Object> object,

+ Handle<Code> CompileLoadCallback(Handle<Type> type,

Handle<JSObject> holder,

Handle<Name> name,

const CallOptimization& call_optimization);

- Handle<Code> CompileLoadConstant(Handle<Object> object,

+ Handle<Code> CompileLoadConstant(Handle<Type> type,

Handle<JSObject> holder,

Handle<Name> name,

Handle<Object> value);

- Handle<Code> CompileLoadInterceptor(Handle<Object> object,

+ Handle<Code> CompileLoadInterceptor(Handle<Type> type,

Handle<JSObject> holder,

Handle<Name> name);

- Handle<Code> CompileLoadViaGetter(Handle<Object> object,

+ Handle<Code> CompileLoadViaGetter(Handle<Type> type,

Handle<JSObject> holder,

Handle<Name> name,

Handle<JSFunction> getter);

@@ -658,12 +657,11 @@ class LoadStubCompiler: public BaseLoadStoreStubCompiler {

Handle<JSFunction> getter);

- Handle<Code> CompileLoadNonexistent(Handle<Object> object,

+ Handle<Code> CompileLoadNonexistent(Handle<Type> type,

Handle<JSObject> last,

- Handle<Name> name,

- Handle<JSGlobalObject> global);

+ Handle<Name> name);

- Handle<Code> CompileLoadGlobal(Handle<Object> object,

+ Handle<Code> CompileLoadGlobal(Handle<Type> type,

Handle<GlobalObject> holder,

Handle<PropertyCell> cell,

Handle<Name> name,

@@ -672,7 +670,7 @@ class LoadStubCompiler: public BaseLoadStoreStubCompiler {

static Register* registers();

protected:

- virtual Register HandlerFrontendHeader(Handle<Object> object,

+ virtual Register HandlerFrontendHeader(Handle<Type> type,

Handle<JSObject> holder,

Handle<Name> name,

@@ -680,15 +678,14 @@ class LoadStubCompiler: public BaseLoadStoreStubCompiler {

virtual void HandlerFrontendFooter(Handle<Name> name, Label* miss);

- Register CallbackHandlerFrontend(Handle<Object> object,

+ Register CallbackHandlerFrontend(Handle<Type> type,

Handle<JSObject> holder,

Handle<Name> name,

Handle<Object> callback);

- void NonexistentHandlerFrontend(Handle<Object> object,

+ void NonexistentHandlerFrontend(Handle<Type> type,

Handle<JSObject> last,

- Handle<Name> name,

- Handle<JSGlobalObject> global);

+ Handle<Name> name);

void GenerateLoadField(Register reg,

Handle<JSObject> holder,

@@ -720,8 +717,10 @@ class LoadStubCompiler: public BaseLoadStoreStubCompiler {

class KeyedLoadStubCompiler: public LoadStubCompiler {

public:

KeyedLoadStubCompiler(Isolate* isolate,

+ ExtraICState extra_ic_state = kNoExtraICState,

InlineCacheHolderFlag cache_holder = OWN_MAP)

- : LoadStubCompiler(isolate, cache_holder, Code::KEYED_LOAD_IC) { }

+ : LoadStubCompiler(isolate, extra_ic_state, cache_holder,

+ Code::KEYED_LOAD_IC) { }

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

@@ -744,10 +743,9 @@ class KeyedLoadStubCompiler: public LoadStubCompiler {

class StoreStubCompiler: public BaseLoadStoreStubCompiler {

public:

StoreStubCompiler(Isolate* isolate,

- StrictModeFlag strict_mode,

+ ExtraICState extra_ic_state,

Code::Kind kind = Code::STORE_IC)

- : BaseLoadStoreStubCompiler(isolate, kind),

- strict_mode_(strict_mode) { }

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

virtual ~StoreStubCompiler() { }

@@ -821,7 +819,7 @@ class StoreStubCompiler: public BaseLoadStoreStubCompiler {

}

protected:

- virtual Register HandlerFrontendHeader(Handle<Object> object,

+ virtual Register HandlerFrontendHeader(Handle<Type> type,

Handle<JSObject> holder,

Handle<Name> name,

@@ -838,14 +836,11 @@ class StoreStubCompiler: public BaseLoadStoreStubCompiler {

virtual Register scratch1() { return registers_[3]; }

virtual Register scratch2() { return registers_[4]; }

virtual Register scratch3() { return registers_[5]; }

- StrictModeFlag strict_mode() { return strict_mode_; }

- virtual Code::ExtraICState extra_state() { return strict_mode_; }

protected:

static Register* registers();

private:

- StrictModeFlag strict_mode_;

friend class BaseLoadStoreStubCompiler;

};

@@ -853,10 +848,8 @@ class StoreStubCompiler: public BaseLoadStoreStubCompiler {

class KeyedStoreStubCompiler: public StoreStubCompiler {

public:

KeyedStoreStubCompiler(Isolate* isolate,

- StrictModeFlag strict_mode,

- KeyedAccessStoreMode store_mode)

- : StoreStubCompiler(isolate, strict_mode, Code::KEYED_STORE_IC),

- store_mode_(store_mode) { }

+ ExtraICState extra_ic_state)

+ : StoreStubCompiler(isolate, extra_ic_state, Code::KEYED_STORE_IC) {}

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

@@ -869,11 +862,12 @@ class KeyedStoreStubCompiler: public StoreStubCompiler {

static void GenerateStoreDictionaryElement(MacroAssembler* masm);

protected:

- virtual Code::ExtraICState extra_state() {

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

- }

static Register* registers();

+ KeyedAccessStoreMode store_mode() {

+ return KeyedStoreIC::GetKeyedAccessStoreMode(extra_state());

+ }

private:

return registers()[3];

@@ -882,7 +876,6 @@ class KeyedStoreStubCompiler: public StoreStubCompiler {

virtual void GenerateNameCheck(Handle<Name> name,

Label* miss);

- KeyedAccessStoreMode store_mode_;

friend class BaseLoadStoreStubCompiler;

};

@@ -909,7 +902,7 @@ class CallStubCompiler: public StubCompiler {

CallStubCompiler(Isolate* isolate,

int argc,

Code::Kind kind,

- Code::ExtraICState extra_state,

+ ExtraICState extra_state,

InlineCacheHolderFlag cache_holder = OWN_MAP);

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

@@ -917,12 +910,29 @@ class CallStubCompiler: public StubCompiler {

PropertyIndex index,

Handle<Name> name);

- void CompileHandlerFrontend(Handle<Object> object,

- Handle<JSObject> holder,

- Handle<Name> name,

- CheckType check);

+ // Patch the global proxy over the global object if the global object is the

+ // receiver.

+ void PatchGlobalProxy(Handle<Object> object);

- void CompileHandlerBackend(Handle<JSFunction> function);

+ // Returns the register containing the holder of |name|.

+ Register HandlerFrontendHeader(Handle<Object> object,

+ Handle<JSObject> holder,

+ Handle<Name> name,

+ CheckType check,

+ Label* miss);

+ void HandlerFrontendFooter(Label* miss);

+ void GenerateJumpFunctionIgnoreReceiver(Handle<JSFunction> function);

+ void GenerateJumpFunction(Handle<Object> object,

+ Handle<JSFunction> function);

+ void GenerateJumpFunction(Handle<Object> object,

+ Register function,

+ Label* miss);

+ // Use to call |actual_closure|, a closure with the same shared function info

+ // as |function|.

+ void GenerateJumpFunction(Handle<Object> object,

+ Register actual_closure,

+ Handle<JSFunction> function);

Handle<Code> CompileCallConstant(Handle<Object> object,

Handle<JSObject> holder,

@@ -971,6 +981,8 @@ class CallStubCompiler: public StubCompiler {

Handle<JSFunction> function,

Handle<String> name);

+ CallKind call_kind();

Handle<Code> GetCode(Code::StubType type, Handle<Name> name);

Handle<Code> GetCode(Handle<JSFunction> function);

@@ -978,23 +990,19 @@ class CallStubCompiler: public StubCompiler {

void GenerateNameCheck(Handle<Name> name, Label* miss);

- void GenerateGlobalReceiverCheck(Handle<JSObject> object,

- Handle<JSObject> holder,

- Handle<Name> name,

- Label* miss);

// Generates code to load the function from the cell checking that

// it still contains the same function.

void GenerateLoadFunctionFromCell(Handle<Cell> cell,

Handle<JSFunction> function,

Label* miss);

+ void GenerateFunctionCheck(Register function, Register scratch, Label* miss);

// Generates a jump to CallIC miss stub.

void GenerateMissBranch();

const ParameterCount arguments_;

const Code::Kind kind_;

- const Code::ExtraICState extra_state_;

const InlineCacheHolderFlag cache_holder_;

};

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