Index: src/stub-cache.h |
=================================================================== |
--- src/stub-cache.h (revision 9808) |
+++ src/stub-cache.h (working copy) |
@@ -76,207 +76,171 @@ |
// Computes the right stub matching. Inserts the result in the |
// cache before returning. This might compile a stub if needed. |
- MUST_USE_RESULT MaybeObject* ComputeLoadNonexistent( |
- String* name, |
- JSObject* receiver); |
+ Handle<Code> ComputeLoadNonexistent(Handle<String> name, |
+ Handle<JSObject> receiver); |
- MUST_USE_RESULT MaybeObject* ComputeLoadField(String* name, |
- JSObject* receiver, |
- JSObject* holder, |
- int field_index); |
+ Handle<Code> ComputeLoadField(Handle<String> name, |
+ Handle<JSObject> receiver, |
+ Handle<JSObject> holder, |
+ int field_index); |
- MUST_USE_RESULT MaybeObject* ComputeLoadCallback( |
- String* name, |
- JSObject* receiver, |
- JSObject* holder, |
- AccessorInfo* callback); |
+ Handle<Code> ComputeLoadCallback(Handle<String> name, |
+ Handle<JSObject> receiver, |
+ Handle<JSObject> holder, |
+ Handle<AccessorInfo> callback); |
- MUST_USE_RESULT MaybeObject* ComputeLoadConstant(String* name, |
- JSObject* receiver, |
- JSObject* holder, |
- Object* value); |
+ Handle<Code> ComputeLoadConstant(Handle<String> name, |
+ Handle<JSObject> receiver, |
+ Handle<JSObject> holder, |
+ Handle<Object> value); |
- MUST_USE_RESULT MaybeObject* ComputeLoadInterceptor( |
- String* name, |
- JSObject* receiver, |
- JSObject* holder); |
+ Handle<Code> ComputeLoadInterceptor(Handle<String> name, |
+ Handle<JSObject> receiver, |
+ Handle<JSObject> holder); |
- MUST_USE_RESULT MaybeObject* ComputeLoadNormal(); |
+ Handle<Code> ComputeLoadNormal(); |
+ Handle<Code> ComputeLoadGlobal(Handle<String> name, |
+ Handle<JSObject> receiver, |
+ Handle<GlobalObject> holder, |
+ Handle<JSGlobalPropertyCell> cell, |
+ bool is_dont_delete); |
- MUST_USE_RESULT MaybeObject* ComputeLoadGlobal( |
- String* name, |
- JSObject* receiver, |
- GlobalObject* holder, |
- JSGlobalPropertyCell* cell, |
- bool is_dont_delete); |
- |
- |
// --- |
- MUST_USE_RESULT MaybeObject* ComputeKeyedLoadField(String* name, |
- JSObject* receiver, |
- JSObject* holder, |
- int field_index); |
+ Handle<Code> ComputeKeyedLoadField(Handle<String> name, |
+ Handle<JSObject> receiver, |
+ Handle<JSObject> holder, |
+ int field_index); |
- MUST_USE_RESULT MaybeObject* ComputeKeyedLoadCallback( |
- String* name, |
- JSObject* receiver, |
- JSObject* holder, |
- AccessorInfo* callback); |
+ Handle<Code> ComputeKeyedLoadCallback(Handle<String> name, |
+ Handle<JSObject> receiver, |
+ Handle<JSObject> holder, |
+ Handle<AccessorInfo> callback); |
- MUST_USE_RESULT MaybeObject* ComputeKeyedLoadConstant( |
- String* name, |
- JSObject* receiver, |
- JSObject* holder, |
- Object* value); |
+ Handle<Code> ComputeKeyedLoadConstant(Handle<String> name, |
+ Handle<JSObject> receiver, |
+ Handle<JSObject> holder, |
+ Handle<Object> value); |
- MUST_USE_RESULT MaybeObject* ComputeKeyedLoadInterceptor( |
- String* name, |
- JSObject* receiver, |
- JSObject* holder); |
+ Handle<Code> ComputeKeyedLoadInterceptor(Handle<String> name, |
+ Handle<JSObject> receiver, |
+ Handle<JSObject> holder); |
- MUST_USE_RESULT MaybeObject* ComputeKeyedLoadArrayLength( |
- String* name, |
- JSArray* receiver); |
+ Handle<Code> ComputeKeyedLoadArrayLength(Handle<String> name, |
+ Handle<JSArray> receiver); |
- MUST_USE_RESULT MaybeObject* ComputeKeyedLoadStringLength( |
- String* name, |
- String* receiver); |
+ Handle<Code> ComputeKeyedLoadStringLength(Handle<String> name, |
+ Handle<String> receiver); |
- MUST_USE_RESULT MaybeObject* ComputeKeyedLoadFunctionPrototype( |
- String* name, |
- JSFunction* receiver); |
+ Handle<Code> ComputeKeyedLoadFunctionPrototype(Handle<String> name, |
+ Handle<JSFunction> receiver); |
// --- |
- MUST_USE_RESULT MaybeObject* ComputeStoreField( |
- String* name, |
- JSObject* receiver, |
- int field_index, |
- Map* transition, |
- StrictModeFlag strict_mode); |
+ Handle<Code> ComputeStoreField(Handle<String> name, |
+ Handle<JSObject> receiver, |
+ int field_index, |
+ Handle<Map> transition, |
+ StrictModeFlag strict_mode); |
- MUST_USE_RESULT MaybeObject* ComputeStoreNormal( |
- StrictModeFlag strict_mode); |
+ Handle<Code> ComputeStoreNormal(StrictModeFlag strict_mode); |
- MUST_USE_RESULT MaybeObject* ComputeStoreGlobal( |
- String* name, |
- GlobalObject* receiver, |
- JSGlobalPropertyCell* cell, |
- StrictModeFlag strict_mode); |
+ Handle<Code> ComputeStoreGlobal(Handle<String> name, |
+ Handle<GlobalObject> receiver, |
+ Handle<JSGlobalPropertyCell> cell, |
+ StrictModeFlag strict_mode); |
- MUST_USE_RESULT MaybeObject* ComputeStoreCallback( |
- String* name, |
- JSObject* receiver, |
- AccessorInfo* callback, |
- StrictModeFlag strict_mode); |
+ Handle<Code> ComputeStoreCallback(Handle<String> name, |
+ Handle<JSObject> receiver, |
+ Handle<AccessorInfo> callback, |
+ StrictModeFlag strict_mode); |
- MUST_USE_RESULT MaybeObject* ComputeStoreInterceptor( |
- String* name, |
- JSObject* receiver, |
- StrictModeFlag strict_mode); |
+ Handle<Code> ComputeStoreInterceptor(Handle<String> name, |
+ Handle<JSObject> receiver, |
+ StrictModeFlag strict_mode); |
// --- |
- MUST_USE_RESULT MaybeObject* ComputeKeyedStoreField( |
- String* name, |
- JSObject* receiver, |
- int field_index, |
- Map* transition, |
- StrictModeFlag strict_mode); |
+ Handle<Code> ComputeKeyedStoreField(Handle<String> name, |
+ Handle<JSObject> receiver, |
+ int field_index, |
+ Handle<Map> transition, |
+ StrictModeFlag strict_mode); |
- MUST_USE_RESULT MaybeObject* ComputeKeyedLoadOrStoreElement( |
- JSObject* receiver, |
- KeyedIC::StubKind stub_kind, |
- StrictModeFlag strict_mode); |
+ Handle<Code> ComputeKeyedLoadOrStoreElement(Handle<JSObject> receiver, |
+ KeyedIC::StubKind stub_kind, |
+ StrictModeFlag strict_mode); |
// --- |
- MUST_USE_RESULT MaybeObject* ComputeCallField( |
- int argc, |
- Code::Kind, |
- Code::ExtraICState extra_ic_state, |
- String* name, |
- Object* object, |
- JSObject* holder, |
- int index); |
+ Handle<Code> ComputeCallField(int argc, |
+ Code::Kind, |
+ Code::ExtraICState extra_state, |
+ Handle<String> name, |
+ Handle<Object> object, |
+ Handle<JSObject> holder, |
+ int index); |
- MUST_USE_RESULT MaybeObject* ComputeCallConstant( |
- int argc, |
- Code::Kind, |
- Code::ExtraICState extra_ic_state, |
- String* name, |
- Object* object, |
- JSObject* holder, |
- JSFunction* function); |
+ Handle<Code> ComputeCallConstant(int argc, |
+ Code::Kind, |
+ Code::ExtraICState extra_state, |
+ Handle<String> name, |
+ Handle<Object> object, |
+ Handle<JSObject> holder, |
+ Handle<JSFunction> function); |
- MUST_USE_RESULT MaybeObject* ComputeCallNormal( |
- int argc, |
- Code::Kind, |
- Code::ExtraICState extra_ic_state, |
- String* name, |
- JSObject* receiver); |
+ Handle<Code> ComputeCallInterceptor(int argc, |
+ Code::Kind, |
+ Code::ExtraICState extra_state, |
+ Handle<String> name, |
+ Handle<Object> object, |
+ Handle<JSObject> holder); |
- MUST_USE_RESULT MaybeObject* ComputeCallInterceptor( |
- int argc, |
- Code::Kind, |
- Code::ExtraICState extra_ic_state, |
- String* name, |
- Object* object, |
- JSObject* holder); |
+ Handle<Code> ComputeCallGlobal(int argc, |
+ Code::Kind, |
+ Code::ExtraICState extra_state, |
+ Handle<String> name, |
+ Handle<JSObject> receiver, |
+ Handle<GlobalObject> holder, |
+ Handle<JSGlobalPropertyCell> cell, |
+ Handle<JSFunction> function); |
- MUST_USE_RESULT MaybeObject* ComputeCallGlobal( |
- int argc, |
- Code::Kind, |
- Code::ExtraICState extra_ic_state, |
- String* name, |
- JSObject* receiver, |
- GlobalObject* holder, |
- JSGlobalPropertyCell* cell, |
- JSFunction* function); |
- |
// --- |
- MUST_USE_RESULT MaybeObject* ComputeCallInitialize(int argc, |
- RelocInfo::Mode mode, |
- Code::Kind kind); |
+ Handle<Code> ComputeCallInitialize(int argc, RelocInfo::Mode mode); |
- Handle<Code> ComputeCallInitialize(int argc, |
- RelocInfo::Mode mode); |
- |
Handle<Code> ComputeKeyedCallInitialize(int argc); |
- MUST_USE_RESULT MaybeObject* ComputeCallPreMonomorphic( |
- int argc, |
- Code::Kind kind, |
- Code::ExtraICState extra_ic_state); |
+ Handle<Code> ComputeCallPreMonomorphic(int argc, |
+ Code::Kind kind, |
+ Code::ExtraICState extra_state); |
- MUST_USE_RESULT MaybeObject* ComputeCallNormal(int argc, |
- Code::Kind kind, |
- Code::ExtraICState state); |
+ Handle<Code> ComputeCallNormal(int argc, |
+ Code::Kind kind, |
+ Code::ExtraICState state); |
- MUST_USE_RESULT MaybeObject* ComputeCallArguments(int argc, |
- Code::Kind kind); |
+ Handle<Code> ComputeCallArguments(int argc, Code::Kind kind); |
- MUST_USE_RESULT MaybeObject* ComputeCallMegamorphic(int argc, |
- Code::Kind kind, |
- Code::ExtraICState state); |
+ Handle<Code> ComputeCallMegamorphic(int argc, |
+ Code::Kind kind, |
+ Code::ExtraICState state); |
- MUST_USE_RESULT MaybeObject* ComputeCallMiss(int argc, |
- Code::Kind kind, |
- Code::ExtraICState state); |
+ Handle<Code> ComputeCallMiss(int argc, |
+ Code::Kind kind, |
+ Code::ExtraICState state); |
+ MUST_USE_RESULT MaybeObject* TryComputeCallMiss(int argc, |
+ Code::Kind kind, |
+ Code::ExtraICState state); |
+ |
// Finds the Code object stored in the Heap::non_monomorphic_cache(). |
- MUST_USE_RESULT Code* FindCallInitialize(int argc, |
- RelocInfo::Mode mode, |
- Code::Kind kind); |
+ Code* FindCallInitialize(int argc, RelocInfo::Mode mode, Code::Kind kind); |
#ifdef ENABLE_DEBUGGER_SUPPORT |
- MUST_USE_RESULT MaybeObject* ComputeCallDebugBreak(int argc, Code::Kind kind); |
+ Handle<Code> ComputeCallDebugBreak(int argc, Code::Kind kind); |
- MUST_USE_RESULT MaybeObject* ComputeCallDebugPrepareStepIn(int argc, |
- Code::Kind kind); |
+ Handle<Code> ComputeCallDebugPrepareStepIn(int argc, Code::Kind kind); |
#endif |
// Update cache for entry hash(name, map). |
@@ -330,16 +294,14 @@ |
Isolate* isolate() { return isolate_; } |
Heap* heap() { return isolate()->heap(); } |
+ Factory* factory() { return isolate()->factory(); } |
private: |
explicit StubCache(Isolate* isolate); |
- friend class Isolate; |
- friend class SCTableReference; |
- static const int kPrimaryTableSize = 2048; |
- static const int kSecondaryTableSize = 512; |
- Entry primary_[kPrimaryTableSize]; |
- Entry secondary_[kSecondaryTableSize]; |
+ Handle<Code> ComputeCallInitialize(int argc, |
+ RelocInfo::Mode mode, |
+ Code::Kind kind); |
// Computes the hashed offsets for primary and secondary caches. |
static int PrimaryOffset(String* name, Code::Flags flags, Map* map) { |
@@ -384,8 +346,16 @@ |
reinterpret_cast<Address>(table) + (offset << shift_amount)); |
} |
+ static const int kPrimaryTableSize = 2048; |
+ static const int kSecondaryTableSize = 512; |
+ |
+ Entry primary_[kPrimaryTableSize]; |
+ Entry secondary_[kSecondaryTableSize]; |
Isolate* isolate_; |
+ friend class Isolate; |
+ friend class SCTableReference; |
+ |
DISALLOW_COPY_AND_ASSIGN(StubCache); |
}; |
@@ -407,21 +377,26 @@ |
DECLARE_RUNTIME_FUNCTION(MaybeObject*, KeyedLoadPropertyWithInterceptor); |
-// The stub compiler compiles stubs for the stub cache. |
+// The stub compilers compile stubs for the stub cache. |
class StubCompiler BASE_EMBEDDED { |
public: |
- StubCompiler() |
- : scope_(), masm_(Isolate::Current(), NULL, 256), failure_(NULL) { } |
+ explicit StubCompiler(Isolate* isolate) |
+ : isolate_(isolate), masm_(isolate, NULL, 256), failure_(NULL) { } |
- MUST_USE_RESULT MaybeObject* CompileCallInitialize(Code::Flags flags); |
- MUST_USE_RESULT MaybeObject* CompileCallPreMonomorphic(Code::Flags flags); |
- MUST_USE_RESULT MaybeObject* CompileCallNormal(Code::Flags flags); |
- MUST_USE_RESULT MaybeObject* CompileCallMegamorphic(Code::Flags flags); |
- MUST_USE_RESULT MaybeObject* CompileCallArguments(Code::Flags flags); |
- MUST_USE_RESULT MaybeObject* CompileCallMiss(Code::Flags flags); |
+ // Functions to compile either CallIC or KeyedCallIC. The specific kind |
+ // is extracted from the code flags. |
+ Handle<Code> CompileCallInitialize(Code::Flags flags); |
+ Handle<Code> CompileCallPreMonomorphic(Code::Flags flags); |
+ Handle<Code> CompileCallNormal(Code::Flags flags); |
+ Handle<Code> CompileCallMegamorphic(Code::Flags flags); |
+ Handle<Code> CompileCallArguments(Code::Flags flags); |
+ Handle<Code> CompileCallMiss(Code::Flags flags); |
+ |
+ MUST_USE_RESULT MaybeObject* TryCompileCallMiss(Code::Flags flags); |
+ |
#ifdef ENABLE_DEBUGGER_SUPPORT |
- MUST_USE_RESULT MaybeObject* CompileCallDebugBreak(Code::Flags flags); |
- MUST_USE_RESULT MaybeObject* CompileCallDebugPrepareStepIn(Code::Flags flags); |
+ Handle<Code> CompileCallDebugBreak(Code::Flags flags); |
+ Handle<Code> CompileCallDebugPrepareStepIn(Code::Flags flags); |
#endif |
// Static functions for generating parts of stubs. |
@@ -441,8 +416,10 @@ |
Label* miss); |
static void GenerateFastPropertyLoad(MacroAssembler* masm, |
- Register dst, Register src, |
- JSObject* holder, int index); |
+ Register dst, |
+ Register src, |
+ Handle<JSObject> holder, |
+ int index); |
static void GenerateLoadArrayLength(MacroAssembler* masm, |
Register receiver, |
@@ -463,9 +440,9 @@ |
Label* miss_label); |
static void GenerateStoreField(MacroAssembler* masm, |
- JSObject* object, |
+ Handle<JSObject> object, |
int index, |
- Map* transition, |
+ Handle<Map> transition, |
Register receiver_reg, |
Register name_reg, |
Register scratch, |
@@ -491,7 +468,30 @@ |
// 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 object_reg, |
+ Handle<JSObject> holder, |
+ Register holder_reg, |
+ Register scratch1, |
+ Register scratch2, |
+ Handle<String> name, |
+ Label* miss) { |
+ return CheckPrototypes(object, object_reg, holder, holder_reg, scratch1, |
+ scratch2, name, kInvalidProtoDepth, miss); |
+ } |
+ Register CheckPrototypes(Handle<JSObject> object, |
+ Register object_reg, |
+ Handle<JSObject> holder, |
+ Register holder_reg, |
+ Register scratch1, |
+ Register scratch2, |
+ Handle<String> name, |
+ int save_at_depth, |
+ Label* miss); |
+ |
+ // TODO(kmillikin): Eliminate this function when the stub cache is fully |
+ // handlified. |
Register CheckPrototypes(JSObject* object, |
Register object_reg, |
JSObject* holder, |
@@ -504,6 +504,8 @@ |
scratch2, name, kInvalidProtoDepth, miss); |
} |
+ // TODO(kmillikin): Eliminate this function when the stub cache is fully |
+ // handlified. |
Register CheckPrototypes(JSObject* object, |
Register object_reg, |
JSObject* holder, |
@@ -515,20 +517,25 @@ |
Label* miss); |
protected: |
- MaybeObject* GetCodeWithFlags(Code::Flags flags, const char* name); |
- MaybeObject* GetCodeWithFlags(Code::Flags flags, String* name); |
+ Handle<Code> GetCodeWithFlags(Code::Flags flags, const char* name); |
+ Handle<Code> GetCodeWithFlags(Code::Flags flags, Handle<String> name); |
+ MUST_USE_RESULT MaybeObject* TryGetCodeWithFlags(Code::Flags flags, |
+ const char* name); |
+ MUST_USE_RESULT MaybeObject* TryGetCodeWithFlags(Code::Flags flags, |
+ String* name); |
+ |
MacroAssembler* masm() { return &masm_; } |
void set_failure(Failure* failure) { failure_ = failure; } |
- void GenerateLoadField(JSObject* object, |
- JSObject* holder, |
+ void GenerateLoadField(Handle<JSObject> object, |
+ Handle<JSObject> holder, |
Register receiver, |
Register scratch1, |
Register scratch2, |
Register scratch3, |
int index, |
- String* name, |
+ Handle<String> name, |
Label* miss); |
MaybeObject* GenerateLoadCallback(JSObject* object, |
@@ -542,14 +549,14 @@ |
String* name, |
Label* miss); |
- void GenerateLoadConstant(JSObject* object, |
- JSObject* holder, |
+ void GenerateLoadConstant(Handle<JSObject> object, |
+ Handle<JSObject> holder, |
Register receiver, |
Register scratch1, |
Register scratch2, |
Register scratch3, |
- Object* value, |
- String* name, |
+ Handle<Object> value, |
+ Handle<String> name, |
Label* miss); |
void GenerateLoadInterceptor(JSObject* object, |
@@ -567,12 +574,12 @@ |
String* name, |
LookupResult* lookup); |
- Isolate* isolate() { return scope_.isolate(); } |
+ Isolate* isolate() { return isolate_; } |
Heap* heap() { return isolate()->heap(); } |
Factory* factory() { return isolate()->factory(); } |
private: |
- HandleScope scope_; |
+ Isolate* isolate_; |
MacroAssembler masm_; |
Failure* failure_; |
}; |
@@ -580,71 +587,96 @@ |
class LoadStubCompiler: public StubCompiler { |
public: |
- MUST_USE_RESULT MaybeObject* CompileLoadNonexistent(String* name, |
- JSObject* object, |
- JSObject* last); |
+ explicit LoadStubCompiler(Isolate* isolate) : StubCompiler(isolate) { } |
- MUST_USE_RESULT MaybeObject* CompileLoadField(JSObject* object, |
- JSObject* holder, |
- int index, |
- String* name); |
+ Handle<Code> CompileLoadNonexistent(Handle<String> name, |
+ Handle<JSObject> object, |
+ Handle<JSObject> last); |
+ Handle<Code> CompileLoadField(Handle<JSObject> object, |
+ Handle<JSObject> holder, |
+ int index, |
+ Handle<String> name); |
+ |
+ Handle<Code> CompileLoadCallback(Handle<String> name, |
+ Handle<JSObject> object, |
+ Handle<JSObject> holder, |
+ Handle<AccessorInfo> callback); |
+ |
MUST_USE_RESULT MaybeObject* CompileLoadCallback(String* name, |
JSObject* object, |
JSObject* holder, |
AccessorInfo* callback); |
- MUST_USE_RESULT MaybeObject* CompileLoadConstant(JSObject* object, |
- JSObject* holder, |
- Object* value, |
- String* name); |
+ Handle<Code> CompileLoadConstant(Handle<JSObject> object, |
+ Handle<JSObject> holder, |
+ Handle<Object> value, |
+ Handle<String> name); |
+ Handle<Code> CompileLoadInterceptor(Handle<JSObject> object, |
+ Handle<JSObject> holder, |
+ Handle<String> name); |
+ |
MUST_USE_RESULT MaybeObject* CompileLoadInterceptor(JSObject* object, |
JSObject* holder, |
String* name); |
- MUST_USE_RESULT MaybeObject* CompileLoadGlobal(JSObject* object, |
- GlobalObject* holder, |
- JSGlobalPropertyCell* cell, |
- String* name, |
- bool is_dont_delete); |
+ Handle<Code> CompileLoadGlobal(Handle<JSObject> object, |
+ Handle<GlobalObject> holder, |
+ Handle<JSGlobalPropertyCell> cell, |
+ Handle<String> name, |
+ bool is_dont_delete); |
private: |
- MUST_USE_RESULT MaybeObject* GetCode(PropertyType type, String* name); |
+ MUST_USE_RESULT MaybeObject* TryGetCode(PropertyType type, String* name); |
+ |
+ Handle<Code> GetCode(PropertyType type, Handle<String> name); |
}; |
class KeyedLoadStubCompiler: public StubCompiler { |
public: |
- MUST_USE_RESULT MaybeObject* CompileLoadField(String* name, |
- JSObject* object, |
- JSObject* holder, |
- int index); |
+ explicit KeyedLoadStubCompiler(Isolate* isolate) : StubCompiler(isolate) { } |
+ Handle<Code> CompileLoadField(Handle<String> name, |
+ Handle<JSObject> object, |
+ Handle<JSObject> holder, |
+ int index); |
+ |
+ Handle<Code> CompileLoadCallback(Handle<String> name, |
+ Handle<JSObject> object, |
+ Handle<JSObject> holder, |
+ Handle<AccessorInfo> callback); |
+ |
MUST_USE_RESULT MaybeObject* CompileLoadCallback(String* name, |
JSObject* object, |
JSObject* holder, |
AccessorInfo* callback); |
- MUST_USE_RESULT MaybeObject* CompileLoadConstant(String* name, |
- JSObject* object, |
- JSObject* holder, |
- Object* value); |
+ Handle<Code> CompileLoadConstant(Handle<String> name, |
+ Handle<JSObject> object, |
+ Handle<JSObject> holder, |
+ Handle<Object> value); |
+ Handle<Code> CompileLoadInterceptor(Handle<JSObject> object, |
+ Handle<JSObject> holder, |
+ Handle<String> name); |
+ |
MUST_USE_RESULT MaybeObject* CompileLoadInterceptor(JSObject* object, |
JSObject* holder, |
String* name); |
- MUST_USE_RESULT MaybeObject* CompileLoadArrayLength(String* name); |
- MUST_USE_RESULT MaybeObject* CompileLoadStringLength(String* name); |
- MUST_USE_RESULT MaybeObject* CompileLoadFunctionPrototype(String* name); |
+ Handle<Code> CompileLoadArrayLength(Handle<String> name); |
- MUST_USE_RESULT MaybeObject* CompileLoadElement(Map* receiver_map); |
+ Handle<Code> CompileLoadStringLength(Handle<String> name); |
- MUST_USE_RESULT MaybeObject* CompileLoadPolymorphic( |
- MapList* receiver_maps, |
- CodeList* handler_ics); |
+ Handle<Code> CompileLoadFunctionPrototype(Handle<String> name); |
+ Handle<Code> CompileLoadElement(Handle<Map> receiver_map); |
+ |
+ Handle<Code> CompileLoadPolymorphic(MapHandleList* receiver_maps, |
+ CodeHandleList* handler_ics); |
+ |
static void GenerateLoadExternalArray(MacroAssembler* masm, |
ElementsKind elements_kind); |
@@ -655,34 +687,40 @@ |
static void GenerateLoadDictionaryElement(MacroAssembler* masm); |
private: |
- MaybeObject* GetCode(PropertyType type, |
- String* name, |
+ MaybeObject* TryGetCode(PropertyType type, |
+ String* name, |
+ InlineCacheState state = MONOMORPHIC); |
+ |
+ Handle<Code> GetCode(PropertyType type, |
+ Handle<String> name, |
InlineCacheState state = MONOMORPHIC); |
}; |
class StoreStubCompiler: public StubCompiler { |
public: |
- explicit StoreStubCompiler(StrictModeFlag strict_mode) |
- : strict_mode_(strict_mode) { } |
+ StoreStubCompiler(Isolate* isolate, StrictModeFlag strict_mode) |
+ : StubCompiler(isolate), strict_mode_(strict_mode) { } |
- MUST_USE_RESULT MaybeObject* CompileStoreField(JSObject* object, |
- int index, |
- Map* transition, |
- String* name); |
- MUST_USE_RESULT MaybeObject* CompileStoreCallback(JSObject* object, |
- AccessorInfo* callbacks, |
- String* name); |
- MUST_USE_RESULT MaybeObject* CompileStoreInterceptor(JSObject* object, |
- String* name); |
- MUST_USE_RESULT MaybeObject* CompileStoreGlobal(GlobalObject* object, |
- JSGlobalPropertyCell* holder, |
- String* name); |
+ Handle<Code> CompileStoreField(Handle<JSObject> object, |
+ int index, |
+ Handle<Map> transition, |
+ Handle<String> name); |
+ Handle<Code> CompileStoreCallback(Handle<JSObject> object, |
+ Handle<AccessorInfo> callback, |
+ Handle<String> name); |
+ Handle<Code> CompileStoreInterceptor(Handle<JSObject> object, |
+ Handle<String> name); |
+ |
+ Handle<Code> CompileStoreGlobal(Handle<GlobalObject> object, |
+ Handle<JSGlobalPropertyCell> holder, |
+ Handle<String> name); |
+ |
private: |
- MaybeObject* GetCode(PropertyType type, String* name); |
+ Handle<Code> GetCode(PropertyType type, Handle<String> name); |
StrictModeFlag strict_mode_; |
}; |
@@ -690,20 +728,19 @@ |
class KeyedStoreStubCompiler: public StubCompiler { |
public: |
- explicit KeyedStoreStubCompiler(StrictModeFlag strict_mode) |
- : strict_mode_(strict_mode) { } |
+ KeyedStoreStubCompiler(Isolate* isolate, StrictModeFlag strict_mode) |
+ : StubCompiler(isolate), strict_mode_(strict_mode) { } |
- MUST_USE_RESULT MaybeObject* CompileStoreField(JSObject* object, |
- int index, |
- Map* transition, |
- String* name); |
+ Handle<Code> CompileStoreField(Handle<JSObject> object, |
+ int index, |
+ Handle<Map> transition, |
+ Handle<String> name); |
- MUST_USE_RESULT MaybeObject* CompileStoreElement(Map* receiver_map); |
+ Handle<Code> CompileStoreElement(Handle<Map> receiver_map); |
- MUST_USE_RESULT MaybeObject* CompileStorePolymorphic( |
- MapList* receiver_maps, |
- CodeList* handler_stubs, |
- MapList* transitioned_maps); |
+ Handle<Code> CompileStorePolymorphic(MapHandleList* receiver_maps, |
+ CodeHandleList* handler_stubs, |
+ MapHandleList* transitioned_maps); |
static void GenerateStoreFastElement(MacroAssembler* masm, |
bool is_js_array, |
@@ -718,8 +755,8 @@ |
static void GenerateStoreDictionaryElement(MacroAssembler* masm); |
private: |
- MaybeObject* GetCode(PropertyType type, |
- String* name, |
+ Handle<Code> GetCode(PropertyType type, |
+ Handle<String> name, |
InlineCacheState state = MONOMORPHIC); |
StrictModeFlag strict_mode_; |
@@ -742,36 +779,49 @@ |
class CallStubCompiler: public StubCompiler { |
public: |
- CallStubCompiler(int argc, |
+ CallStubCompiler(Isolate* isolate, |
+ int argc, |
Code::Kind kind, |
- Code::ExtraICState extra_ic_state, |
+ Code::ExtraICState extra_state, |
InlineCacheHolderFlag cache_holder); |
- MUST_USE_RESULT MaybeObject* CompileCallField( |
- JSObject* object, |
- JSObject* holder, |
- int index, |
- String* name); |
+ Handle<Code> CompileCallField(Handle<JSObject> object, |
+ Handle<JSObject> holder, |
+ int index, |
+ Handle<String> name); |
- MUST_USE_RESULT MaybeObject* CompileCallConstant( |
- Object* object, |
- JSObject* holder, |
- JSFunction* function, |
- String* name, |
- CheckType check); |
+ Handle<Code> CompileCallConstant(Handle<Object> object, |
+ Handle<JSObject> holder, |
+ Handle<JSFunction> function, |
+ Handle<String> name, |
+ CheckType check); |
- MUST_USE_RESULT MaybeObject* CompileCallInterceptor( |
- JSObject* object, |
- JSObject* holder, |
- String* name); |
+ MUST_USE_RESULT MaybeObject* CompileCallConstant(Object* object, |
+ JSObject* holder, |
+ JSFunction* function, |
+ String* name, |
+ CheckType check); |
- MUST_USE_RESULT MaybeObject* CompileCallGlobal( |
- JSObject* object, |
- GlobalObject* holder, |
- JSGlobalPropertyCell* cell, |
- JSFunction* function, |
- String* name); |
+ Handle<Code> CompileCallInterceptor(Handle<JSObject> object, |
+ Handle<JSObject> holder, |
+ Handle<String> name); |
+ MUST_USE_RESULT MaybeObject* CompileCallInterceptor(JSObject* object, |
+ JSObject* holder, |
+ String* name); |
+ |
+ Handle<Code> CompileCallGlobal(Handle<JSObject> object, |
+ Handle<GlobalObject> holder, |
+ Handle<JSGlobalPropertyCell> cell, |
+ Handle<JSFunction> function, |
+ Handle<String> name); |
+ |
+ MUST_USE_RESULT MaybeObject* CompileCallGlobal(JSObject* object, |
+ GlobalObject* holder, |
+ JSGlobalPropertyCell* cell, |
+ JSFunction* function, |
+ String* name); |
+ |
static bool HasCustomCallGenerator(JSFunction* function); |
private: |
@@ -803,18 +853,20 @@ |
const ParameterCount arguments_; |
const Code::Kind kind_; |
- const Code::ExtraICState extra_ic_state_; |
+ const Code::ExtraICState extra_state_; |
const InlineCacheHolderFlag cache_holder_; |
const ParameterCount& arguments() { return arguments_; } |
- MUST_USE_RESULT MaybeObject* GetCode(PropertyType type, String* name); |
+ Handle<Code> GetCode(PropertyType type, Handle<String> name); |
+ Handle<Code> GetCode(Handle<JSFunction> function); |
- // Convenience function. Calls GetCode above passing |
- // CONSTANT_FUNCTION type and the name of the given function. |
- MUST_USE_RESULT MaybeObject* GetCode(JSFunction* function); |
+ // TODO(kmillikin): Eliminate these functions when the stub cache is fully |
+ // handlified. |
+ MUST_USE_RESULT MaybeObject* TryGetCode(PropertyType type, String* name); |
+ MUST_USE_RESULT MaybeObject* TryGetCode(JSFunction* function); |
- void GenerateNameCheck(String* name, Label* miss); |
+ void GenerateNameCheck(Handle<String> name, Label* miss); |
void GenerateGlobalReceiverCheck(JSObject* object, |
JSObject* holder, |
@@ -827,15 +879,18 @@ |
JSFunction* function, |
Label* miss); |
- // Generates a jump to CallIC miss stub. Returns Failure if the jump cannot |
- // be generated. |
- MUST_USE_RESULT MaybeObject* GenerateMissBranch(); |
+ // Generates a jump to CallIC miss stub. |
+ void GenerateMissBranch(); |
+ |
+ // TODO(kmillikin): Eliminate this function when the stub cache is fully |
+ // handlified. |
+ MUST_USE_RESULT MaybeObject* TryGenerateMissBranch(); |
}; |
class ConstructStubCompiler: public StubCompiler { |
public: |
- explicit ConstructStubCompiler() {} |
+ explicit ConstructStubCompiler(Isolate* isolate) : StubCompiler(isolate) { } |
MUST_USE_RESULT MaybeObject* CompileConstructStub(JSFunction* function); |