Bug 1419025 - wasm baseline, rename some controlling macros. r=bbouvier
authorLars T Hansen <lhansen@mozilla.com>
Wed, 22 Nov 2017 12:37:56 +0100
changeset 393269 32b00c586da29bfca96d5fdfd5c9e7932e6736d7
parent 393268 2079792e5c71451b2dfac559d72e7f6f97a5526b
child 393270 c54539f8350fc151c06b347dc6d2e3d05cb10591
push id97628
push userlhansen@mozilla.com
push dateThu, 23 Nov 2017 07:40:41 +0000
treeherdermozilla-inbound@32b00c586da2 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersbbouvier
bugs1419025
milestone59.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1419025 - wasm baseline, rename some controlling macros. r=bbouvier
js/src/wasm/WasmBaselineCompile.cpp
--- a/js/src/wasm/WasmBaselineCompile.cpp
+++ b/js/src/wasm/WasmBaselineCompile.cpp
@@ -161,34 +161,34 @@ static const Register StackPointer = Rea
 // EBX not being one of the WasmTableCall registers; and needing a
 // temp register for load/store that has a single-byte persona.
 //
 // The compiler assumes that ScratchRegX86 has a single-byte persona.
 // Code for 8-byte atomic operations assumes that ScratchRegX86 is in
 // fact ebx.
 static const Register ScratchRegX86 = ebx;
 
-# define INT_DIV_I64_CALLOUT
+# define RABALDR_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 INT_DIV_I64_CALLOUT
-# define I64_TO_FLOAT_CALLOUT
-# define FLOAT_TO_I64_CALLOUT
+# define RABALDR_INT_DIV_I64_CALLOUT
+# define RABALDR_I64_TO_FLOAT_CALLOUT
+# define RABALDR_FLOAT_TO_I64_CALLOUT
 #endif
 
 template<MIRType t>
 struct RegTypeOf {
     static_assert(t == MIRType::Float32 || t == MIRType::Double, "Float mask type");
 };
 
 template<> struct RegTypeOf<MIRType::Float32> {
@@ -3046,17 +3046,17 @@ class BaseCompiler final : public BaseCo
             masm.xor64(srcDest, srcDest);
             masm.jump(done);
         } else {
             masm.jump(trap(Trap::IntegerOverflow));
         }
         masm.bind(&notmin);
     }
 
-#ifndef INT_DIV_I64_CALLOUT
+#ifndef RABALDR_INT_DIV_I64_CALLOUT
     void quotientI64(RegI64 rhs, RegI64 srcDest, IsUnsigned isUnsigned,
                      bool isConst, int64_t c)
     {
         Label done;
 
         if (!isConst || c == 0)
             checkDivideByZeroI64(rhs);
 
@@ -3104,17 +3104,17 @@ class BaseCompiler final : public BaseCo
             masm.idivq(rhs.reg);
         }
         masm.movq(rdx, rax);
 # else
         MOZ_CRASH("BaseCompiler platform hook: remainderI64");
 # endif
         masm.bind(&done);
     }
-#endif // INT_DIV_I64_CALLOUT
+#endif // RABALDR_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
@@ -3302,17 +3302,17 @@ class BaseCompiler final : public BaseCo
             (void)src;
             (void)isUnsigned;
             (void)off;
             MOZ_CRASH("BaseCompiler platform hook: OutOfLineTruncateCheckF32OrF64ToI64");
 #endif
         }
     };
 
-#ifndef FLOAT_TO_I64_CALLOUT
+#ifndef RABALDR_FLOAT_TO_I64_CALLOUT
     MOZ_MUST_USE bool truncateF32ToI64(RegF32 src, RegI64 dest, bool isUnsigned, RegF64 temp) {
 # if defined(JS_CODEGEN_X64) || defined(JS_CODEGEN_X86)
         OutOfLineCode* ool =
             addOutOfLineCode(new (alloc_) OutOfLineTruncateCheckF32OrF64ToI64(AnyReg(src),
                                                                               isUnsigned,
                                                                               bytecodeOffset()));
         if (!ool)
             return false;
@@ -3342,19 +3342,19 @@ class BaseCompiler final : public BaseCo
         else
             masm.wasmTruncateDoubleToInt64(src, dest, ool->entry(),
                                            ool->rejoin(), temp);
 # else
         MOZ_CRASH("BaseCompiler platform hook: truncateF64ToI64");
 # endif
         return true;
     }
