diff options
Diffstat (limited to 'deps/v8/src/ia32/macro-assembler-ia32.h')
| -rw-r--r-- | deps/v8/src/ia32/macro-assembler-ia32.h | 64 |
1 files changed, 38 insertions, 26 deletions
diff --git a/deps/v8/src/ia32/macro-assembler-ia32.h b/deps/v8/src/ia32/macro-assembler-ia32.h index be11f66202..08cc7ceb64 100644 --- a/deps/v8/src/ia32/macro-assembler-ia32.h +++ b/deps/v8/src/ia32/macro-assembler-ia32.h @@ -19,18 +19,16 @@ const Register kReturnRegister1 = {Register::kCode_edx}; const Register kReturnRegister2 = {Register::kCode_edi}; const Register kJSFunctionRegister = {Register::kCode_edi}; const Register kContextRegister = {Register::kCode_esi}; +const Register kAllocateSizeRegister = {Register::kCode_edx}; const Register kInterpreterAccumulatorRegister = {Register::kCode_eax}; -const Register kInterpreterRegisterFileRegister = {Register::kCode_edx}; const Register kInterpreterBytecodeOffsetRegister = {Register::kCode_ecx}; const Register kInterpreterBytecodeArrayRegister = {Register::kCode_edi}; +const Register kInterpreterDispatchTableRegister = {Register::kCode_esi}; const Register kJavaScriptCallArgCountRegister = {Register::kCode_eax}; const Register kJavaScriptCallNewTargetRegister = {Register::kCode_edx}; const Register kRuntimeCallFunctionRegister = {Register::kCode_ebx}; const Register kRuntimeCallArgCountRegister = {Register::kCode_eax}; -// Spill slots used by interpreter dispatch calling convention. -const int kInterpreterDispatchTableSpillSlot = -1; - // Convenience for platform-independent signatures. We do not normally // distinguish memory operands from other operands on ia32. typedef Operand MemOperand; @@ -243,7 +241,7 @@ class MacroAssembler: public Assembler { // arguments in register eax and sets up the number of arguments in // register edi and the pointer to the first argument in register // esi. - void EnterExitFrame(int argc, bool save_doubles); + void EnterExitFrame(int argc, bool save_doubles, StackFrame::Type frame_type); void EnterApiExitFrame(int argc); @@ -511,6 +509,23 @@ class MacroAssembler: public Assembler { j(not_zero, not_smi_label, distance); } + // Jump if the value cannot be represented by a smi. + inline void JumpIfNotValidSmiValue(Register value, Register scratch, + Label* on_invalid, + Label::Distance distance = Label::kFar) { + mov(scratch, value); + add(scratch, Immediate(0x40000000U)); + j(sign, on_invalid, distance); + } + + // Jump if the unsigned integer value cannot be represented by a smi. + inline void JumpIfUIntNotValidSmiValue( + Register value, Label* on_invalid, + Label::Distance distance = Label::kFar) { + cmp(value, Immediate(0x40000000U)); + j(above_equal, on_invalid, distance); + } + void LoadInstanceDescriptors(Register map, Register descriptors); void EnumLength(Register dst, Register map); void NumberOfOwnDescriptors(Register dst, Register map); @@ -566,6 +581,10 @@ class MacroAssembler: public Assembler { // enabled via --debug-code. void AssertBoundFunction(Register object); + // Abort execution if argument is not a JSGeneratorObject, + // enabled via --debug-code. + void AssertGeneratorObject(Register object); + // Abort execution if argument is not a JSReceiver, enabled via --debug-code. void AssertReceiver(Register object); @@ -621,6 +640,14 @@ class MacroAssembler: public Assembler { void Allocate(Register object_size, Register result, Register result_end, Register scratch, Label* gc_required, AllocationFlags flags); + // FastAllocate is right now only used for folded allocations. It just + // increments the top pointer without checking against limit. This can only + // be done if it was proved earlier that the allocation will succeed. + void FastAllocate(int object_size, Register result, Register result_end, + AllocationFlags flags); + void FastAllocate(Register object_size, Register result, Register result_end, + AllocationFlags flags); + // Allocate a heap number in new space with undefined value. The // register scratch2 can be passed as no_reg; the others must be // valid registers. Returns tagged pointer in result register, or @@ -759,7 +786,8 @@ class MacroAssembler: public Assembler { void CallCFunction(Register function, int num_arguments); // Jump to a runtime routine. - void JumpToExternalReference(const ExternalReference& ext); + void JumpToExternalReference(const ExternalReference& ext, + bool builtin_exit_frame = false); // --------------------------------------------------------------------------- // Utilities @@ -904,6 +932,9 @@ class MacroAssembler: public Assembler { void EnterFrame(StackFrame::Type type, bool load_constant_pool_pointer_reg); void LeaveFrame(StackFrame::Type type); + void EnterBuiltinFrame(Register context, Register target, Register argc); + void LeaveBuiltinFrame(Register context, Register target, Register argc); + // Expects object in eax and returns map with validated enum cache // in eax. Assumes that any other register can be used as a scratch. void CheckEnumCache(Label* call_runtime); @@ -945,7 +976,7 @@ class MacroAssembler: public Assembler { Label::Distance done_distance, const CallWrapper& call_wrapper); - void EnterExitFramePrologue(); + void EnterExitFramePrologue(StackFrame::Type frame_type); void EnterExitFrameEpilogue(int argc, bool save_doubles); void LeaveExitFrameEpilogue(bool restore_context); @@ -1029,26 +1060,7 @@ inline Operand NativeContextOperand() { return ContextOperand(esi, Context::NATIVE_CONTEXT_INDEX); } -#ifdef GENERATED_CODE_COVERAGE -extern void LogGeneratedCodeCoverage(const char* file_line); -#define CODE_COVERAGE_STRINGIFY(x) #x -#define CODE_COVERAGE_TOSTRING(x) CODE_COVERAGE_STRINGIFY(x) -#define __FILE_LINE__ __FILE__ ":" CODE_COVERAGE_TOSTRING(__LINE__) -#define ACCESS_MASM(masm) { \ - byte* ia32_coverage_function = \ - reinterpret_cast<byte*>(FUNCTION_ADDR(LogGeneratedCodeCoverage)); \ - masm->pushfd(); \ - masm->pushad(); \ - masm->push(Immediate(reinterpret_cast<int>(&__FILE_LINE__))); \ - masm->call(ia32_coverage_function, RelocInfo::RUNTIME_ENTRY); \ - masm->pop(eax); \ - masm->popad(); \ - masm->popfd(); \ - } \ - masm-> -#else #define ACCESS_MASM(masm) masm-> -#endif } // namespace internal } // namespace v8 |