void JIT::emitSlow_op_div(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
{
unsigned result = currentInstruction[1].u.operand;
unsigned op1 = currentInstruction[2].u.operand;
unsigned op2 = currentInstruction[3].u.operand;
OperandTypes types = OperandTypes::fromInt(currentInstruction[4].u.operand);
if (types.first().definitelyIsNumber() && types.second().definitelyIsNumber()) {
#ifndef NDEBUG
breakpoint();
#endif
return;
}
if (!isOperandConstantImmediateDouble(op1) && !isOperandConstantImmediateInt(op1)) {
if (!types.first().definitelyIsNumber())
linkSlowCase(iter);
}
if (!isOperandConstantImmediateDouble(op2) && !isOperandConstantImmediateInt(op2)) {
if (!types.second().definitelyIsNumber())
linkSlowCase(iter);
}
// There is an extra slow case for (op1 * -N) or (-N * op2), to check for 0 since this should produce a result of -0.
JITStubCall stubCall(this, cti_op_div);
stubCall.addArgument(op1, regT2);
stubCall.addArgument(op2, regT2);
stubCall.call(result);
}
void JIT::compileFastArith_op_add(Instruction* currentInstruction)
{
unsigned result = currentInstruction[1].u.operand;
unsigned op1 = currentInstruction[2].u.operand;
unsigned op2 = currentInstruction[3].u.operand;
OperandTypes types = OperandTypes::fromInt(currentInstruction[4].u.operand);
if (!types.first().mightBeNumber() || !types.second().mightBeNumber()) {
emitPutJITStubArgFromVirtualRegister(op1, 1, X86::ecx);
emitPutJITStubArgFromVirtualRegister(op2, 2, X86::ecx);
emitCTICall(Interpreter::cti_op_add);
emitPutVirtualRegister(result);
return;
}
if (isOperandConstantImmediateInt(op1)) {
emitGetVirtualRegister(op2, X86::eax);
emitJumpSlowCaseIfNotImmediateInteger(X86::eax);
addSlowCase(branchAdd32(Overflow, Imm32(getConstantOperandImmediateInt(op1)), X86::eax));
emitFastArithIntToImmNoCheck(X86::eax, X86::eax);
} else if (isOperandConstantImmediateInt(op2)) {
emitGetVirtualRegister(op1, X86::eax);
emitJumpSlowCaseIfNotImmediateInteger(X86::eax);
addSlowCase(branchAdd32(Overflow, Imm32(getConstantOperandImmediateInt(op2)), X86::eax));
emitFastArithIntToImmNoCheck(X86::eax, X86::eax);
} else
compileBinaryArithOp(op_add, result, op1, op2, types);
emitPutVirtualRegister(result);
}
void JIT::emit_op_add(Instruction* currentInstruction)
{
unsigned result = currentInstruction[1].u.operand;
unsigned op1 = currentInstruction[2].u.operand;
unsigned op2 = currentInstruction[3].u.operand;
OperandTypes types = OperandTypes::fromInt(currentInstruction[4].u.operand);
if (!types.first().mightBeNumber() || !types.second().mightBeNumber()) {
JITStubCall stubCall(this, cti_op_add);
stubCall.addArgument(op1, regT2);
stubCall.addArgument(op2, regT2);
stubCall.call(result);
return;
}
if (isOperandConstantImmediateInt(op1)) {
emitGetVirtualRegister(op2, regT0);
emitJumpSlowCaseIfNotImmediateInteger(regT0);
addSlowCase(branchAdd32(Overflow, Imm32(getConstantOperandImmediateInt(op1)), regT0));
emitFastArithIntToImmNoCheck(regT0, regT0);
} else if (isOperandConstantImmediateInt(op2)) {
emitGetVirtualRegister(op1, regT0);
emitJumpSlowCaseIfNotImmediateInteger(regT0);
addSlowCase(branchAdd32(Overflow, Imm32(getConstantOperandImmediateInt(op2)), regT0));
emitFastArithIntToImmNoCheck(regT0, regT0);
} else
compileBinaryArithOp(op_add, result, op1, op2, types);
emitPutVirtualRegister(result);
}
void JIT::emit_op_div(Instruction* currentInstruction)
{
unsigned dst = currentInstruction[1].u.operand;
unsigned op1 = currentInstruction[2].u.operand;
unsigned op2 = currentInstruction[3].u.operand;
OperandTypes types = OperandTypes::fromInt(currentInstruction[4].u.operand);
if (isOperandConstantImmediateDouble(op1)) {
emitGetVirtualRegister(op1, regT0);
addPtr(tagTypeNumberRegister, regT0);
movePtrToDouble(regT0, fpRegT0);
} else if (isOperandConstantImmediateInt(op1)) {
emitLoadInt32ToDouble(op1, fpRegT0);
} else {
emitGetVirtualRegister(op1, regT0);
if (!types.first().definitelyIsNumber())
emitJumpSlowCaseIfNotImmediateNumber(regT0);
Jump notInt = emitJumpIfNotImmediateInteger(regT0);
convertInt32ToDouble(regT0, fpRegT0);
Jump skipDoubleLoad = jump();
notInt.link(this);
addPtr(tagTypeNumberRegister, regT0);
movePtrToDouble(regT0, fpRegT0);
skipDoubleLoad.link(this);
}
if (isOperandConstantImmediateDouble(op2)) {
emitGetVirtualRegister(op2, regT1);
addPtr(tagTypeNumberRegister, regT1);
movePtrToDouble(regT1, fpRegT1);
} else if (isOperandConstantImmediateInt(op2)) {
emitLoadInt32ToDouble(op2, fpRegT1);
} else {
emitGetVirtualRegister(op2, regT1);
if (!types.second().definitelyIsNumber())
emitJumpSlowCaseIfNotImmediateNumber(regT1);
Jump notInt = emitJumpIfNotImmediateInteger(regT1);
convertInt32ToDouble(regT1, fpRegT1);
Jump skipDoubleLoad = jump();
notInt.link(this);
addPtr(tagTypeNumberRegister, regT1);
movePtrToDouble(regT1, fpRegT1);
skipDoubleLoad.link(this);
}
divDouble(fpRegT1, fpRegT0);
// Double result.
moveDoubleToPtr(fpRegT0, regT0);
subPtr(tagTypeNumberRegister, regT0);
emitPutVirtualRegister(dst, regT0);
}
void JIT::emitSlow_op_add(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
{
unsigned result = currentInstruction[1].u.operand;
unsigned op1 = currentInstruction[2].u.operand;
unsigned op2 = currentInstruction[3].u.operand;
OperandTypes types = OperandTypes::fromInt(currentInstruction[4].u.operand);
if (!types.first().mightBeNumber() || !types.second().mightBeNumber())
return;
bool op1HasImmediateIntFastCase = isOperandConstantImmediateInt(op1);
bool op2HasImmediateIntFastCase = !op1HasImmediateIntFastCase && isOperandConstantImmediateInt(op2);
compileBinaryArithOpSlowCase(op_add, iter, result, op1, op2, OperandTypes::fromInt(currentInstruction[4].u.operand), op1HasImmediateIntFastCase, op2HasImmediateIntFastCase);
}
void JIT::compileBinaryArithOpSlowCase(OpcodeID opcodeID, Vector<SlowCaseEntry>::iterator& iter, unsigned, unsigned op1, unsigned, OperandTypes types)
{
// We assume that subtracting TagTypeNumber is equivalent to adding DoubleEncodeOffset.
COMPILE_ASSERT(((JSImmediate::TagTypeNumber + JSImmediate::DoubleEncodeOffset) == 0), TagTypeNumber_PLUS_DoubleEncodeOffset_EQUALS_0);
Jump notImm1 = getSlowCase(iter);
Jump notImm2 = getSlowCase(iter);
linkSlowCase(iter); // Integer overflow case - we could handle this in JIT code, but this is likely rare.
if (opcodeID == op_mul) // op_mul has an extra slow case to handle 0 * negative number.
linkSlowCase(iter);
emitGetVirtualRegister(op1, X86::eax);
Label stubFunctionCall(this);
emitPutJITStubArg(X86::eax, 1);
emitPutJITStubArg(X86::edx, 2);
if (opcodeID == op_add)
emitCTICall(Interpreter::cti_op_add);
else if (opcodeID == op_sub)
emitCTICall(Interpreter::cti_op_sub);
else {
ASSERT(opcodeID == op_mul);
emitCTICall(Interpreter::cti_op_mul);
}
Jump end = jump();
// if we get here, eax is not an int32, edx not yet checked.
notImm1.link(this);
if (!types.first().definitelyIsNumber())
emitJumpIfNotImmediateNumber(X86::eax).linkTo(stubFunctionCall, this);
if (!types.second().definitelyIsNumber())
emitJumpIfNotImmediateNumber(X86::edx).linkTo(stubFunctionCall, this);
addPtr(tagTypeNumberRegister, X86::eax);
m_assembler.movq_rr(X86::eax, X86::xmm1);
Jump op2isDouble = emitJumpIfNotImmediateInteger(X86::edx);
m_assembler.cvtsi2sd_rr(X86::edx, X86::xmm2);
Jump op2wasInteger = jump();
// if we get here, eax IS an int32, edx is not.
notImm2.link(this);
if (!types.second().definitelyIsNumber())
emitJumpIfNotImmediateNumber(X86::edx).linkTo(stubFunctionCall, this);
m_assembler.cvtsi2sd_rr(X86::eax, X86::xmm1);
op2isDouble.link(this);
addPtr(tagTypeNumberRegister, X86::edx);
m_assembler.movq_rr(X86::edx, X86::xmm2);
op2wasInteger.link(this);
if (opcodeID == op_add)
m_assembler.addsd_rr(X86::xmm2, X86::xmm1);
else if (opcodeID == op_sub)
m_assembler.subsd_rr(X86::xmm2, X86::xmm1);
else {
ASSERT(opcodeID == op_mul);
m_assembler.mulsd_rr(X86::xmm2, X86::xmm1);
}
m_assembler.movq_rr(X86::xmm1, X86::eax);
subPtr(tagTypeNumberRegister, X86::eax);
end.link(this);
}
void JIT::compileBinaryArithOpSlowCase(OpcodeID opcodeID, Vector<SlowCaseEntry>::iterator& iter, unsigned result, unsigned op1, unsigned op2, OperandTypes types, bool op1HasImmediateIntFastCase, bool op2HasImmediateIntFastCase)
{
// We assume that subtracting TagTypeNumber is equivalent to adding DoubleEncodeOffset.
COMPILE_ASSERT(((JSImmediate::TagTypeNumber + JSImmediate::DoubleEncodeOffset) == 0), TagTypeNumber_PLUS_DoubleEncodeOffset_EQUALS_0);
Jump notImm1;
Jump notImm2;
if (op1HasImmediateIntFastCase) {
notImm2 = getSlowCase(iter);
} else if (op2HasImmediateIntFastCase) {
notImm1 = getSlowCase(iter);
} else {
notImm1 = getSlowCase(iter);
notImm2 = getSlowCase(iter);
}
linkSlowCase(iter); // Integer overflow case - we could handle this in JIT code, but this is likely rare.
if (opcodeID == op_mul && !op1HasImmediateIntFastCase && !op2HasImmediateIntFastCase) // op_mul has an extra slow case to handle 0 * negative number.
linkSlowCase(iter);
emitGetVirtualRegister(op1, regT0);
Label stubFunctionCall(this);
JITStubCall stubCall(this, opcodeID == op_add ? cti_op_add : opcodeID == op_sub ? cti_op_sub : cti_op_mul);
if (op1HasImmediateIntFastCase || op2HasImmediateIntFastCase) {
emitGetVirtualRegister(op1, regT0);
emitGetVirtualRegister(op2, regT1);
}
stubCall.addArgument(regT0);
stubCall.addArgument(regT1);
stubCall.call(result);
Jump end = jump();
if (op1HasImmediateIntFastCase) {
notImm2.link(this);
if (!types.second().definitelyIsNumber())
emitJumpIfNotImmediateNumber(regT0).linkTo(stubFunctionCall, this);
emitGetVirtualRegister(op1, regT1);
convertInt32ToDouble(regT1, fpRegT1);
addPtr(tagTypeNumberRegister, regT0);
movePtrToDouble(regT0, fpRegT2);
} else if (op2HasImmediateIntFastCase) {
notImm1.link(this);
if (!types.first().definitelyIsNumber())
emitJumpIfNotImmediateNumber(regT0).linkTo(stubFunctionCall, this);
emitGetVirtualRegister(op2, regT1);
convertInt32ToDouble(regT1, fpRegT1);
addPtr(tagTypeNumberRegister, regT0);
movePtrToDouble(regT0, fpRegT2);
} else {
// if we get here, eax is not an int32, edx not yet checked.
notImm1.link(this);
if (!types.first().definitelyIsNumber())
emitJumpIfNotImmediateNumber(regT0).linkTo(stubFunctionCall, this);
if (!types.second().definitelyIsNumber())
emitJumpIfNotImmediateNumber(regT1).linkTo(stubFunctionCall, this);
addPtr(tagTypeNumberRegister, regT0);
movePtrToDouble(regT0, fpRegT1);
Jump op2isDouble = emitJumpIfNotImmediateInteger(regT1);
convertInt32ToDouble(regT1, fpRegT2);
Jump op2wasInteger = jump();
// if we get here, eax IS an int32, edx is not.
notImm2.link(this);
if (!types.second().definitelyIsNumber())
emitJumpIfNotImmediateNumber(regT1).linkTo(stubFunctionCall, this);
convertInt32ToDouble(regT0, fpRegT1);
op2isDouble.link(this);
addPtr(tagTypeNumberRegister, regT1);
movePtrToDouble(regT1, fpRegT2);
op2wasInteger.link(this);
}
if (opcodeID == op_add)
addDouble(fpRegT2, fpRegT1);
else if (opcodeID == op_sub)
subDouble(fpRegT2, fpRegT1);
else if (opcodeID == op_mul)
mulDouble(fpRegT2, fpRegT1);
else {
ASSERT(opcodeID == op_div);
divDouble(fpRegT2, fpRegT1);
}
moveDoubleToPtr(fpRegT1, regT0);
subPtr(tagTypeNumberRegister, regT0);
emitPutVirtualRegister(result, regT0);
end.link(this);
}
