2008-12-04 Gavin Barraclough <barraclough@apple.com>
Reviewed by Geoff Garen.
Start porting the JIT to use the MacroAssembler.
https://bugs.webkit.org/show_bug.cgi?id=22671
No change in performance.
* assembler/MacroAssembler.h:
(JSC::MacroAssembler::Jump::operator X86Assembler::JmpSrc):
(JSC::MacroAssembler::add32):
(JSC::MacroAssembler::and32):
(JSC::MacroAssembler::lshift32):
(JSC::MacroAssembler::rshift32):
(JSC::MacroAssembler::storePtr):
(JSC::MacroAssembler::store32):
(JSC::MacroAssembler::poke):
(JSC::MacroAssembler::move):
(JSC::MacroAssembler::compareImm32ForBranchEquality):
(JSC::MacroAssembler::jnePtr):
(JSC::MacroAssembler::jnset32):
(JSC::MacroAssembler::jset32):
(JSC::MacroAssembler::jzeroSub32):
(JSC::MacroAssembler::joverAdd32):
(JSC::MacroAssembler::call):
* assembler/X86Assembler.h:
(JSC::X86Assembler::shll_i8r):
* jit/JIT.cpp:
(JSC::JIT::privateCompileMainPass):
(JSC::JIT::privateCompile):
(JSC::JIT::privateCompileCTIMachineTrampolines):
* jit/JIT.h:
* jit/JITArithmetic.cpp:
(JSC::JIT::compileBinaryArithOp):
* jit/JITInlineMethods.h:
(JSC::JIT::emitGetVirtualRegister):
(JSC::JIT::emitPutCTIArg):
(JSC::JIT::emitPutCTIArgConstant):
(JSC::JIT::emitGetCTIArg):
(JSC::JIT::emitPutCTIArgFromVirtualRegister):
(JSC::JIT::emitPutCTIParam):
(JSC::JIT::emitGetCTIParam):
(JSC::JIT::emitPutToCallFrameHeader):
(JSC::JIT::emitPutImmediateToCallFrameHeader):
(JSC::JIT::emitGetFromCallFrameHeader):
(JSC::JIT::emitPutVirtualRegister):
(JSC::JIT::emitInitRegister):
(JSC::JIT::emitNakedCall):
(JSC::JIT::restoreArgumentReference):
(JSC::JIT::restoreArgumentReferenceForTrampoline):
(JSC::JIT::emitCTICall):
(JSC::JIT::checkStructure):
(JSC::JIT::emitJumpSlowCaseIfNotJSCell):
(JSC::JIT::emitJumpSlowCaseIfNotImmNum):
(JSC::JIT::emitJumpSlowCaseIfNotImmNums):
(JSC::JIT::emitFastArithDeTagImmediate):
(JSC::JIT::emitFastArithDeTagImmediateJumpIfZero):
(JSC::JIT::emitFastArithReTagImmediate):
(JSC::JIT::emitFastArithPotentiallyReTagImmediate):
(JSC::JIT::emitFastArithImmToInt):
(JSC::JIT::emitFastArithIntToImmOrSlowCase):
(JSC::JIT::emitFastArithIntToImmNoCheck):
(JSC::JIT::emitTagAsBoolImmediate):
* jit/JITPropertyAccess.cpp:
(JSC::JIT::privateCompilePutByIdTransition):
git-svn-id: http://svn.webkit.org/repository/webkit/trunk@39020 268f45cc-cd09-0410-ab3c-d52691b4dbfc
diff --git a/JavaScriptCore/jit/JIT.cpp b/JavaScriptCore/jit/JIT.cpp
index a382f51..f3565b5 100644
--- a/JavaScriptCore/jit/JIT.cpp
+++ b/JavaScriptCore/jit/JIT.cpp
@@ -565,7 +565,7 @@
case op_get_scoped_var: {
int skip = instruction[i + 3].u.operand + m_codeBlock->needsFullScopeChain;
- emitGetVirtualRegister(RegisterFile::ScopeChain, X86::eax, i);
+ emitGetFromCallFrameHeader(RegisterFile::ScopeChain, X86::eax);
while (skip--)
__ movl_mr(FIELD_OFFSET(ScopeChainNode, next), X86::eax, X86::eax);
@@ -578,7 +578,7 @@
case op_put_scoped_var: {
int skip = instruction[i + 2].u.operand + m_codeBlock->needsFullScopeChain;
- emitGetVirtualRegister(RegisterFile::ScopeChain, X86::edx, i);
+ emitGetFromCallFrameHeader(RegisterFile::ScopeChain, X86::edx);
emitGetVirtualRegister(instruction[i + 3].u.operand, X86::eax, i);
while (skip--)
__ movl_mr(FIELD_OFFSET(ScopeChainNode, next), X86::edx, X86::edx);
@@ -608,10 +608,10 @@
emitGetVirtualRegister(instruction[i + 1].u.operand, X86::eax, i);
// Grab the return address.
- emitGetVirtualRegister(RegisterFile::ReturnPC, X86::edx, i);
+ emitGetFromCallFrameHeader(RegisterFile::ReturnPC, X86::edx);
// Restore our caller's "r".
- emitGetVirtualRegister(RegisterFile::CallerFrame, X86::edi, i);
+ emitGetFromCallFrameHeader(RegisterFile::CallerFrame, X86::edi);
// Return.
__ pushl_r(X86::edx);
@@ -947,7 +947,7 @@
}
case op_eq: {
emitGetVirtualRegisters(instruction[i + 2].u.operand, X86::eax, instruction[i + 3].u.operand, X86::edx, i);
- emitJumpSlowCaseIfNotImmNums(X86::eax, X86::edx, i);
+ emitJumpSlowCaseIfNotImmNums(X86::eax, X86::edx, X86::ecx, i);
__ cmpl_rr(X86::edx, X86::eax);
__ sete_r(X86::eax);
__ movzbl_rr(X86::eax, X86::eax);
@@ -1071,7 +1071,7 @@
CTI_COMPILE_BINARY_OP(op_less)
case op_neq: {
emitGetVirtualRegisters(instruction[i + 2].u.operand, X86::eax, instruction[i + 3].u.operand, X86::edx, i);
- emitJumpSlowCaseIfNotImmNums(X86::eax, X86::edx, i);
+ emitJumpSlowCaseIfNotImmNums(X86::eax, X86::edx, X86::ecx, i);
__ cmpl_rr(X86::eax, X86::edx);
__ setne_r(X86::eax);
@@ -1098,7 +1098,7 @@
CTI_COMPILE_BINARY_OP(op_urshift)
case op_bitxor: {
emitGetVirtualRegisters(instruction[i + 2].u.operand, X86::eax, instruction[i + 3].u.operand, X86::edx, i);
- emitJumpSlowCaseIfNotImmNums(X86::eax, X86::edx, i);
+ emitJumpSlowCaseIfNotImmNums(X86::eax, X86::edx, X86::ecx, i);
__ xorl_rr(X86::edx, X86::eax);
emitFastArithReTagImmediate(X86::eax);
emitPutVirtualRegister(instruction[i + 1].u.operand);
@@ -1115,7 +1115,7 @@
}
case op_bitor: {
emitGetVirtualRegisters(instruction[i + 2].u.operand, X86::eax, instruction[i + 3].u.operand, X86::edx, i);
- emitJumpSlowCaseIfNotImmNums(X86::eax, X86::edx, i);
+ emitJumpSlowCaseIfNotImmNums(X86::eax, X86::edx, X86::ecx, i);
__ orl_rr(X86::edx, X86::eax);
emitPutVirtualRegister(instruction[i + 1].u.operand);
i += 5;
@@ -2005,7 +2005,7 @@
JmpDst afterRegisterFileCheck;
if (m_codeBlock->codeType == FunctionCode) {
// In the case of a fast linked call, we do not set this up in the caller.
- __ movl_i32m(reinterpret_cast<unsigned>(m_codeBlock), RegisterFile::CodeBlock * static_cast<int>(sizeof(Register)), X86::edi);
+ emitPutImmediateToCallFrameHeader(m_codeBlock, RegisterFile::CodeBlock);
emitGetCTIParam(CTI_ARGS_registerFile, X86::eax);
__ leal_mr(m_codeBlock->numCalleeRegisters * sizeof(Register), X86::edi, X86::edx);
@@ -2140,7 +2140,7 @@
__ testl_rr(X86::eax, X86::eax);
JmpSrc hasCodeBlock1 = __ jne();
__ popl_r(X86::ebx);
- __ restoreArgumentReference();
+ restoreArgumentReference();
emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
JmpSrc callJSFunction1 = __ call();
emitGetCTIArg(0, X86::ecx);
@@ -2154,7 +2154,7 @@
__ popl_r(X86::ebx);
emitPutCTIArg(X86::ebx, 4);
emitPutCTIArg(X86::eax, 12);
- __ restoreArgumentReference();
+ restoreArgumentReference();
emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
JmpSrc callArityCheck1 = __ call();
__ movl_rr(X86::edx, X86::edi);
@@ -2167,7 +2167,7 @@
__ popl_r(X86::ebx);
emitPutCTIArg(X86::ebx, 4);
- __ restoreArgumentReference();
+ restoreArgumentReference();
emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
JmpSrc callDontLazyLinkCall = __ call();
__ pushl_r(X86::ebx);
@@ -2182,7 +2182,7 @@
__ testl_rr(X86::eax, X86::eax);
JmpSrc hasCodeBlock2 = __ jne();
__ popl_r(X86::ebx);
- __ restoreArgumentReference();
+ restoreArgumentReference();
emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
JmpSrc callJSFunction2 = __ call();
emitGetCTIArg(0, X86::ecx);
@@ -2196,7 +2196,7 @@
__ popl_r(X86::ebx);
emitPutCTIArg(X86::ebx, 4);
emitPutCTIArg(X86::eax, 12);
- __ restoreArgumentReference();
+ restoreArgumentReference();
emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
JmpSrc callArityCheck2 = __ call();
__ movl_rr(X86::edx, X86::edi);
@@ -2209,7 +2209,7 @@
__ popl_r(X86::ebx);
emitPutCTIArg(X86::ebx, 4);
- __ restoreArgumentReference();
+ restoreArgumentReference();
emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
JmpSrc callLazyLinkCall = __ call();
__ pushl_r(X86::ebx);
@@ -2224,7 +2224,7 @@
__ testl_rr(X86::eax, X86::eax);
JmpSrc hasCodeBlock3 = __ jne();
__ popl_r(X86::ebx);
- __ restoreArgumentReference();
+ restoreArgumentReference();
emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
JmpSrc callJSFunction3 = __ call();
emitGetCTIArg(0, X86::ecx);
@@ -2238,7 +2238,7 @@
__ popl_r(X86::ebx);
emitPutCTIArg(X86::ebx, 4);
emitPutCTIArg(X86::eax, 12);
- __ restoreArgumentReference();
+ restoreArgumentReference();
emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
JmpSrc callArityCheck3 = __ call();
__ movl_rr(X86::edx, X86::edi);
diff --git a/JavaScriptCore/jit/JIT.h b/JavaScriptCore/jit/JIT.h
index 7243b5a..ace7e67 100644
--- a/JavaScriptCore/jit/JIT.h
+++ b/JavaScriptCore/jit/JIT.h
@@ -35,7 +35,7 @@
#include "Interpreter.h"
#include "Opcode.h"
#include "RegisterFile.h"
-#include "X86Assembler.h"
+#include "MacroAssembler.h"
#include "Profiler.h"
#include <wtf/AlwaysInline.h>
#include <wtf/Vector.h>
@@ -260,12 +260,14 @@
void ctiSetReturnAddress(void** where, void* what);
void ctiRepatchCallByReturnAddress(void* where, void* what);
- class JIT {
+ class JIT : private MacroAssembler {
typedef X86Assembler::RegisterID RegisterID;
typedef X86Assembler::XMMRegisterID XMMRegisterID;
typedef X86Assembler::JmpSrc JmpSrc;
typedef X86Assembler::JmpDst JmpDst;
+ static const RegisterID callFrameRegister = X86::edi;
+
static const int repatchGetByIdDefaultStructure = -1;
// Magic number - initial offset cannot be representable as a signed 8bit value, or the X86Assembler
// will compress the displacement, and we may not be able to fit a repatched offset.
@@ -415,6 +417,7 @@
void emitPutCTIArg(RegisterID src, unsigned offset);
void emitPutCTIArgFromVirtualRegister(unsigned src, unsigned offset, RegisterID scratch);
void emitPutCTIArgConstant(unsigned value, unsigned offset);
+ void emitPutCTIArgConstant(void* value, unsigned offset);
void emitGetCTIArg(unsigned offset, RegisterID dst);
void emitInitRegister(unsigned dst);
@@ -424,6 +427,7 @@
void emitGetCTIParam(unsigned name, RegisterID to);
void emitPutToCallFrameHeader(RegisterID from, RegisterFile::CallFrameHeaderEntry entry);
+ void emitPutImmediateToCallFrameHeader(void* value, RegisterFile::CallFrameHeaderEntry entry);
void emitGetFromCallFrameHeader(RegisterFile::CallFrameHeaderEntry entry, RegisterID to);
JSValue* getConstantImmediateNumericArg(unsigned src);
@@ -434,7 +438,7 @@
void emitJumpSlowCaseIfNotJSCell(RegisterID, unsigned bytecodeIndex, int VReg);
void emitJumpSlowCaseIfNotImmNum(RegisterID, unsigned bytecodeIndex);
- void emitJumpSlowCaseIfNotImmNums(RegisterID, RegisterID, unsigned bytecodeIndex);
+ void emitJumpSlowCaseIfNotImmNums(RegisterID, RegisterID, RegisterID, unsigned bytecodeIndex);
JmpSrc checkStructure(RegisterID reg, Structure* structure);
@@ -448,6 +452,9 @@
void emitTagAsBoolImmediate(RegisterID reg);
+ void restoreArgumentReference();
+ void restoreArgumentReferenceForTrampoline();
+
JmpSrc emitNakedCall(unsigned bytecodeIndex, RegisterID);
JmpSrc emitNakedCall(unsigned bytecodeIndex, void* function);
JmpSrc emitCTICall(unsigned bytecodeIndex, CTIHelper_j);
@@ -468,7 +475,6 @@
void killLastResultRegister();
- X86Assembler m_assembler;
Interpreter* m_interpreter;
JSGlobalData* m_globalData;
CodeBlock* m_codeBlock;
diff --git a/JavaScriptCore/jit/JITArithmetic.cpp b/JavaScriptCore/jit/JITArithmetic.cpp
index e961bb5..7fe8060 100644
--- a/JavaScriptCore/jit/JITArithmetic.cpp
+++ b/JavaScriptCore/jit/JITArithmetic.cpp
@@ -254,7 +254,7 @@
__ link(op1imm, __ label());
emitJumpSlowCaseIfNotImmNum(X86::edx, i);
} else
- emitJumpSlowCaseIfNotImmNums(X86::eax, X86::edx, i);
+ emitJumpSlowCaseIfNotImmNums(X86::eax, X86::edx, X86::ecx, i);
if (opcodeID == op_add) {
emitFastArithDeTagImmediate(X86::eax);
diff --git a/JavaScriptCore/jit/JITInlineMethods.h b/JavaScriptCore/jit/JITInlineMethods.h
index 0741a32..a5526e6 100644
--- a/JavaScriptCore/jit/JITInlineMethods.h
+++ b/JavaScriptCore/jit/JITInlineMethods.h
@@ -30,7 +30,7 @@
#if ENABLE(JIT)
-#define __ m_assembler.
+#define __ m_assembler.
#if PLATFORM(WIN)
#undef FIELD_OFFSET // Fix conflict with winnt.h.
@@ -61,7 +61,7 @@
// TODO: we want to reuse values that are already in registers if we can - add a register allocator!
if (m_codeBlock->isConstantRegisterIndex(src)) {
JSValue* value = m_codeBlock->getConstant(src);
- __ movl_i32r(asInteger(value), dst);
+ move(value, dst);
killLastResultRegister();
return;
}
@@ -77,13 +77,13 @@
if (!atJumpTarget) {
// The argument we want is already stored in eax
if (dst != X86::eax)
- __ movl_rr(X86::eax, dst);
+ move(X86::eax, dst);
killLastResultRegister();
return;
}
}
- __ movl_mr(src * sizeof(Register), X86::edi, dst);
+ loadPtr(Address(callFrameRegister, src * sizeof(Register)), dst);
killLastResultRegister();
}
@@ -98,35 +98,25 @@
}
}
-// get arg puts an arg from the SF register array onto the stack, as an arg to a context threaded function.
-ALWAYS_INLINE void JIT::emitPutCTIArgFromVirtualRegister(unsigned src, unsigned offset, RegisterID scratch)
-{
- if (m_codeBlock->isConstantRegisterIndex(src)) {
- JSValue* value = m_codeBlock->getConstant(src);
- __ movl_i32m(asInteger(value), offset + sizeof(void*), X86::esp);
- } else {
- __ movl_mr(src * sizeof(Register), X86::edi, scratch);
- __ movl_rm(scratch, offset + sizeof(void*), X86::esp);
- }
-
- killLastResultRegister();
-}
-
// puts an arg onto the stack, as an arg to a context threaded function.
ALWAYS_INLINE void JIT::emitPutCTIArg(RegisterID src, unsigned offset)
{
- __ movl_rm(src, offset + sizeof(void*), X86::esp);
+ poke(src, (offset / sizeof(void*)) + 1);
+}
+
+ALWAYS_INLINE void JIT::emitPutCTIArgConstant(unsigned value, unsigned offset)
+{
+ poke(Imm32(value), (offset / sizeof(void*)) + 1);
+}
+
+ALWAYS_INLINE void JIT::emitPutCTIArgConstant(void* value, unsigned offset)
+{
+ poke(value, (offset / sizeof(void*)) + 1);
}
ALWAYS_INLINE void JIT::emitGetCTIArg(unsigned offset, RegisterID dst)
{
- __ movl_mr(offset + sizeof(void*), X86::esp, dst);
-}
-
-
-ALWAYS_INLINE void JIT::emitPutCTIArgConstant(unsigned value, unsigned offset)
-{
- __ movl_i32m(value, offset + sizeof(void*), X86::esp);
+ peek(dst, (offset / sizeof(void*)) + 1);
}
ALWAYS_INLINE JSValue* JIT::getConstantImmediateNumericArg(unsigned src)
@@ -138,190 +128,226 @@
return noValue();
}
+// get arg puts an arg from the SF register array onto the stack, as an arg to a context threaded function.
+ALWAYS_INLINE void JIT::emitPutCTIArgFromVirtualRegister(unsigned src, unsigned offset, RegisterID scratch)
+{
+ if (m_codeBlock->isConstantRegisterIndex(src)) {
+ JSValue* value = m_codeBlock->getConstant(src);
+ emitPutCTIArgConstant(value, offset);
+ } else {
+ loadPtr(Address(callFrameRegister, src * sizeof(Register)), scratch);
+ emitPutCTIArg(scratch, offset);
+ }
+
+ killLastResultRegister();
+}
+
ALWAYS_INLINE void JIT::emitPutCTIParam(void* value, unsigned name)
{
- __ movl_i32m(reinterpret_cast<intptr_t>(value), name * sizeof(void*), X86::esp);
+ poke(value, name);
}
ALWAYS_INLINE void JIT::emitPutCTIParam(RegisterID from, unsigned name)
{
- __ movl_rm(from, name * sizeof(void*), X86::esp);
+ poke(from, name);
}
ALWAYS_INLINE void JIT::emitGetCTIParam(unsigned name, RegisterID to)
{
- __ movl_mr(name * sizeof(void*), X86::esp, to);
+ peek(to, name);
killLastResultRegister();
}
ALWAYS_INLINE void JIT::emitPutToCallFrameHeader(RegisterID from, RegisterFile::CallFrameHeaderEntry entry)
{
- __ movl_rm(from, entry * sizeof(Register), X86::edi);
+ storePtr(from, Address(callFrameRegister, entry * sizeof(Register)));
+}
+
+ALWAYS_INLINE void JIT::emitPutImmediateToCallFrameHeader(void* value, RegisterFile::CallFrameHeaderEntry entry)
+{
+ storePtr(value, Address(callFrameRegister, entry * sizeof(Register)));
}
ALWAYS_INLINE void JIT::emitGetFromCallFrameHeader(RegisterFile::CallFrameHeaderEntry entry, RegisterID to)
{
- __ movl_mr(entry * sizeof(Register), X86::edi, to);
+ loadPtr(Address(callFrameRegister, entry * sizeof(Register)), to);
killLastResultRegister();
}
ALWAYS_INLINE void JIT::emitPutVirtualRegister(unsigned dst, RegisterID from)
{
- __ movl_rm(from, dst * sizeof(Register), X86::edi);
+ storePtr(from, Address(callFrameRegister, dst * sizeof(Register)));
m_lastResultBytecodeRegister = (from == X86::eax) ? dst : std::numeric_limits<int>::max();
// FIXME: #ifndef NDEBUG, Write the correct m_type to the register.
}
ALWAYS_INLINE void JIT::emitInitRegister(unsigned dst)
{
- __ movl_i32m(asInteger(jsUndefined()), dst * sizeof(Register), X86::edi);
+ storePtr(jsUndefined(), Address(callFrameRegister, dst * sizeof(Register)));
// FIXME: #ifndef NDEBUG, Write the correct m_type to the register.
}
ALWAYS_INLINE JmpSrc JIT::emitNakedCall(unsigned bytecodeIndex, X86::RegisterID r)
{
- JmpSrc call = __ call(r);
- m_calls.append(CallRecord(call, bytecodeIndex));
-
- return call;
+ JmpSrc nakedCall = call(r);
+ m_calls.append(CallRecord(nakedCall, bytecodeIndex));
+ return nakedCall;
}
-ALWAYS_INLINE JmpSrc JIT::emitNakedCall(unsigned bytecodeIndex, void* function)
+ALWAYS_INLINE JmpSrc JIT::emitNakedCall(unsigned bytecodeIndex, void* function)
{
- JmpSrc call = __ call();
- m_calls.append(CallRecord(call, reinterpret_cast<CTIHelper_v>(function), bytecodeIndex));
- return call;
+ JmpSrc nakedCall = call();
+ m_calls.append(CallRecord(nakedCall, reinterpret_cast<CTIHelper_v>(function), bytecodeIndex));
+ return nakedCall;
}
+ALWAYS_INLINE void JIT::restoreArgumentReference()
+{
+#if USE(CTI_ARGUMENT)
+#if USE(FAST_CALL_CTI_ARGUMENT)
+ movl_rr(X86::esp, X86::ecx);
+#else
+ movl_rm(X86::esp, 0, X86::esp);
+#endif
+#endif
+}
+
+ALWAYS_INLINE void JIT::restoreArgumentReferenceForTrampoline()
+{
+#if USE(CTI_ARGUMENT) && USE(FAST_CALL_CTI_ARGUMENT)
+ movl_rr(X86::esp, X86::ecx);
+ addl_i32r(4, X86::ecx);
+#endif
+}
+
+
ALWAYS_INLINE JmpSrc JIT::emitCTICall(unsigned bytecodeIndex, CTIHelper_j helper)
{
#if ENABLE(OPCODE_SAMPLING)
- __ movl_i32m(m_interpreter->sampler()->encodeSample(m_codeBlock->instructions.begin() + bytecodeIndex, true), m_interpreter->sampler()->sampleSlot());
+ store32(Imm32(m_interpreter->sampler()->encodeSample(m_codeBlock->instructions.begin() + bytecodeIndex, true)), m_interpreter->sampler()->sampleSlot());
#endif
- __ restoreArgumentReference();
- emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
- JmpSrc call = __ call();
- m_calls.append(CallRecord(call, helper, bytecodeIndex));
+ restoreArgumentReference();
+ emitPutCTIParam(callFrameRegister, CTI_ARGS_callFrame);
+ JmpSrc ctiCall = call();
+ m_calls.append(CallRecord(ctiCall, helper, bytecodeIndex));
#if ENABLE(OPCODE_SAMPLING)
- __ movl_i32m(m_interpreter->sampler()->encodeSample(m_codeBlock->instructions.begin() + bytecodeIndex, false), m_interpreter->sampler()->sampleSlot());
+ store32(Imm32(m_interpreter->sampler()->encodeSample(m_codeBlock->instructions.begin() + bytecodeIndex, false)), m_interpreter->sampler()->sampleSlot());
#endif
killLastResultRegister();
- return call;
+ return ctiCall;
}
ALWAYS_INLINE JmpSrc JIT::emitCTICall(unsigned bytecodeIndex, CTIHelper_o helper)
{
#if ENABLE(OPCODE_SAMPLING)
- __ movl_i32m(m_interpreter->sampler()->encodeSample(m_codeBlock->instructions.begin() + bytecodeIndex, true), m_interpreter->sampler()->sampleSlot());
+ store32(Imm32(m_interpreter->sampler()->encodeSample(m_codeBlock->instructions.begin() + bytecodeIndex, true)), m_interpreter->sampler()->sampleSlot());
#endif
- __ restoreArgumentReference();
- emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
- JmpSrc call = __ call();
- m_calls.append(CallRecord(call, helper, bytecodeIndex));
+ restoreArgumentReference();
+ emitPutCTIParam(callFrameRegister, CTI_ARGS_callFrame);
+ JmpSrc ctiCall = call();
+ m_calls.append(CallRecord(ctiCall, helper, bytecodeIndex));
#if ENABLE(OPCODE_SAMPLING)
- __ movl_i32m(m_interpreter->sampler()->encodeSample(m_codeBlock->instructions.begin() + bytecodeIndex, false), m_interpreter->sampler()->sampleSlot());
+ store32(Imm32(m_interpreter->sampler()->encodeSample(m_codeBlock->instructions.begin() + bytecodeIndex, false)), m_interpreter->sampler()->sampleSlot());
#endif
killLastResultRegister();
- return call;
+ return ctiCall;
}
ALWAYS_INLINE JmpSrc JIT::emitCTICall(unsigned bytecodeIndex, CTIHelper_p helper)
{
#if ENABLE(OPCODE_SAMPLING)
- __ movl_i32m(m_interpreter->sampler()->encodeSample(m_codeBlock->instructions.begin() + bytecodeIndex, true), m_interpreter->sampler()->sampleSlot());
+ store32(Imm32(m_interpreter->sampler()->encodeSample(m_codeBlock->instructions.begin() + bytecodeIndex, true)), m_interpreter->sampler()->sampleSlot());
#endif
- __ restoreArgumentReference();
- emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
- JmpSrc call = __ call();
- m_calls.append(CallRecord(call, helper, bytecodeIndex));
+ restoreArgumentReference();
+ emitPutCTIParam(callFrameRegister, CTI_ARGS_callFrame);
+ JmpSrc ctiCall = call();
+ m_calls.append(CallRecord(ctiCall, helper, bytecodeIndex));
#if ENABLE(OPCODE_SAMPLING)
- __ movl_i32m(m_interpreter->sampler()->encodeSample(m_codeBlock->instructions.begin() + bytecodeIndex, false), m_interpreter->sampler()->sampleSlot());
+ store32(Imm32(m_interpreter->sampler()->encodeSample(m_codeBlock->instructions.begin() + bytecodeIndex, false)), m_interpreter->sampler()->sampleSlot());
#endif
killLastResultRegister();
- return call;
+ return ctiCall;
}
ALWAYS_INLINE JmpSrc JIT::emitCTICall(unsigned bytecodeIndex, CTIHelper_b helper)
{
#if ENABLE(OPCODE_SAMPLING)
- __ movl_i32m(m_interpreter->sampler()->encodeSample(m_codeBlock->instructions.begin() + bytecodeIndex, true), m_interpreter->sampler()->sampleSlot());
+ store32(Imm32(m_interpreter->sampler()->encodeSample(m_codeBlock->instructions.begin() + bytecodeIndex, true)), m_interpreter->sampler()->sampleSlot());
#endif
- __ restoreArgumentReference();
- emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
- JmpSrc call = __ call();
- m_calls.append(CallRecord(call, helper, bytecodeIndex));
+ restoreArgumentReference();
+ emitPutCTIParam(callFrameRegister, CTI_ARGS_callFrame);
+ JmpSrc ctiCall = call();
+ m_calls.append(CallRecord(ctiCall, helper, bytecodeIndex));
#if ENABLE(OPCODE_SAMPLING)
- __ movl_i32m(m_interpreter->sampler()->encodeSample(m_codeBlock->instructions.begin() + bytecodeIndex, false), m_interpreter->sampler()->sampleSlot());
+ store32(Imm32(m_interpreter->sampler()->encodeSample(m_codeBlock->instructions.begin() + bytecodeIndex, false)), m_interpreter->sampler()->sampleSlot());
#endif
killLastResultRegister();
- return call;
+ return ctiCall;
}
ALWAYS_INLINE JmpSrc JIT::emitCTICall(unsigned bytecodeIndex, CTIHelper_v helper)
{
#if ENABLE(OPCODE_SAMPLING)
- __ movl_i32m(m_interpreter->sampler()->encodeSample(m_codeBlock->instructions.begin() + bytecodeIndex, true), m_interpreter->sampler()->sampleSlot());
+ store32(Imm32(m_interpreter->sampler()->encodeSample(m_codeBlock->instructions.begin() + bytecodeIndex, true)), m_interpreter->sampler()->sampleSlot());
#endif
- __ restoreArgumentReference();
- emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
- JmpSrc call = __ call();
- m_calls.append(CallRecord(call, helper, bytecodeIndex));
+ restoreArgumentReference();
+ emitPutCTIParam(callFrameRegister, CTI_ARGS_callFrame);
+ JmpSrc ctiCall = call();
+ m_calls.append(CallRecord(ctiCall, helper, bytecodeIndex));
#if ENABLE(OPCODE_SAMPLING)
- __ movl_i32m(m_interpreter->sampler()->encodeSample(m_codeBlock->instructions.begin() + bytecodeIndex, false), m_interpreter->sampler()->sampleSlot());
+ store32(Imm32(m_interpreter->sampler()->encodeSample(m_codeBlock->instructions.begin() + bytecodeIndex, false)), m_interpreter->sampler()->sampleSlot());
#endif
killLastResultRegister();
- return call;
+ return ctiCall;
}
ALWAYS_INLINE JmpSrc JIT::emitCTICall(unsigned bytecodeIndex, CTIHelper_s helper)
{
#if ENABLE(OPCODE_SAMPLING)
- __ movl_i32m(m_interpreter->sampler()->encodeSample(m_codeBlock->instructions.begin() + bytecodeIndex, true), m_interpreter->sampler()->sampleSlot());
+ store32(Imm32(m_interpreter->sampler()->encodeSample(m_codeBlock->instructions.begin() + bytecodeIndex, true)), m_interpreter->sampler()->sampleSlot());
#endif
- __ restoreArgumentReference();
- emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
- JmpSrc call = __ call();
- m_calls.append(CallRecord(call, helper, bytecodeIndex));
+ restoreArgumentReference();
+ emitPutCTIParam(callFrameRegister, CTI_ARGS_callFrame);
+ JmpSrc ctiCall = call();
+ m_calls.append(CallRecord(ctiCall, helper, bytecodeIndex));
#if ENABLE(OPCODE_SAMPLING)
- __ movl_i32m(m_interpreter->sampler()->encodeSample(m_codeBlock->instructions.begin() + bytecodeIndex, false), m_interpreter->sampler()->sampleSlot());
+ store32(Imm32(m_interpreter->sampler()->encodeSample(m_codeBlock->instructions.begin() + bytecodeIndex, false)), m_interpreter->sampler()->sampleSlot());
#endif
killLastResultRegister();
- return call;
+ return ctiCall;
}
ALWAYS_INLINE JmpSrc JIT::emitCTICall(unsigned bytecodeIndex, CTIHelper_2 helper)
{
#if ENABLE(OPCODE_SAMPLING)
- __ movl_i32m(m_interpreter->sampler()->encodeSample(m_codeBlock->instructions.begin() + bytecodeIndex, true), m_interpreter->sampler()->sampleSlot());
+ store32(Imm32(m_interpreter->sampler()->encodeSample(m_codeBlock->instructions.begin() + bytecodeIndex, true)), m_interpreter->sampler()->sampleSlot());
#endif
- __ restoreArgumentReference();
- emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
- JmpSrc call = __ call();
- m_calls.append(CallRecord(call, helper, bytecodeIndex));
+ restoreArgumentReference();
+ emitPutCTIParam(callFrameRegister, CTI_ARGS_callFrame);
+ JmpSrc ctiCall = call();
+ m_calls.append(CallRecord(ctiCall, helper, bytecodeIndex));
#if ENABLE(OPCODE_SAMPLING)
- __ movl_i32m(m_interpreter->sampler()->encodeSample(m_codeBlock->instructions.begin() + bytecodeIndex, false), m_interpreter->sampler()->sampleSlot());
+ store32(Imm32(m_interpreter->sampler()->encodeSample(m_codeBlock->instructions.begin() + bytecodeIndex, false)), m_interpreter->sampler()->sampleSlot());
#endif
killLastResultRegister();
- return call;
+ return ctiCall;
}
ALWAYS_INLINE JmpSrc JIT::checkStructure(RegisterID reg, Structure* structure)
{
- __ cmpl_i32m(reinterpret_cast<uint32_t>(structure), FIELD_OFFSET(JSCell, m_structure), reg);
- return __ jne();
+ return jnePtr(structure, Address(reg, FIELD_OFFSET(JSCell, m_structure)));
}
ALWAYS_INLINE void JIT::emitJumpSlowCaseIfNotJSCell(RegisterID reg, unsigned bytecodeIndex)
{
- __ testl_i32r(JSImmediate::TagMask, reg);
- m_slowCases.append(SlowCaseEntry(__ jne(), bytecodeIndex));
+ m_slowCases.append(SlowCaseEntry(jset32(Imm32(JSImmediate::TagMask), reg), bytecodeIndex));
}
ALWAYS_INLINE void JIT::emitJumpSlowCaseIfNotJSCell(RegisterID reg, unsigned bytecodeIndex, int vReg)
@@ -343,15 +369,14 @@
ALWAYS_INLINE void JIT::emitJumpSlowCaseIfNotImmNum(RegisterID reg, unsigned bytecodeIndex)
{
- __ testl_i32r(JSImmediate::TagBitTypeInteger, reg);
- m_slowCases.append(SlowCaseEntry(__ je(), bytecodeIndex));
+ m_slowCases.append(SlowCaseEntry(jnset32(Imm32(JSImmediate::TagBitTypeInteger), reg), bytecodeIndex));
}
-ALWAYS_INLINE void JIT::emitJumpSlowCaseIfNotImmNums(RegisterID reg1, RegisterID reg2, unsigned bytecodeIndex)
+ALWAYS_INLINE void JIT::emitJumpSlowCaseIfNotImmNums(RegisterID reg1, RegisterID reg2, RegisterID scratch, unsigned bytecodeIndex)
{
- __ movl_rr(reg1, X86::ecx);
- __ andl_rr(reg2, X86::ecx);
- emitJumpSlowCaseIfNotImmNum(X86::ecx, bytecodeIndex);
+ move(reg1, scratch);
+ and32(reg2, scratch);
+ emitJumpSlowCaseIfNotImmNum(scratch, bytecodeIndex);
}
ALWAYS_INLINE unsigned JIT::getDeTaggedConstantImmediate(JSValue* imm)
@@ -362,47 +387,45 @@
ALWAYS_INLINE void JIT::emitFastArithDeTagImmediate(RegisterID reg)
{
- __ subl_i8r(JSImmediate::TagBitTypeInteger, reg);
+ sub32(Imm32(JSImmediate::TagBitTypeInteger), reg);
}
ALWAYS_INLINE JmpSrc JIT::emitFastArithDeTagImmediateJumpIfZero(RegisterID reg)
{
- __ subl_i8r(JSImmediate::TagBitTypeInteger, reg);
- return __ je();
+ return jzSub32(Imm32(JSImmediate::TagBitTypeInteger), reg);
}
ALWAYS_INLINE void JIT::emitFastArithReTagImmediate(RegisterID reg)
{
- __ addl_i8r(JSImmediate::TagBitTypeInteger, reg);
+ add32(Imm32(JSImmediate::TagBitTypeInteger), reg);
}
ALWAYS_INLINE void JIT::emitFastArithPotentiallyReTagImmediate(RegisterID reg)
{
- __ orl_i8r(JSImmediate::TagBitTypeInteger, reg);
+ or32(Imm32(JSImmediate::TagBitTypeInteger), reg);
}
ALWAYS_INLINE void JIT::emitFastArithImmToInt(RegisterID reg)
{
- __ sarl_i8r(1, reg);
+ rshift32(Imm32(1), reg);
}
ALWAYS_INLINE void JIT::emitFastArithIntToImmOrSlowCase(RegisterID reg, unsigned bytecodeIndex)
{
- __ addl_rr(reg, reg);
- m_slowCases.append(SlowCaseEntry(__ jo(), bytecodeIndex));
+ m_slowCases.append(SlowCaseEntry(joAdd32(reg, reg), bytecodeIndex));
emitFastArithReTagImmediate(reg);
}
ALWAYS_INLINE void JIT::emitFastArithIntToImmNoCheck(RegisterID reg)
{
- __ addl_rr(reg, reg);
+ add32(reg, reg);
emitFastArithReTagImmediate(reg);
}
ALWAYS_INLINE void JIT::emitTagAsBoolImmediate(RegisterID reg)
{
- __ shl_i8r(JSImmediate::ExtendedPayloadShift, reg);
- __ orl_i8r(JSImmediate::FullTagTypeBool, reg);
+ lshift32(Imm32(JSImmediate::ExtendedPayloadShift), reg);
+ or32(Imm32(JSImmediate::FullTagTypeBool), reg);
}
}
diff --git a/JavaScriptCore/jit/JITPropertyAccess.cpp b/JavaScriptCore/jit/JITPropertyAccess.cpp
index ffb70e0..a4cba0f 100644
--- a/JavaScriptCore/jit/JITPropertyAccess.cpp
+++ b/JavaScriptCore/jit/JITPropertyAccess.cpp
@@ -281,7 +281,7 @@
if (failureCases.size()) {
for (unsigned i = 0; i < failureCases.size(); ++i)
__ link(failureCases[i], __ label());
- __ restoreArgumentReferenceForTrampoline();
+ restoreArgumentReferenceForTrampoline();
failureJump = __ jmp();
}