-#endif // FLOAT_TO_I64_CALLOUT
-
-#ifndef I64_TO_FLOAT_CALLOUT
+#endif // RABALDR_FLOAT_TO_I64_CALLOUT
+
+#ifndef RABALDR_I64_TO_FLOAT_CALLOUT
     bool convertI64ToFloatNeedsTemp(ValType to, bool isUnsigned) const {
 # if defined(JS_CODEGEN_X86)
         return isUnsigned &&
                ((to == ValType::F64 && AssemblerX86Shared::HasSSE3()) ||
                to == ValType::F32);
 # else
         return isUnsigned;
 # endif
@@ -3376,17 +3376,17 @@ class BaseCompiler final : public BaseCo
         if (isUnsigned)
             masm.convertUInt64ToDouble(src, dest, temp);
         else
             masm.convertInt64ToDouble(src, dest);
 # else
         MOZ_CRASH("BaseCompiler platform hook: convertI64ToF64");
 # endif
     }
-#endif // I64_TO_FLOAT_CALLOUT
+#endif // RABALDR_I64_TO_FLOAT_CALLOUT
 
     void cmp64Set(Assembler::Condition cond, RegI64 lhs, RegI64 rhs, RegI32 dest) {
 #if defined(JS_CODEGEN_X64)
         masm.cmpq(rhs.reg, lhs.reg);
         masm.emitSet(cond, dest);
 #elif defined(JS_CODEGEN_X86) || defined(JS_CODEGEN_ARM)
         // TODO / OPTIMIZE (Bug 1316822): This is pretty branchy, we should be
         // able to do better.
@@ -4266,17 +4266,17 @@ class BaseCompiler final : public BaseCo
     void emitMultiplyI32();
     void emitMultiplyI64();
     void emitMultiplyF32();
     void emitMultiplyF64();
     void emitQuotientI32();
     void emitQuotientU32();
     void emitRemainderI32();
     void emitRemainderU32();
-#ifdef INT_DIV_I64_CALLOUT
+#ifdef RABALDR_INT_DIV_I64_CALLOUT
     void emitDivOrModI64BuiltinCall(SymbolicAddress callee, ValType operandType);
 #else
     void emitQuotientI64();
     void emitQuotientU64();
     void emitRemainderI64();
     void emitRemainderU64();
 #endif
     void emitDivideF32();
@@ -4314,17 +4314,17 @@ class BaseCompiler final : public BaseCo
     void emitAbsF32();
     void emitAbsF64();
     void emitNegateF32();
     void emitNegateF64();
     void emitSqrtF32();
     void emitSqrtF64();
     template<bool isUnsigned> MOZ_MUST_USE bool emitTruncateF32ToI32();
     template<bool isUnsigned> MOZ_MUST_USE bool emitTruncateF64ToI32();
-#ifdef FLOAT_TO_I64_CALLOUT
+#ifdef RABALDR_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 emitExtendI32_8();
@@ -4337,17 +4337,17 @@ class BaseCompiler final : public BaseCo
     void emitReinterpretF32AsI32();
     void emitReinterpretF64AsI64();
     void emitConvertF64ToF32();
     void emitConvertI32ToF32();
     void emitConvertU32ToF32();
     void emitConvertF32ToF64();
     void emitConvertI32ToF64();
     void emitConvertU32ToF64();
-#ifdef I64_TO_FLOAT_CALLOUT
+#ifdef RABALDR_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
@@ -4652,17 +4652,17 @@ BaseCompiler::emitRemainderU32()
         masm.remainder32(r1, r0, IsUnsigned(true));
         masm.bind(&done);
 
         freeI32(r1);
         pushI32(r0);
     }
 }
 
