SpecializedThunkJIT.h [plain text]
#ifndef SpecializedThunkJIT_h
#define SpecializedThunkJIT_h
#if ENABLE(JIT)
#include "Executable.h"
#include "JSInterfaceJIT.h"
#include "LinkBuffer.h"
namespace JSC {
class SpecializedThunkJIT : public JSInterfaceJIT {
public:
static const int ThisArgument = -1;
SpecializedThunkJIT(int expectedArgCount, JSGlobalData* globalData)
: m_expectedArgCount(expectedArgCount)
, m_globalData(globalData)
{
m_failures.append(branch32(NotEqual, Address(callFrameRegister, RegisterFile::ArgumentCount * (int)sizeof(Register)), TrustedImm32(expectedArgCount + 1)));
}
void loadDoubleArgument(int argument, FPRegisterID dst, RegisterID scratch)
{
unsigned src = CallFrame::argumentOffset(argument);
m_failures.append(emitLoadDouble(src, dst, scratch));
}
void loadCellArgument(int argument, RegisterID dst)
{
unsigned src = CallFrame::argumentOffset(argument);
m_failures.append(emitLoadJSCell(src, dst));
}
void loadJSStringArgument(int argument, RegisterID dst)
{
loadCellArgument(argument, dst);
m_failures.append(branchPtr(NotEqual, Address(dst, 0), TrustedImmPtr(m_globalData->jsStringVPtr)));
}
void loadInt32Argument(int argument, RegisterID dst, Jump& failTarget)
{
unsigned src = CallFrame::argumentOffset(argument);
failTarget = emitLoadInt32(src, dst);
}
void loadInt32Argument(int argument, RegisterID dst)
{
Jump conversionFailed;
loadInt32Argument(argument, dst, conversionFailed);
m_failures.append(conversionFailed);
}
void appendFailure(const Jump& failure)
{
m_failures.append(failure);
}
void returnJSValue(RegisterID src)
{
if (src != regT0)
move(src, regT0);
loadPtr(payloadFor(RegisterFile::CallerFrame, callFrameRegister), callFrameRegister);
ret();
}
void returnDouble(FPRegisterID src)
{
#if USE(JSVALUE64)
moveDoubleToPtr(src, regT0);
Jump zero = branchTestPtr(Zero, regT0);
subPtr(tagTypeNumberRegister, regT0);
Jump done = jump();
zero.link(this);
move(tagTypeNumberRegister, regT0);
done.link(this);
#else
storeDouble(src, Address(stackPointerRegister, -(int)sizeof(double)));
loadPtr(Address(stackPointerRegister, OBJECT_OFFSETOF(JSValue, u.asBits.tag) - sizeof(double)), regT1);
loadPtr(Address(stackPointerRegister, OBJECT_OFFSETOF(JSValue, u.asBits.payload) - sizeof(double)), regT0);
Jump lowNonZero = branchTestPtr(NonZero, regT1);
Jump highNonZero = branchTestPtr(NonZero, regT0);
move(TrustedImm32(0), regT0);
move(TrustedImm32(Int32Tag), regT1);
lowNonZero.link(this);
highNonZero.link(this);
#endif
loadPtr(payloadFor(RegisterFile::CallerFrame, callFrameRegister), callFrameRegister);
ret();
}
void returnInt32(RegisterID src)
{
if (src != regT0)
move(src, regT0);
tagReturnAsInt32();
loadPtr(payloadFor(RegisterFile::CallerFrame, callFrameRegister), callFrameRegister);
ret();
}
void returnJSCell(RegisterID src)
{
if (src != regT0)
move(src, regT0);
tagReturnAsJSCell();
loadPtr(payloadFor(RegisterFile::CallerFrame, callFrameRegister), callFrameRegister);
ret();
}
MacroAssemblerCodeRef finalize(JSGlobalData& globalData, MacroAssemblerCodePtr fallback)
{
LinkBuffer patchBuffer(globalData, this);
patchBuffer.link(m_failures, CodeLocationLabel(fallback));
for (unsigned i = 0; i < m_calls.size(); i++)
patchBuffer.link(m_calls[i].first, m_calls[i].second);
return patchBuffer.finalizeCode();
}
void callDoubleToDouble(FunctionPtr function)
{
m_calls.append(std::make_pair(call(), function));
}
private:
void tagReturnAsInt32()
{
#if USE(JSVALUE64)
orPtr(tagTypeNumberRegister, regT0);
#else
move(TrustedImm32(JSValue::Int32Tag), regT1);
#endif
}
void tagReturnAsJSCell()
{
#if USE(JSVALUE32_64)
move(TrustedImm32(JSValue::CellTag), regT1);
#endif
}
int m_expectedArgCount;
JSGlobalData* m_globalData;
MacroAssembler::JumpList m_failures;
Vector<std::pair<Call, FunctionPtr> > m_calls;
};
}
#endif // ENABLE(JIT)
#endif // SpecializedThunkJIT_h