--- a/js/src/wasm/WasmBaselineCompile.cpp
+++ b/js/src/wasm/WasmBaselineCompile.cpp
@@ -186,32 +186,32 @@ static const Register StackPointer = Rea
#ifdef JS_CODEGEN_X86
// The selection of EBX here steps gingerly around: the need for EDX
// to be allocatable for multiply/divide; ECX to be allocatable for
// shift/rotate; EAX (= ReturnReg) to be allocatable as the joinreg;
// EBX not being one of the WasmTableCall registers; and needing a
// temp register for load/store that has a single-byte persona.
static const Register ScratchRegX86 = ebx;
-# define QUOT_REM_I64_CALLOUT
+# define INT_DIV_I64_CALLOUT
#endif
#ifdef JS_CODEGEN_ARM
// We need a temp for funcPtrCall. It can't be any of the
// WasmTableCall registers, an argument register, or a scratch
// register, and probably should not be ReturnReg.
static const Register FuncPtrCallTemp = CallTempReg1;
// We use our own scratch register, because the macro assembler uses
// the regular scratch register(s) pretty liberally. We could
// work around that in several cases but the mess does not seem
// worth it yet. CallTempReg2 seems safe.
static const Register ScratchRegARM = CallTempReg2;
-# define QUOT_REM_I64_CALLOUT
+# define INT_DIV_I64_CALLOUT
# define I64_TO_FLOAT_CALLOUT
# define FLOAT_TO_I64_CALLOUT
#endif
class BaseCompiler
{
// We define our own ScratchRegister abstractions, deferring to
// the platform's when possible.
@@ -940,21 +940,17 @@ class BaseCompiler
return RegI64(invalidRegister64());
}
RegF64 invalidF64() {
return RegF64(InvalidFloatReg);
}
RegI32 fromI64(RegI64 r) {
-#ifdef JS_PUNBOX64
- return RegI32(r.reg.reg);
-#else
- return RegI32(r.reg.low);
-#endif
+ return RegI32(lowPart(r));
}
RegI64 widenI32(RegI32 r) {
MOZ_ASSERT(!isAvailable(r.reg));
#ifdef JS_PUNBOX64
return RegI64(Register64(r.reg));
#else
RegI32 high = needI32();
@@ -995,18 +991,16 @@ class BaseCompiler
void freeI64Except(RegI64 r, RegI32 except) {
#ifdef JS_PUNBOX64
MOZ_ASSERT(r.reg.reg == except.reg);
#else
MOZ_ASSERT(r.reg.high == except.reg || r.reg.low == except.reg);
freeI64(r);
needI32(except);
#endif
-
-
}
void freeF64(RegF64 r) {
freeFPU(r.reg);
}
void freeF32(RegF32 r) {
freeFPU(r.reg);
@@ -2517,29 +2511,20 @@ class BaseCompiler
masm.move32(Imm32(0), srcDest.reg);
masm.jump(done);
masm.bind(¬DivByZero);
} else {
masm.branchTest32(Assembler::Zero, rhs.reg, rhs.reg, trap(Trap::IntegerDivideByZero));
}
}
- void checkDivideByZeroI64(RegI64 rhs, RegI64 srcDest, Label* done) {
+ void checkDivideByZeroI64(RegI64 r) {
MOZ_ASSERT(!isCompilingAsmJS());
-#if defined(JS_CODEGEN_X64)
- masm.testq(rhs.reg.reg, rhs.reg.reg);
- masm.j(Assembler::Zero, trap(Trap::IntegerDivideByZero));
-#elif defined(JS_CODEGEN_X86) || defined(JS_CODEGEN_ARM)
- Label nonZero;
- masm.branchTest32(Assembler::NonZero, rhs.reg.low, rhs.reg.low, &nonZero);
- masm.branchTest32(Assembler::Zero, rhs.reg.high, rhs.reg.high, trap(Trap::IntegerDivideByZero));
- masm.bind(&nonZero);
-#else
- MOZ_CRASH("BaseCompiler platform hook: checkDivideByZeroI64");
-#endif
+ ScratchI32 scratch(*this);
+ masm.branchTest64(Assembler::Zero, r.reg, r.reg, scratch, trap(Trap::IntegerDivideByZero));
}
void checkDivideSignedOverflowI32(RegI32 rhs, RegI32 srcDest, Label* done, bool zeroOnOverflow) {
Label notMin;
masm.branch32(Assembler::NotEqual, srcDest.reg, Imm32(INT32_MIN), ¬Min);
if (zeroOnOverflow) {
masm.branch32(Assembler::NotEqual, rhs.reg, Imm32(-1), ¬Min);
masm.move32(Imm32(0), srcDest.reg);
@@ -2549,38 +2534,34 @@ class BaseCompiler
masm.branch32(Assembler::Equal, rhs.reg, Imm32(-1), done);
} else {
masm.branch32(Assembler::Equal, rhs.reg, Imm32(-1), trap(Trap::IntegerOverflow));
}
masm.bind(¬Min);
}
void checkDivideSignedOverflowI64(RegI64 rhs, RegI64 srcDest, Label* done, bool zeroOnOverflow) {
-#if defined(JS_CODEGEN_X64) || defined(JS_CODEGEN_X86) || defined(JS_CODEGEN_ARM)
MOZ_ASSERT(!isCompilingAsmJS());
Label notmin;
masm.branch64(Assembler::NotEqual, srcDest.reg, Imm64(INT64_MIN), ¬min);
masm.branch64(Assembler::NotEqual, rhs.reg, Imm64(-1), ¬min);
if (zeroOnOverflow) {
masm.xor64(srcDest.reg, srcDest.reg);
masm.jump(done);
} else {
masm.jump(trap(Trap::IntegerOverflow));
}
masm.bind(¬min);
-#else
- MOZ_CRASH("BaseCompiler platform hook: checkDivideSignedOverflowI64");
-#endif
- }
-
-#ifndef QUOT_REM_I64_CALLOUT
+ }
+
+#ifndef INT_DIV_I64_CALLOUT
void quotientI64(RegI64 rhs, RegI64 srcDest, IsUnsigned isUnsigned) {
Label done;
- checkDivideByZeroI64(rhs, srcDest, &done);
+ checkDivideByZeroI64(rhs);
if (!isUnsigned)
checkDivideSignedOverflowI64(rhs, srcDest, &done, ZeroOnOverflow(false));
# if defined(JS_CODEGEN_X64)
// The caller must set up the following situation.
MOZ_ASSERT(srcDest.reg.reg == rax);
MOZ_ASSERT(isAvailable(rdx));
@@ -2595,17 +2576,17 @@ class BaseCompiler
MOZ_CRASH("BaseCompiler platform hook: quotientI64");
# endif
masm.bind(&done);
}
void remainderI64(RegI64 rhs, RegI64 srcDest, IsUnsigned isUnsigned) {
Label done;
- checkDivideByZeroI64(rhs, srcDest, &done);
+ checkDivideByZeroI64(rhs);
if (!isUnsigned)
checkDivideSignedOverflowI64(rhs, srcDest, &done, ZeroOnOverflow(true));
# if defined(JS_CODEGEN_X64)
// The caller must set up the following situation.
MOZ_ASSERT(srcDest.reg.reg == rax);
MOZ_ASSERT(isAvailable(rdx));
@@ -2618,17 +2599,17 @@ class BaseCompiler
masm.idivq(rhs.reg.reg);
}
masm.movq(rdx, rax);
# else
MOZ_CRASH("BaseCompiler platform hook: remainderI64");
# endif
masm.bind(&done);
}
-#endif
+#endif // INT_DIV_I64_CALLOUT
void pop2xI32ForShiftOrRotate(RegI32* r0, RegI32* r1) {
#if defined(JS_CODEGEN_X86) || defined(JS_CODEGEN_X64)
*r1 = popI32(specific_ecx);
*r0 = popI32();
#else
pop2xI32(r0, r1);
#endif
@@ -2707,29 +2688,42 @@ class BaseCompiler
masm.movl(src.reg.reg, dest.reg);
#elif defined(JS_NUNBOX32)
masm.move32(src.reg.low, dest.reg);
#else
MOZ_CRASH("BaseCompiler platform hook: wrapI64ToI32");
#endif
}
- void extendI32ToI64(RegI32 src, RegI64 dest) {
+ RegI64 popI32ForSignExtendI64() {
+#if defined(JS_CODEGEN_X86)
+ need2xI32(specific_edx, specific_eax);
+ RegI32 r0 = popI32ToSpecific(specific_eax);
+ RegI64 x0 = RegI64(Register64(specific_edx.reg, specific_eax.reg));
+ (void)r0; // x0 is the widening of r0
+#else
+ RegI32 r0 = popI32();
+ RegI64 x0 = widenI32(r0);
+#endif
+ return x0;
+ }
+
+ void signExtendI32ToI64(RegI32 src, RegI64 dest) {
#if defined(JS_CODEGEN_X64)
masm.movslq(src.reg, dest.reg.reg);
#elif defined(JS_CODEGEN_X86)
MOZ_ASSERT(dest.reg.low == src.reg);
MOZ_ASSERT(dest.reg.low == eax);
MOZ_ASSERT(dest.reg.high == edx);
masm.cdq();
#elif defined(JS_CODEGEN_ARM)
masm.ma_mov(src.reg, dest.reg.low);
masm.ma_asr(Imm32(31), src.reg, dest.reg.high);
#else
- MOZ_CRASH("BaseCompiler platform hook: extendI32ToI64");
+ MOZ_CRASH("BaseCompiler platform hook: signExtendI32ToI64");
#endif
}
void extendU32ToI64(RegI32 src, RegI64 dest) {
#if defined(JS_CODEGEN_X64)
masm.movl(src.reg, dest.reg.reg);
#elif defined(JS_NUNBOX32)
masm.move32(src.reg, dest.reg.low);
@@ -2918,17 +2912,17 @@ class BaseCompiler
else
masm.wasmTruncateDoubleToInt64(src.reg, dest.reg, ool->entry(),
ool->rejoin(), temp.reg);
# else
MOZ_CRASH("BaseCompiler platform hook: truncateF64ToI64");
# endif
return true;
}
-#endif
+#endif // FLOAT_TO_I64_CALLOUT
#ifndef I64_TO_FLOAT_CALLOUT
bool convertI64ToFloatNeedsTemp(bool isUnsigned) const {
# if defined(JS_CODEGEN_X86)
return isUnsigned && AssemblerX86Shared::HasSSE3();
# else
return false;
# endif
@@ -2950,17 +2944,17 @@ class BaseCompiler
if (isUnsigned)
masm.convertUInt64ToDouble(src.reg, dest.reg, temp.reg);
else
masm.convertInt64ToDouble(src.reg, dest.reg);
# else
MOZ_CRASH("BaseCompiler platform hook: convertI64ToF64");
# endif
}
-#endif
+#endif // I64_TO_FLOAT_CALLOUT
void cmp64Set(Assembler::Condition cond, RegI64 lhs, RegI64 rhs, RegI32 dest) {
#if defined(JS_CODEGEN_X64)
masm.cmpq(rhs.reg.reg, lhs.reg.reg);
masm.emitSet(cond, dest.reg);
#elif defined(JS_CODEGEN_X86) || defined(JS_CODEGEN_ARM)
// TODO / OPTIMIZE: This is pretty branchy, we should be able to do better.
Label done, condTrue;
@@ -3181,27 +3175,24 @@ class BaseCompiler
Unused << viewType;
Unused << dest;
MOZ_CRASH("Compiler bug: Unexpected platform.");
# endif
}
};
#endif
- private:
void checkOffset(MemoryAccessDesc* access, RegI32 ptr) {
if (access->offset() >= OffsetGuardLimit) {
- masm.branchAdd32(Assembler::CarrySet,
- Imm32(access->offset()), ptr.reg,
+ masm.branchAdd32(Assembler::CarrySet, Imm32(access->offset()), ptr.reg,
trap(Trap::OutOfBounds));
access->clearOffset();
}
}
- public:
// This is the temp register passed as the last argument to load()
MOZ_MUST_USE size_t loadStoreTemps(MemoryAccessDesc& access) {
#if defined(JS_CODEGEN_ARM)
if (access.isUnaligned()) {
switch (access.type()) {
case Scalar::Float32:
return 1;
case Scalar::Float64:
@@ -3500,17 +3491,17 @@ class BaseCompiler
masm.emitUnalignedStore(ByteSize(4), ptr.reg, tmp1.reg, 0);
masm.emitUnalignedStore(ByteSize(4), ptr.reg, tmp2.reg, 4);
} else {
BufferOffset st =
masm.ma_vstr(src.reg, VFPAddr(ptr.reg, VFPOffImm(0)), Assembler::Always);
masm.append(access, st.getOffset(), masm.framePushed());
}
}
-#endif
+#endif // JS_CODEGEN_ARM
////////////////////////////////////////////////////////////
// Generally speaking, ABOVE this point there should be no value
// stack manipulation (calls to popI32 etc).
// Generally speaking, BELOW this point there should be no
// platform dependencies. We make an exception for x86 register
@@ -3592,17 +3583,17 @@ class BaseCompiler
MOZ_MUST_USE bool emitReturn();
MOZ_MUST_USE bool emitCallArgs(const ValTypeVector& args, FunctionCall& baselineCall);
MOZ_MUST_USE bool emitCall();
MOZ_MUST_USE bool emitCallIndirect(bool oldStyle);
MOZ_MUST_USE bool emitCommonMathCall(uint32_t lineOrBytecode, SymbolicAddress callee,
ValTypeVector& signature, ExprType retType);
MOZ_MUST_USE bool emitUnaryMathBuiltinCall(SymbolicAddress callee, ValType operandType);
MOZ_MUST_USE bool emitBinaryMathBuiltinCall(SymbolicAddress callee, ValType operandType);
-#ifdef QUOT_REM_I64_CALLOUT
+#ifdef INT_DIV_I64_CALLOUT
MOZ_MUST_USE bool emitDivOrModI64BuiltinCall(SymbolicAddress callee, ValType operandType);
#endif
MOZ_MUST_USE bool emitGetLocal();
MOZ_MUST_USE bool emitSetLocal();
MOZ_MUST_USE bool emitTeeLocal();
MOZ_MUST_USE bool emitGetGlobal();
MOZ_MUST_USE bool emitSetGlobal();
MOZ_MUST_USE bool emitTeeGlobal();
@@ -3636,17 +3627,17 @@ class BaseCompiler
void emitMultiplyI32();
void emitMultiplyI64();
void emitMultiplyF32();
void emitMultiplyF64();
void emitQuotientI32();
void emitQuotientU32();
void emitRemainderI32();
void emitRemainderU32();
-#ifndef QUOT_REM_I64_CALLOUT
+#ifndef INT_DIV_I64_CALLOUT
void emitQuotientI64();
void emitQuotientU64();
void emitRemainderI64();
void emitRemainderU64();
#endif
void emitDivideF32();
void emitDivideF64();
void emitMinI32();
@@ -3688,49 +3679,47 @@ class BaseCompiler
void emitAbsF64();
void emitNegateI32();
void emitNegateF32();
void emitNegateF64();
void emitSqrtF32();
void emitSqrtF64();
template<bool isUnsigned> MOZ_MUST_USE bool emitTruncateF32ToI32();
template<bool isUnsigned> MOZ_MUST_USE bool emitTruncateF64ToI32();
-#ifndef FLOAT_TO_I64_CALLOUT
+#ifdef FLOAT_TO_I64_CALLOUT
+ MOZ_MUST_USE bool emitConvertFloatingToInt64Callout(SymbolicAddress callee, ValType operandType,
+ ValType resultType);
+#else
template<bool isUnsigned> MOZ_MUST_USE bool emitTruncateF32ToI64();
template<bool isUnsigned> MOZ_MUST_USE bool emitTruncateF64ToI64();
#endif
void emitWrapI64ToI32();
void emitExtendI32ToI64();
void emitExtendU32ToI64();
void emitReinterpretF32AsI32();
void emitReinterpretF64AsI64();
void emitConvertF64ToF32();
void emitConvertI32ToF32();
void emitConvertU32ToF32();
void emitConvertF32ToF64();
void emitConvertI32ToF64();
void emitConvertU32ToF64();
-#ifndef I64_TO_FLOAT_CALLOUT
+#ifdef I64_TO_FLOAT_CALLOUT
+ MOZ_MUST_USE bool emitConvertInt64ToFloatingCallout(SymbolicAddress callee, ValType operandType,
+ ValType resultType);
+#else
void emitConvertI64ToF32();
void emitConvertU64ToF32();
void emitConvertI64ToF64();
void emitConvertU64ToF64();
#endif
void emitReinterpretI32AsF32();
void emitReinterpretI64AsF64();
MOZ_MUST_USE bool emitGrowMemory();
MOZ_MUST_USE bool emitCurrentMemory();
-#ifdef I64_TO_FLOAT_CALLOUT
- MOZ_MUST_USE bool emitConvertInt64ToFloatingCallout(SymbolicAddress callee, ValType operandType,
- ValType resultType);
-#endif
-#ifdef FLOAT_TO_I64_CALLOUT
- MOZ_MUST_USE bool emitConvertFloatingToInt64Callout(SymbolicAddress callee, ValType operandType,
- ValType resultType);
-#endif
};
void
BaseCompiler::emitAddI32()
{
int32_t c;
if (popConstI32(c)) {
RegI32 r = popI32();
@@ -3905,46 +3894,16 @@ BaseCompiler::emitQuotientU32()
checkDivideByZeroI32(r1, r0, &done);
masm.quotient32(r1.reg, r0.reg, IsUnsigned(true));
masm.bind(&done);
freeI32(r1);
pushI32(r0);
}
-#ifndef QUOT_REM_I64_CALLOUT
-void
-BaseCompiler::emitQuotientI64()
-{
-# ifdef JS_PUNBOX64
- RegI64 r0, r1;
- pop2xI64ForIntDiv(&r0, &r1);
- quotientI64(r1, r0, IsUnsigned(false));
- freeI64(r1);
- pushI64(r0);
-# else
- MOZ_CRASH("BaseCompiler platform hook: emitQuotientI64");
-# endif
-}
-
-void
-BaseCompiler::emitQuotientU64()
-{
-# ifdef JS_PUNBOX64
- RegI64 r0, r1;
- pop2xI64ForIntDiv(&r0, &r1);
- quotientI64(r1, r0, IsUnsigned(true));
- freeI64(r1);
- pushI64(r0);
-# else
- MOZ_CRASH("BaseCompiler platform hook: emitQuotientU64");
-# endif
-}
-#endif
-
void
BaseCompiler::emitRemainderI32()
{
// TODO / OPTIMIZE: Fast case if lhs >= 0 and rhs is power of two.
RegI32 r0, r1;
pop2xI32ForIntMulDiv(&r0, &r1);
Label done;
@@ -3968,17 +3927,45 @@ BaseCompiler::emitRemainderU32()
checkDivideByZeroI32(r1, r0, &done);
masm.remainder32(r1.reg, r0.reg, IsUnsigned(true));
masm.bind(&done);
freeI32(r1);
pushI32(r0);
}
-#ifndef QUOT_REM_I64_CALLOUT
+#ifndef INT_DIV_I64_CALLOUT
+void
+BaseCompiler::emitQuotientI64()
+{
+# ifdef JS_PUNBOX64
+ RegI64 r0, r1;
+ pop2xI64ForIntDiv(&r0, &r1);
+ quotientI64(r1, r0, IsUnsigned(false));
+ freeI64(r1);
+ pushI64(r0);
+# else
+ MOZ_CRASH("BaseCompiler platform hook: emitQuotientI64");
+# endif
+}
+
+void
+BaseCompiler::emitQuotientU64()
+{
+# ifdef JS_PUNBOX64
+ RegI64 r0, r1;
+ pop2xI64ForIntDiv(&r0, &r1);
+ quotientI64(r1, r0, IsUnsigned(true));
+ freeI64(r1);
+ pushI64(r0);
+# else
+ MOZ_CRASH("BaseCompiler platform hook: emitQuotientU64");
+# endif
+}
+
void
BaseCompiler::emitRemainderI64()
{
# ifdef JS_PUNBOX64
RegI64 r0, r1;
pop2xI64ForIntDiv(&r0, &r1);
remainderI64(r1, r0, IsUnsigned(false));
freeI64(r1);
@@ -3996,17 +3983,17 @@ BaseCompiler::emitRemainderU64()
pop2xI64ForIntDiv(&r0, &r1);
remainderI64(r1, r0, IsUnsigned(true));
freeI64(r1);
pushI64(r0);
# else
MOZ_CRASH("BaseCompiler platform hook: emitRemainderU64");
# endif
}
-#endif
+#endif // INT_DIV_I64_CALLOUT
void
BaseCompiler::emitDivideF32()
{
RegF32 r0, r1;
pop2xF32(&r0, &r1);
masm.divFloat32(r1.reg, r0.reg);
freeF32(r1);
@@ -4574,40 +4561,34 @@ BaseCompiler::emitTruncateF64ToI64()
} else {
if (!truncateF64ToI64(r0, x0, isUnsigned, invalidF64()))
return false;
}
freeF64(r0);
pushI64(x0);
return true;
}
-#endif
+#endif // FLOAT_TO_I64_CALLOUT
void
BaseCompiler::emitWrapI64ToI32()
{
RegI64 r0 = popI64();
RegI32 i0 = fromI64(r0);
wrapI64ToI32(r0, i0);
freeI64Except(r0, i0);
pushI32(i0);
}
void
BaseCompiler::emitExtendI32ToI64()
{
-#if defined(JS_CODEGEN_X86)
- need2xI32(specific_edx, specific_eax);
- RegI32 r0 = popI32ToSpecific(specific_eax);
- RegI64 x0 = RegI64(Register64(specific_edx.reg, specific_eax.reg));
-#else
- RegI32 r0 = popI32();
- RegI64 x0 = widenI32(r0);
-#endif
- extendI32ToI64(r0, x0);
+ RegI64 x0 = popI32ForSignExtendI64();
+ RegI32 r0 = RegI32(lowPart(x0));
+ signExtendI32ToI64(r0, x0);
pushI64(x0);
// Note: no need to free r0, since it is part of x0
}
void
BaseCompiler::emitExtendU32ToI64()
{
RegI32 r0 = popI32();
@@ -4744,17 +4725,17 @@ BaseCompiler::emitConvertU64ToF64()
if (convertI64ToFloatNeedsTemp(IsUnsigned(true)))
temp = needI32();
convertI64ToF64(r0, IsUnsigned(true), d0, temp);
if (temp.reg != Register::Invalid())
freeI32(temp);
freeI64(r0);
pushF64(d0);
}
-#endif
+#endif // I64_TO_FLOAT_CALLOUT
void
BaseCompiler::emitReinterpretI32AsF32()
{
RegI32 r0 = popI32();
RegF32 f0 = needF32();
masm.moveGPRToFloat32(r0.reg, f0.reg);
freeI32(r0);
@@ -5520,17 +5501,17 @@ BaseCompiler::emitBinaryMathBuiltinCall(
}
if (deadCode_)
return true;
return emitCommonMathCall(lineOrBytecode, callee, SigDD_, ExprType::F64);
}
-#ifdef QUOT_REM_I64_CALLOUT
+#ifdef INT_DIV_I64_CALLOUT
bool
BaseCompiler::emitDivOrModI64BuiltinCall(SymbolicAddress callee, ValType operandType)
{
MOZ_ASSERT(operandType == ValType::I64);
if (deadCode_)
return true;
@@ -5539,17 +5520,17 @@ BaseCompiler::emitDivOrModI64BuiltinCall
needI64(abiReturnRegI64);
RegI32 temp = needI32();
RegI64 rhs = popI64();
RegI64 srcDest = popI64ToSpecific(abiReturnRegI64);
Label done;
- checkDivideByZeroI64(rhs, srcDest, &done);
+ checkDivideByZeroI64(rhs);
if (callee == SymbolicAddress::DivI64)
checkDivideSignedOverflowI64(rhs, srcDest, &done, ZeroOnOverflow(false));
else if (callee == SymbolicAddress::ModI64)
checkDivideSignedOverflowI64(rhs, srcDest, &done, ZeroOnOverflow(true));
masm.setupUnalignedABICall(temp.reg);
masm.passABIArg(srcDest.reg.high);
@@ -5561,17 +5542,17 @@ BaseCompiler::emitDivOrModI64BuiltinCall
masm.bind(&done);
freeI32(temp);
freeI64(rhs);
pushI64(srcDest);
return true;
}
-#endif
+#endif // INT_DIV_I64_CALLOUT
#ifdef I64_TO_FLOAT_CALLOUT
bool
BaseCompiler::emitConvertInt64ToFloatingCallout(SymbolicAddress callee, ValType operandType,
ValType resultType)
{
sync();
@@ -5600,17 +5581,17 @@ BaseCompiler::emitConvertInt64ToFloating
freeF64(rv);
pushF32(rv2);
} else {
pushF64(rv);
}
return true;
}
-#endif
+#endif // I64_TO_FLOAT_CALLOUT
#ifdef FLOAT_TO_I64_CALLOUT
// `Callee` always takes a double, so a float32 input must be converted.
bool
BaseCompiler::emitConvertFloatingToInt64Callout(SymbolicAddress callee, ValType operandType,
ValType resultType)
{
RegF64 doubleInput;
@@ -5657,17 +5638,17 @@ BaseCompiler::emitConvertFloatingToInt64
masm.branch64(Assembler::Equal, rv.reg, Imm64(0x8000000000000000), ool->entry());
masm.bind(ool->rejoin());
pushI64(rv);
freeF64(inputVal);
return true;
}
-#endif
+#endif // FLOAT_TO_I64_CALLOUT
bool
BaseCompiler::emitGetLocal()
{
uint32_t slot;
if (!iter_.readGetLocal(locals_, &slot))
return false;
@@ -6730,35 +6711,35 @@ BaseCompiler::emitBody()
}
case Expr::I64Add:
CHECK_NEXT(emitBinary(emitAddI64, ValType::I64));
case Expr::I64Sub:
CHECK_NEXT(emitBinary(emitSubtractI64, ValType::I64));
case Expr::I64Mul:
CHECK_NEXT(emitBinary(emitMultiplyI64, ValType::I64));
case Expr::I64DivS:
-#ifdef QUOT_REM_I64_CALLOUT
+#ifdef INT_DIV_I64_CALLOUT
CHECK_NEXT(emitDivOrModI64BuiltinCall(SymbolicAddress::DivI64, ValType::I64));
#else
CHECK_NEXT(emitBinary(emitQuotientI64, ValType::I64));
#endif
case Expr::I64DivU:
-#ifdef QUOT_REM_I64_CALLOUT
+#ifdef INT_DIV_I64_CALLOUT
CHECK_NEXT(emitDivOrModI64BuiltinCall(SymbolicAddress::UDivI64, ValType::I64));
#else
CHECK_NEXT(emitBinary(emitQuotientU64, ValType::I64));
#endif
case Expr::I64RemS:
-#ifdef QUOT_REM_I64_CALLOUT
+#ifdef INT_DIV_I64_CALLOUT
CHECK_NEXT(emitDivOrModI64BuiltinCall(SymbolicAddress::ModI64, ValType::I64));
#else
CHECK_NEXT(emitBinary(emitRemainderI64, ValType::I64));
#endif
case Expr::I64RemU:
-#ifdef QUOT_REM_I64_CALLOUT
+#ifdef INT_DIV_I64_CALLOUT
CHECK_NEXT(emitDivOrModI64BuiltinCall(SymbolicAddress::UModI64, ValType::I64));
#else
CHECK_NEXT(emitBinary(emitRemainderU64, ValType::I64));
#endif
case Expr::I64TruncSF32:
#ifdef FLOAT_TO_I64_CALLOUT
CHECK_NEXT(emitCalloutConversionOOM(emitConvertFloatingToInt64Callout,
SymbolicAddress::TruncateDoubleToInt64,
@@ -7192,23 +7173,16 @@ BaseCompiler::emitFunction()
return false;
beginFunction();
UniquePooledLabel functionEnd(newLabel());
if (!pushControl(&functionEnd))
return false;
-#ifdef JS_CODEGEN_ARM64
- // FIXME: There is a hack up at the top to allow the baseline
- // compiler to compile on ARM64 (by defining StackPointer), but
- // the resulting code cannot run. So prevent it from running.
- MOZ_CRASH("Several adjustments required for ARM64 operation");
-#endif
-
if (!emitBody())
return false;
if (!iter_.readFunctionEnd())
return false;
if (!endFunction())
return false;
@@ -7458,11 +7432,11 @@ js::wasm::BaselineCompileFunction(IonCom
if (!f.emitFunction())
return false;
f.finish();
return true;
}
-#undef QUOT_REM_I64_CALLOUT
+#undef INT_DIV_I64_CALLOUT
#undef I64_TO_FLOAT_CALLOUT
#undef FLOAT_TO_I64_CALLOUT