-#ifndef INT_DIV_I64_CALLOUT
+#ifndef RABALDR_INT_DIV_I64_CALLOUT
 void
 BaseCompiler::emitQuotientI64()
 {
 # ifdef JS_PUNBOX64
     int64_t c;
     uint_fast8_t power;
     if (popConstPositivePowerOfTwoI64(&c, &power, 0)) {
         if (power != 0) {
@@ -4767,17 +4767,17 @@ BaseCompiler::emitRemainderU64()
         remainderI64(r1, r0, IsUnsigned(true), isConst, c);
         freeI64(r1);
         pushI64(r0);
     }
 # else
     MOZ_CRASH("BaseCompiler platform hook: emitRemainderU64");
 # endif
 }
-#endif // INT_DIV_I64_CALLOUT
+#endif // RABALDR_INT_DIV_I64_CALLOUT
 
 void
 BaseCompiler::emitDivideF32()
 {
     RegF32 r0, r1;
     pop2xF32(&r0, &r1);
     masm.divFloat32(r1, r0);
     freeF32(r1);
@@ -5339,17 +5339,17 @@ BaseCompiler::emitTruncateF64ToI32()
     RegI32 i0 = needI32();
     if (!truncateF64ToI32(r0, i0, isUnsigned))
         return false;
     freeF64(r0);
     pushI32(i0);
     return true;
 }
 
-#ifndef FLOAT_TO_I64_CALLOUT
+#ifndef RABALDR_FLOAT_TO_I64_CALLOUT
 template<bool isUnsigned>
 bool
 BaseCompiler::emitTruncateF32ToI64()
 {
     RegF32 r0 = popF32();
     RegI64 x0 = needI64();
     if (isUnsigned) {
         RegF64 tmp = needF64();
@@ -5379,17 +5379,17 @@ BaseCompiler::emitTruncateF64ToI64()
     } else {
         if (!truncateF64ToI64(r0, x0, isUnsigned, invalidF64()))
             return false;
     }
     freeF64(r0);
     pushI64(x0);
     return true;
 }
-#endif // FLOAT_TO_I64_CALLOUT
+#endif // RABALDR_FLOAT_TO_I64_CALLOUT
 
 void
 BaseCompiler::emitWrapI64ToI32()
 {
     RegI64 r0 = popI64();
     RegI32 i0 = fromI64(r0);
     masm.move64To32(r0, i0);
     freeI64Except(r0, i0);
@@ -5498,17 +5498,17 @@ BaseCompiler::emitConvertU32ToF32()
 {
     RegI32 r0 = popI32();
     RegF32 f0 = needF32();
     masm.convertUInt32ToFloat32(r0, f0);
     freeI32(r0);
     pushF32(f0);
 }
 
-#ifndef I64_TO_FLOAT_CALLOUT
+#ifndef RABALDR_I64_TO_FLOAT_CALLOUT
 void
 BaseCompiler::emitConvertI64ToF32()
 {
     RegI64 r0 = popI64();
     RegF32 f0 = needF32();
     convertI64ToF32(r0, IsUnsigned(false), f0, RegI32());
     freeI64(r0);
     pushF32(f0);
@@ -5554,17 +5554,17 @@ BaseCompiler::emitConvertU32ToF64()
 {
     RegI32 r0 = popI32();
     RegF64 d0 = needF64();
     masm.convertUInt32ToDouble(r0, d0);
     freeI32(r0);
     pushF64(d0);
 }
 
-#ifndef I64_TO_FLOAT_CALLOUT
+#ifndef RABALDR_I64_TO_FLOAT_CALLOUT
 void
 BaseCompiler::emitConvertI64ToF64()
 {
     RegI64 r0 = popI64();
     RegF64 d0 = needF64();
     convertI64ToF64(r0, IsUnsigned(false), d0, RegI32());
     freeI64(r0);
     pushF64(d0);
@@ -5578,17 +5578,17 @@ BaseCompiler::emitConvertU64ToF64()
     RegI32 temp;
     if (convertI64ToFloatNeedsTemp(ValType::F64, IsUnsigned(true)))
         temp = needI32();
     convertI64ToF64(r0, IsUnsigned(true), d0, temp);
     maybeFreeI32(temp);
     freeI64(r0);
     pushF64(d0);
 }
-#endif // I64_TO_FLOAT_CALLOUT
+#endif // RABALDR_I64_TO_FLOAT_CALLOUT
 
 void
 BaseCompiler::emitReinterpretI32AsF32()
 {
     RegI32 r0 = popI32();
     RegF32 f0 = needF32();
     masm.moveGPRToFloat32(r0, f0);
     freeI32(r0);
@@ -6432,17 +6432,17 @@ BaseCompiler::emitUnaryMathBuiltinCall(S
 
     popValueStackBy(numArgs);
 
     pushReturned(baselineCall, retType);
 
     return true;
 }
 
-#ifdef INT_DIV_I64_CALLOUT
+#ifdef RABALDR_INT_DIV_I64_CALLOUT
 void
 BaseCompiler::emitDivOrModI64BuiltinCall(SymbolicAddress callee, ValType operandType)
 {
     MOZ_ASSERT(operandType == ValType::I64);
     MOZ_ASSERT(!deadCode_);
 
     sync();
 
@@ -6467,19 +6467,19 @@ BaseCompiler::emitDivOrModI64BuiltinCall
     masm.passABIArg(rhs.low);
     masm.callWithABI(bytecodeOffset(), callee);
 
     masm.bind(&done);
 
     freeI64(rhs);
     pushI64(srcDest);
 }
-#endif // INT_DIV_I64_CALLOUT
-
-#ifdef I64_TO_FLOAT_CALLOUT
+#endif // RABALDR_INT_DIV_I64_CALLOUT
+
+#ifdef RABALDR_I64_TO_FLOAT_CALLOUT
 bool
 BaseCompiler::emitConvertInt64ToFloatingCallout(SymbolicAddress callee, ValType operandType,
                                                 ValType resultType)
 {
     sync();
 
     RegI64 input = popI64();
 
@@ -6499,19 +6499,19 @@ BaseCompiler::emitConvertInt64ToFloating
 
     if (resultType == ValType::F32)
         pushF32(captureReturnedF32(call));
     else
         pushF64(captureReturnedF64(call));
 
     return true;
 }
-#endif // I64_TO_FLOAT_CALLOUT
-
-#ifdef FLOAT_TO_I64_CALLOUT
+#endif // RABALDR_I64_TO_FLOAT_CALLOUT
+
+#ifdef RABALDR_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;
     if (operandType == ValType::F32) {
         doubleInput = needF64();
@@ -6554,17 +6554,17 @@ BaseCompiler::emitConvertFloatingToInt64
     masm.branch64(Assembler::Equal, rv, Imm64(0x8000000000000000), ool->entry());
     masm.bind(ool->rejoin());
 
     pushI64(rv);
     freeF64(inputVal);
 
     return true;
 }
-#endif // FLOAT_TO_I64_CALLOUT
+#endif // RABALDR_FLOAT_TO_I64_CALLOUT
 
 bool
 BaseCompiler::emitGetLocal()
 {
     uint32_t slot;
     if (!iter_.readGetLocal(locals_, &slot))
         return false;
 
@@ -7969,69 +7969,69 @@ BaseCompiler::emitBody()
           }
           case uint16_t(Op::I64Add):
             CHECK_NEXT(emitBinary(emitAddI64, ValType::I64));
           case uint16_t(Op::I64Sub):
             CHECK_NEXT(emitBinary(emitSubtractI64, ValType::I64));
           case uint16_t(Op::I64Mul):
             CHECK_NEXT(emitBinary(emitMultiplyI64, ValType::I64));
           case uint16_t(Op::I64DivS):
-#ifdef INT_DIV_I64_CALLOUT
+#ifdef RABALDR_INT_DIV_I64_CALLOUT
             CHECK_NEXT(emitIntDivCallout(emitDivOrModI64BuiltinCall, SymbolicAddress::DivI64,
                                          ValType::I64));
 #else
             CHECK_NEXT(emitBinary(emitQuotientI64, ValType::I64));
 #endif
           case uint16_t(Op::I64DivU):
-#ifdef INT_DIV_I64_CALLOUT
+#ifdef RABALDR_INT_DIV_I64_CALLOUT
             CHECK_NEXT(emitIntDivCallout(emitDivOrModI64BuiltinCall, SymbolicAddress::UDivI64,
                                          ValType::I64));
 #else
             CHECK_NEXT(emitBinary(emitQuotientU64, ValType::I64));
 #endif
           case uint16_t(Op::I64RemS):
-#ifdef INT_DIV_I64_CALLOUT
+#ifdef RABALDR_INT_DIV_I64_CALLOUT
             CHECK_NEXT(emitIntDivCallout(emitDivOrModI64BuiltinCall, SymbolicAddress::ModI64,
                                          ValType::I64));
 #else
             CHECK_NEXT(emitBinary(emitRemainderI64, ValType::I64));
 #endif
           case uint16_t(Op::I64RemU):
-#ifdef INT_DIV_I64_CALLOUT
+#ifdef RABALDR_INT_DIV_I64_CALLOUT
             CHECK_NEXT(emitIntDivCallout(emitDivOrModI64BuiltinCall, SymbolicAddress::UModI64,
                                          ValType::I64));
 #else
             CHECK_NEXT(emitBinary(emitRemainderU64, ValType::I64));
 #endif
           case uint16_t(Op::I64TruncSF32):
-#ifdef FLOAT_TO_I64_CALLOUT
+#ifdef RABALDR_FLOAT_TO_I64_CALLOUT
             CHECK_NEXT(emitCalloutConversionOOM(emitConvertFloatingToInt64Callout,
                                                 SymbolicAddress::TruncateDoubleToInt64,
                                                 ValType::F32, ValType::I64));
 #else
             CHECK_NEXT(emitConversionOOM(emitTruncateF32ToI64<false>, ValType::F32, ValType::I64));
 #endif
           case uint16_t(Op::I64TruncUF32):
-#ifdef FLOAT_TO_I64_CALLOUT
+#ifdef RABALDR_FLOAT_TO_I64_CALLOUT
             CHECK_NEXT(emitCalloutConversionOOM(emitConvertFloatingToInt64Callout,
                                                 SymbolicAddress::TruncateDoubleToUint64,
                                                 ValType::F32, ValType::I64));
 #else
             CHECK_NEXT(emitConversionOOM(emitTruncateF32ToI64<true>, ValType::F32, ValType::I64));
 #endif
           case uint16_t(Op::I64TruncSF64):
-#ifdef FLOAT_TO_I64_CALLOUT
+#ifdef RABALDR_FLOAT_TO_I64_CALLOUT
             CHECK_NEXT(emitCalloutConversionOOM(emitConvertFloatingToInt64Callout,
                                                 SymbolicAddress::TruncateDoubleToInt64,
                                                 ValType::F64, ValType::I64));
 #else
             CHECK_NEXT(emitConversionOOM(emitTruncateF64ToI64<false>, ValType::F64, ValType::I64));
 #endif
           case uint16_t(Op::I64TruncUF64):
-#ifdef FLOAT_TO_I64_CALLOUT
+#ifdef RABALDR_FLOAT_TO_I64_CALLOUT
             CHECK_NEXT(emitCalloutConversionOOM(emitConvertFloatingToInt64Callout,
                                                 SymbolicAddress::TruncateDoubleToUint64,
                                                 ValType::F64, ValType::I64));
 #else
             CHECK_NEXT(emitConversionOOM(emitTruncateF64ToI64<true>, ValType::F64, ValType::I64));
 #endif
           case uint16_t(Op::I64ExtendSI32):
             CHECK_NEXT(emitConversion(emitExtendI32ToI64, ValType::I32, ValType::I64));
@@ -8118,25 +8118,25 @@ BaseCompiler::emitBody()
             CHECK_NEXT(emitUnaryMathBuiltinCall(SymbolicAddress::FloorF, ValType::F32));
           case uint16_t(Op::F32DemoteF64):
             CHECK_NEXT(emitConversion(emitConvertF64ToF32, ValType::F64, ValType::F32));
           case uint16_t(Op::F32ConvertSI32):
             CHECK_NEXT(emitConversion(emitConvertI32ToF32, ValType::I32, ValType::F32));
           case uint16_t(Op::F32ConvertUI32):
             CHECK_NEXT(emitConversion(emitConvertU32ToF32, ValType::I32, ValType::F32));
           case uint16_t(Op::F32ConvertSI64):
-#ifdef I64_TO_FLOAT_CALLOUT
+#ifdef RABALDR_I64_TO_FLOAT_CALLOUT
             CHECK_NEXT(emitCalloutConversionOOM(emitConvertInt64ToFloatingCallout,
                                                 SymbolicAddress::Int64ToFloat32,
                                                 ValType::I64, ValType::F32));
 #else
             CHECK_NEXT(emitConversion(emitConvertI64ToF32, ValType::I64, ValType::F32));
 #endif
           case uint16_t(Op::F32ConvertUI64):
-#ifdef I64_TO_FLOAT_CALLOUT
+#ifdef RABALDR_I64_TO_FLOAT_CALLOUT
             CHECK_NEXT(emitCalloutConversionOOM(emitConvertInt64ToFloatingCallout,
                                                 SymbolicAddress::Uint64ToFloat32,
                                                 ValType::I64, ValType::F32));
 #else
             CHECK_NEXT(emitConversion(emitConvertU64ToF32, ValType::I64, ValType::F32));
 #endif
           case uint16_t(Op::F32ReinterpretI32):
             CHECK_NEXT(emitConversion(emitReinterpretI32AsF32, ValType::I32, ValType::F32));
@@ -8183,25 +8183,25 @@ BaseCompiler::emitBody()
             CHECK_NEXT(emitUnaryMathBuiltinCall(SymbolicAddress::FloorD, ValType::F64));
           case uint16_t(Op::F64PromoteF32):
             CHECK_NEXT(emitConversion(emitConvertF32ToF64, ValType::F32, ValType::F64));
           case uint16_t(Op::F64ConvertSI32):
             CHECK_NEXT(emitConversion(emitConvertI32ToF64, ValType::I32, ValType::F64));
           case uint16_t(Op::F64ConvertUI32):
             CHECK_NEXT(emitConversion(emitConvertU32ToF64, ValType::I32, ValType::F64));
           case uint16_t(Op::F64ConvertSI64):
-#ifdef I64_TO_FLOAT_CALLOUT
+#ifdef RABALDR_I64_TO_FLOAT_CALLOUT
             CHECK_NEXT(emitCalloutConversionOOM(emitConvertInt64ToFloatingCallout,
                                                 SymbolicAddress::Int64ToDouble,
                                                 ValType::I64, ValType::F64));
 #else
             CHECK_NEXT(emitConversion(emitConvertI64ToF64, ValType::I64, ValType::F64));
 #endif
           case uint16_t(Op::F64ConvertUI64):
-#ifdef I64_TO_FLOAT_CALLOUT
+#ifdef RABALDR_I64_TO_FLOAT_CALLOUT
             CHECK_NEXT(emitCalloutConversionOOM(emitConvertInt64ToFloatingCallout,
                                                 SymbolicAddress::Uint64ToDouble,
                                                 ValType::I64, ValType::F64));
 #else
             CHECK_NEXT(emitConversion(emitConvertU64ToF64, ValType::I64, ValType::F64));
 #endif
           case uint16_t(Op::F64Load):
             CHECK_NEXT(emitLoad(ValType::F64, Scalar::Float64));
@@ -8793,12 +8793,12 @@ js::wasm::BaselineCompileFunctions(const
 
     masm.finish();
     if (masm.oom())
         return false;
 
     return code->swap(masm);
 }
 
-#undef INT_DIV_I64_CALLOUT
-#undef I64_TO_FLOAT_CALLOUT
-#undef FLOAT_TO_I64_CALLOUT
+#undef RABALDR_INT_DIV_I64_CALLOUT
+#undef RABALDR_I64_TO_FLOAT_CALLOUT
+#undef RABALDR_FLOAT_TO_I64_CALLOUT
 #undef ATOMIC_PTR