| 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);
|
|
|
|
|
Chromium Code Reviews
