mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-22 17:55:50 +00:00
Bug 1638798 part 1 - Replace MMathFunction::Function enum with UnaryMathFunction enum class. r=evilpie
CacheIR code will use this enum class too. Differential Revision: https://phabricator.services.mozilla.com/D75805
This commit is contained in:
parent
222f19424a
commit
810973a4c4
@ -8522,73 +8522,73 @@ void CodeGenerator::visitMathFunctionD(LMathFunctionD* ins) {
|
||||
|
||||
void* funptr = nullptr;
|
||||
switch (ins->mir()->function()) {
|
||||
case MMathFunction::Log:
|
||||
case UnaryMathFunction::Log:
|
||||
funptr = JS_FUNC_TO_DATA_PTR(void*, js::math_log_impl);
|
||||
break;
|
||||
case MMathFunction::Sin:
|
||||
case UnaryMathFunction::Sin:
|
||||
funptr = JS_FUNC_TO_DATA_PTR(void*, js::math_sin_impl);
|
||||
break;
|
||||
case MMathFunction::Cos:
|
||||
case UnaryMathFunction::Cos:
|
||||
funptr = JS_FUNC_TO_DATA_PTR(void*, js::math_cos_impl);
|
||||
break;
|
||||
case MMathFunction::Exp:
|
||||
case UnaryMathFunction::Exp:
|
||||
funptr = JS_FUNC_TO_DATA_PTR(void*, js::math_exp_impl);
|
||||
break;
|
||||
case MMathFunction::Tan:
|
||||
case UnaryMathFunction::Tan:
|
||||
funptr = JS_FUNC_TO_DATA_PTR(void*, js::math_tan_impl);
|
||||
break;
|
||||
case MMathFunction::ATan:
|
||||
case UnaryMathFunction::ATan:
|
||||
funptr = JS_FUNC_TO_DATA_PTR(void*, js::math_atan_impl);
|
||||
break;
|
||||
case MMathFunction::ASin:
|
||||
case UnaryMathFunction::ASin:
|
||||
funptr = JS_FUNC_TO_DATA_PTR(void*, js::math_asin_impl);
|
||||
break;
|
||||
case MMathFunction::ACos:
|
||||
case UnaryMathFunction::ACos:
|
||||
funptr = JS_FUNC_TO_DATA_PTR(void*, js::math_acos_impl);
|
||||
break;
|
||||
case MMathFunction::Log10:
|
||||
case UnaryMathFunction::Log10:
|
||||
funptr = JS_FUNC_TO_DATA_PTR(void*, js::math_log10_impl);
|
||||
break;
|
||||
case MMathFunction::Log2:
|
||||
case UnaryMathFunction::Log2:
|
||||
funptr = JS_FUNC_TO_DATA_PTR(void*, js::math_log2_impl);
|
||||
break;
|
||||
case MMathFunction::Log1P:
|
||||
case UnaryMathFunction::Log1P:
|
||||
funptr = JS_FUNC_TO_DATA_PTR(void*, js::math_log1p_impl);
|
||||
break;
|
||||
case MMathFunction::ExpM1:
|
||||
case UnaryMathFunction::ExpM1:
|
||||
funptr = JS_FUNC_TO_DATA_PTR(void*, js::math_expm1_impl);
|
||||
break;
|
||||
case MMathFunction::CosH:
|
||||
case UnaryMathFunction::CosH:
|
||||
funptr = JS_FUNC_TO_DATA_PTR(void*, js::math_cosh_impl);
|
||||
break;
|
||||
case MMathFunction::SinH:
|
||||
case UnaryMathFunction::SinH:
|
||||
funptr = JS_FUNC_TO_DATA_PTR(void*, js::math_sinh_impl);
|
||||
break;
|
||||
case MMathFunction::TanH:
|
||||
case UnaryMathFunction::TanH:
|
||||
funptr = JS_FUNC_TO_DATA_PTR(void*, js::math_tanh_impl);
|
||||
break;
|
||||
case MMathFunction::ACosH:
|
||||
case UnaryMathFunction::ACosH:
|
||||
funptr = JS_FUNC_TO_DATA_PTR(void*, js::math_acosh_impl);
|
||||
break;
|
||||
case MMathFunction::ASinH:
|
||||
case UnaryMathFunction::ASinH:
|
||||
funptr = JS_FUNC_TO_DATA_PTR(void*, js::math_asinh_impl);
|
||||
break;
|
||||
case MMathFunction::ATanH:
|
||||
case UnaryMathFunction::ATanH:
|
||||
funptr = JS_FUNC_TO_DATA_PTR(void*, js::math_atanh_impl);
|
||||
break;
|
||||
case MMathFunction::Trunc:
|
||||
case UnaryMathFunction::Trunc:
|
||||
funptr = JS_FUNC_TO_DATA_PTR(void*, js::math_trunc_impl);
|
||||
break;
|
||||
case MMathFunction::Cbrt:
|
||||
case UnaryMathFunction::Cbrt:
|
||||
funptr = JS_FUNC_TO_DATA_PTR(void*, js::math_cbrt_impl);
|
||||
break;
|
||||
case MMathFunction::Floor:
|
||||
case UnaryMathFunction::Floor:
|
||||
funptr = JS_FUNC_TO_DATA_PTR(void*, js::math_floor_impl);
|
||||
break;
|
||||
case MMathFunction::Ceil:
|
||||
case UnaryMathFunction::Ceil:
|
||||
funptr = JS_FUNC_TO_DATA_PTR(void*, js::math_ceil_impl);
|
||||
break;
|
||||
case MMathFunction::Round:
|
||||
case UnaryMathFunction::Round:
|
||||
funptr = JS_FUNC_TO_DATA_PTR(void*, js::math_round_impl);
|
||||
break;
|
||||
default:
|
||||
@ -8611,17 +8611,17 @@ void CodeGenerator::visitMathFunctionF(LMathFunctionF* ins) {
|
||||
void* funptr = nullptr;
|
||||
CheckUnsafeCallWithABI check = CheckUnsafeCallWithABI::Check;
|
||||
switch (ins->mir()->function()) {
|
||||
case MMathFunction::Floor:
|
||||
case UnaryMathFunction::Floor:
|
||||
funptr = JS_FUNC_TO_DATA_PTR(void*, floorf);
|
||||
check = CheckUnsafeCallWithABI::DontCheckOther;
|
||||
break;
|
||||
case MMathFunction::Round:
|
||||
case UnaryMathFunction::Round:
|
||||
funptr = JS_FUNC_TO_DATA_PTR(void*, math_roundf_impl);
|
||||
break;
|
||||
case MMathFunction::Trunc:
|
||||
case UnaryMathFunction::Trunc:
|
||||
funptr = JS_FUNC_TO_DATA_PTR(void*, math_truncf_impl);
|
||||
break;
|
||||
case MMathFunction::Ceil:
|
||||
case UnaryMathFunction::Ceil:
|
||||
funptr = JS_FUNC_TO_DATA_PTR(void*, ceilf);
|
||||
check = CheckUnsafeCallWithABI::DontCheckOther;
|
||||
break;
|
||||
|
@ -758,7 +758,7 @@ class MOZ_STACK_CLASS IonBuilder {
|
||||
InliningResult inlineMathTrunc(CallInfo& callInfo);
|
||||
InliningResult inlineMathSign(CallInfo& callInfo);
|
||||
InliningResult inlineMathFunction(CallInfo& callInfo,
|
||||
MMathFunction::Function function);
|
||||
UnaryMathFunction function);
|
||||
|
||||
// String natives.
|
||||
InliningResult inlineStringObject(CallInfo& callInfo);
|
||||
|
@ -427,43 +427,43 @@ IonBuilder::InliningResult IonBuilder::inlineNativeCall(CallInfo& callInfo,
|
||||
case InlinableNative::MathSign:
|
||||
return inlineMathSign(callInfo);
|
||||
case InlinableNative::MathSin:
|
||||
return inlineMathFunction(callInfo, MMathFunction::Sin);
|
||||
return inlineMathFunction(callInfo, UnaryMathFunction::Sin);
|
||||
case InlinableNative::MathTan:
|
||||
return inlineMathFunction(callInfo, MMathFunction::Tan);
|
||||
return inlineMathFunction(callInfo, UnaryMathFunction::Tan);
|
||||
case InlinableNative::MathCos:
|
||||
return inlineMathFunction(callInfo, MMathFunction::Cos);
|
||||
return inlineMathFunction(callInfo, UnaryMathFunction::Cos);
|
||||
case InlinableNative::MathExp:
|
||||
return inlineMathFunction(callInfo, MMathFunction::Exp);
|
||||
return inlineMathFunction(callInfo, UnaryMathFunction::Exp);
|
||||
case InlinableNative::MathLog:
|
||||
return inlineMathFunction(callInfo, MMathFunction::Log);
|
||||
return inlineMathFunction(callInfo, UnaryMathFunction::Log);
|
||||
case InlinableNative::MathASin:
|
||||
return inlineMathFunction(callInfo, MMathFunction::ASin);
|
||||
return inlineMathFunction(callInfo, UnaryMathFunction::ASin);
|
||||
case InlinableNative::MathATan:
|
||||
return inlineMathFunction(callInfo, MMathFunction::ATan);
|
||||
return inlineMathFunction(callInfo, UnaryMathFunction::ATan);
|
||||
case InlinableNative::MathACos:
|
||||
return inlineMathFunction(callInfo, MMathFunction::ACos);
|
||||
return inlineMathFunction(callInfo, UnaryMathFunction::ACos);
|
||||
case InlinableNative::MathLog10:
|
||||
return inlineMathFunction(callInfo, MMathFunction::Log10);
|
||||
return inlineMathFunction(callInfo, UnaryMathFunction::Log10);
|
||||
case InlinableNative::MathLog2:
|
||||
return inlineMathFunction(callInfo, MMathFunction::Log2);
|
||||
return inlineMathFunction(callInfo, UnaryMathFunction::Log2);
|
||||
case InlinableNative::MathLog1P:
|
||||
return inlineMathFunction(callInfo, MMathFunction::Log1P);
|
||||
return inlineMathFunction(callInfo, UnaryMathFunction::Log1P);
|
||||
case InlinableNative::MathExpM1:
|
||||
return inlineMathFunction(callInfo, MMathFunction::ExpM1);
|
||||
return inlineMathFunction(callInfo, UnaryMathFunction::ExpM1);
|
||||
case InlinableNative::MathCosH:
|
||||
return inlineMathFunction(callInfo, MMathFunction::CosH);
|
||||
return inlineMathFunction(callInfo, UnaryMathFunction::CosH);
|
||||
case InlinableNative::MathSinH:
|
||||
return inlineMathFunction(callInfo, MMathFunction::SinH);
|
||||
return inlineMathFunction(callInfo, UnaryMathFunction::SinH);
|
||||
case InlinableNative::MathTanH:
|
||||
return inlineMathFunction(callInfo, MMathFunction::TanH);
|
||||
return inlineMathFunction(callInfo, UnaryMathFunction::TanH);
|
||||
case InlinableNative::MathACosH:
|
||||
return inlineMathFunction(callInfo, MMathFunction::ACosH);
|
||||
return inlineMathFunction(callInfo, UnaryMathFunction::ACosH);
|
||||
case InlinableNative::MathASinH:
|
||||
return inlineMathFunction(callInfo, MMathFunction::ASinH);
|
||||
return inlineMathFunction(callInfo, UnaryMathFunction::ASinH);
|
||||
case InlinableNative::MathATanH:
|
||||
return inlineMathFunction(callInfo, MMathFunction::ATanH);
|
||||
return inlineMathFunction(callInfo, UnaryMathFunction::ATanH);
|
||||
case InlinableNative::MathCbrt:
|
||||
return inlineMathFunction(callInfo, MMathFunction::Cbrt);
|
||||
return inlineMathFunction(callInfo, UnaryMathFunction::Cbrt);
|
||||
|
||||
// Reflect natives.
|
||||
case InlinableNative::ReflectGetPrototypeOf:
|
||||
@ -740,7 +740,7 @@ MIRType IonBuilder::getInlineReturnType() {
|
||||
}
|
||||
|
||||
IonBuilder::InliningResult IonBuilder::inlineMathFunction(
|
||||
CallInfo& callInfo, MMathFunction::Function function) {
|
||||
CallInfo& callInfo, UnaryMathFunction function) {
|
||||
if (callInfo.constructing()) {
|
||||
return InliningStatus_NotInlined;
|
||||
}
|
||||
@ -1429,7 +1429,7 @@ IonBuilder::InliningResult IonBuilder::inlineMathFloor(CallInfo& callInfo) {
|
||||
RoundingMode::Down);
|
||||
} else {
|
||||
ins = MMathFunction::New(alloc(), callInfo.getArg(0),
|
||||
MMathFunction::Floor);
|
||||
UnaryMathFunction::Floor);
|
||||
}
|
||||
|
||||
current->add(ins);
|
||||
@ -1481,7 +1481,7 @@ IonBuilder::InliningResult IonBuilder::inlineMathCeil(CallInfo& callInfo) {
|
||||
RoundingMode::Up);
|
||||
} else {
|
||||
ins = MMathFunction::New(alloc(), callInfo.getArg(0),
|
||||
MMathFunction::Ceil);
|
||||
UnaryMathFunction::Ceil);
|
||||
}
|
||||
|
||||
current->add(ins);
|
||||
@ -1547,8 +1547,8 @@ IonBuilder::InliningResult IonBuilder::inlineMathRound(CallInfo& callInfo) {
|
||||
|
||||
if (IsFloatingPointType(argType) && returnType == MIRType::Double) {
|
||||
callInfo.setImplicitlyUsedUnchecked();
|
||||
MMathFunction* ins =
|
||||
MMathFunction::New(alloc(), callInfo.getArg(0), MMathFunction::Round);
|
||||
MMathFunction* ins = MMathFunction::New(alloc(), callInfo.getArg(0),
|
||||
UnaryMathFunction::Round);
|
||||
current->add(ins);
|
||||
current->push(ins);
|
||||
return InliningStatus_Inlined;
|
||||
@ -1783,7 +1783,7 @@ IonBuilder::InliningResult IonBuilder::inlineMathTrunc(CallInfo& callInfo) {
|
||||
RoundingMode::TowardsZero);
|
||||
} else {
|
||||
ins = MMathFunction::New(alloc(), callInfo.getArg(0),
|
||||
MMathFunction::Trunc);
|
||||
UnaryMathFunction::Trunc);
|
||||
}
|
||||
|
||||
current->add(ins);
|
||||
@ -3638,7 +3638,7 @@ IonBuilder::InliningResult IonBuilder::inlineToInteger(CallInfo& callInfo) {
|
||||
ins = MNearbyInt::New(alloc(), input, MIRType::Double,
|
||||
RoundingMode::TowardsZero);
|
||||
} else {
|
||||
ins = MMathFunction::New(alloc(), input, MMathFunction::Trunc);
|
||||
ins = MMathFunction::New(alloc(), input, UnaryMathFunction::Trunc);
|
||||
}
|
||||
current->add(ins);
|
||||
|
||||
|
@ -13,6 +13,7 @@
|
||||
#include "mozilla/MathAlgorithms.h"
|
||||
|
||||
#include "jslibmath.h"
|
||||
#include "jsmath.h"
|
||||
|
||||
#include "builtin/RegExp.h"
|
||||
#include "jit/AtomicOperations.h"
|
||||
@ -1373,53 +1374,53 @@ MDefinition* MSign::foldsTo(TempAllocator& alloc) {
|
||||
return MConstant::New(alloc, DoubleValue(out));
|
||||
}
|
||||
|
||||
const char* MMathFunction::FunctionName(Function function) {
|
||||
const char* MMathFunction::FunctionName(UnaryMathFunction function) {
|
||||
switch (function) {
|
||||
case Log:
|
||||
case UnaryMathFunction::Log:
|
||||
return "Log";
|
||||
case Sin:
|
||||
case UnaryMathFunction::Sin:
|
||||
return "Sin";
|
||||
case Cos:
|
||||
case UnaryMathFunction::Cos:
|
||||
return "Cos";
|
||||
case Exp:
|
||||
case UnaryMathFunction::Exp:
|
||||
return "Exp";
|
||||
case Tan:
|
||||
case UnaryMathFunction::Tan:
|
||||
return "Tan";
|
||||
case ACos:
|
||||
case UnaryMathFunction::ACos:
|
||||
return "ACos";
|
||||
case ASin:
|
||||
case UnaryMathFunction::ASin:
|
||||
return "ASin";
|
||||
case ATan:
|
||||
case UnaryMathFunction::ATan:
|
||||
return "ATan";
|
||||
case Log10:
|
||||
case UnaryMathFunction::Log10:
|
||||
return "Log10";
|
||||
case Log2:
|
||||
case UnaryMathFunction::Log2:
|
||||
return "Log2";
|
||||
case Log1P:
|
||||
case UnaryMathFunction::Log1P:
|
||||
return "Log1P";
|
||||
case ExpM1:
|
||||
case UnaryMathFunction::ExpM1:
|
||||
return "ExpM1";
|
||||
case CosH:
|
||||
case UnaryMathFunction::CosH:
|
||||
return "CosH";
|
||||
case SinH:
|
||||
case UnaryMathFunction::SinH:
|
||||
return "SinH";
|
||||
case TanH:
|
||||
case UnaryMathFunction::TanH:
|
||||
return "TanH";
|
||||
case ACosH:
|
||||
case UnaryMathFunction::ACosH:
|
||||
return "ACosH";
|
||||
case ASinH:
|
||||
case UnaryMathFunction::ASinH:
|
||||
return "ASinH";
|
||||
case ATanH:
|
||||
case UnaryMathFunction::ATanH:
|
||||
return "ATanH";
|
||||
case Trunc:
|
||||
case UnaryMathFunction::Trunc:
|
||||
return "Trunc";
|
||||
case Cbrt:
|
||||
case UnaryMathFunction::Cbrt:
|
||||
return "Cbrt";
|
||||
case Floor:
|
||||
case UnaryMathFunction::Floor:
|
||||
return "Floor";
|
||||
case Ceil:
|
||||
case UnaryMathFunction::Ceil:
|
||||
return "Ceil";
|
||||
case Round:
|
||||
case UnaryMathFunction::Round:
|
||||
return "Round";
|
||||
default:
|
||||
MOZ_CRASH("Unknown math function");
|
||||
@ -1443,73 +1444,73 @@ MDefinition* MMathFunction::foldsTo(TempAllocator& alloc) {
|
||||
double in = input->toConstant()->numberToDouble();
|
||||
double out;
|
||||
switch (function_) {
|
||||
case Log:
|
||||
case UnaryMathFunction::Log:
|
||||
out = js::math_log_impl(in);
|
||||
break;
|
||||
case Sin:
|
||||
case UnaryMathFunction::Sin:
|
||||
out = js::math_sin_impl(in);
|
||||
break;
|
||||
case Cos:
|
||||
case UnaryMathFunction::Cos:
|
||||
out = js::math_cos_impl(in);
|
||||
break;
|
||||
case Exp:
|
||||
case UnaryMathFunction::Exp:
|
||||
out = js::math_exp_impl(in);
|
||||
break;
|
||||
case Tan:
|
||||
case UnaryMathFunction::Tan:
|
||||
out = js::math_tan_impl(in);
|
||||
break;
|
||||
case ACos:
|
||||
case UnaryMathFunction::ACos:
|
||||
out = js::math_acos_impl(in);
|
||||
break;
|
||||
case ASin:
|
||||
case UnaryMathFunction::ASin:
|
||||
out = js::math_asin_impl(in);
|
||||
break;
|
||||
case ATan:
|
||||
case UnaryMathFunction::ATan:
|
||||
out = js::math_atan_impl(in);
|
||||
break;
|
||||
case Log10:
|
||||
case UnaryMathFunction::Log10:
|
||||
out = js::math_log10_impl(in);
|
||||
break;
|
||||
case Log2:
|
||||
case UnaryMathFunction::Log2:
|
||||
out = js::math_log2_impl(in);
|
||||
break;
|
||||
case Log1P:
|
||||
case UnaryMathFunction::Log1P:
|
||||
out = js::math_log1p_impl(in);
|
||||
break;
|
||||
case ExpM1:
|
||||
case UnaryMathFunction::ExpM1:
|
||||
out = js::math_expm1_impl(in);
|
||||
break;
|
||||
case CosH:
|
||||
case UnaryMathFunction::CosH:
|
||||
out = js::math_cosh_impl(in);
|
||||
break;
|
||||
case SinH:
|
||||
case UnaryMathFunction::SinH:
|
||||
out = js::math_sinh_impl(in);
|
||||
break;
|
||||
case TanH:
|
||||
case UnaryMathFunction::TanH:
|
||||
out = js::math_tanh_impl(in);
|
||||
break;
|
||||
case ACosH:
|
||||
case UnaryMathFunction::ACosH:
|
||||
out = js::math_acosh_impl(in);
|
||||
break;
|
||||
case ASinH:
|
||||
case UnaryMathFunction::ASinH:
|
||||
out = js::math_asinh_impl(in);
|
||||
break;
|
||||
case ATanH:
|
||||
case UnaryMathFunction::ATanH:
|
||||
out = js::math_atanh_impl(in);
|
||||
break;
|
||||
case Trunc:
|
||||
case UnaryMathFunction::Trunc:
|
||||
out = js::math_trunc_impl(in);
|
||||
break;
|
||||
case Cbrt:
|
||||
case UnaryMathFunction::Cbrt:
|
||||
out = js::math_cbrt_impl(in);
|
||||
break;
|
||||
case Floor:
|
||||
case UnaryMathFunction::Floor:
|
||||
out = js::math_floor_impl(in);
|
||||
break;
|
||||
case Ceil:
|
||||
case UnaryMathFunction::Ceil:
|
||||
out = js::math_ceil_impl(in);
|
||||
break;
|
||||
case Round:
|
||||
case UnaryMathFunction::Round:
|
||||
out = js::math_round_impl(in);
|
||||
break;
|
||||
default:
|
||||
@ -3237,6 +3238,32 @@ void MMathFunction::trySpecializeFloat32(TempAllocator& alloc) {
|
||||
specialization_ = MIRType::Float32;
|
||||
}
|
||||
|
||||
bool MMathFunction::isFloat32Commutative() const {
|
||||
switch (function_) {
|
||||
case UnaryMathFunction::Floor:
|
||||
case UnaryMathFunction::Ceil:
|
||||
case UnaryMathFunction::Round:
|
||||
case UnaryMathFunction::Trunc:
|
||||
return true;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
bool MMathFunction::canRecoverOnBailout() const {
|
||||
switch (function_) {
|
||||
case UnaryMathFunction::Sin:
|
||||
case UnaryMathFunction::Log:
|
||||
case UnaryMathFunction::Ceil:
|
||||
case UnaryMathFunction::Floor:
|
||||
case UnaryMathFunction::Round:
|
||||
case UnaryMathFunction::Trunc:
|
||||
return true;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
MHypot* MHypot::New(TempAllocator& alloc, const MDefinitionVector& vector) {
|
||||
uint32_t length = vector.length();
|
||||
MHypot* hypot = new (alloc) MHypot;
|
||||
|
@ -45,6 +45,8 @@ class FuncExport;
|
||||
|
||||
class StringObject;
|
||||
|
||||
enum class UnaryMathFunction : uint8_t;
|
||||
|
||||
namespace jit {
|
||||
|
||||
// Forward declarations of MIR types.
|
||||
@ -5277,39 +5279,11 @@ class MSign : public MUnaryInstruction, public SignPolicy::Data {
|
||||
|
||||
class MMathFunction : public MUnaryInstruction,
|
||||
public FloatingPointPolicy<0>::Data {
|
||||
public:
|
||||
enum Function {
|
||||
Log,
|
||||
Sin,
|
||||
Cos,
|
||||
Exp,
|
||||
Tan,
|
||||
ACos,
|
||||
ASin,
|
||||
ATan,
|
||||
Log10,
|
||||
Log2,
|
||||
Log1P,
|
||||
ExpM1,
|
||||
CosH,
|
||||
SinH,
|
||||
TanH,
|
||||
ACosH,
|
||||
ASinH,
|
||||
ATanH,
|
||||
Trunc,
|
||||
Cbrt,
|
||||
Floor,
|
||||
Ceil,
|
||||
Round
|
||||
};
|
||||
|
||||
private:
|
||||
Function function_;
|
||||
UnaryMathFunction function_;
|
||||
|
||||
// A nullptr cache means this function will neither access nor update the
|
||||
// cache.
|
||||
MMathFunction(MDefinition* input, Function function)
|
||||
MMathFunction(MDefinition* input, UnaryMathFunction function)
|
||||
: MUnaryInstruction(classOpcode, input), function_(function) {
|
||||
setResultType(MIRType::Double);
|
||||
specialization_ = MIRType::Double;
|
||||
@ -5320,7 +5294,7 @@ class MMathFunction : public MUnaryInstruction,
|
||||
INSTRUCTION_HEADER(MathFunction)
|
||||
TRIVIAL_NEW_WRAPPERS
|
||||
|
||||
Function function() const { return function_; }
|
||||
UnaryMathFunction function() const { return function_; }
|
||||
|
||||
bool congruentTo(const MDefinition* ins) const override {
|
||||
if (!ins->isMathFunction()) {
|
||||
@ -5342,29 +5316,16 @@ class MMathFunction : public MUnaryInstruction,
|
||||
void printOpcode(GenericPrinter& out) const override;
|
||||
#endif
|
||||
|
||||
static const char* FunctionName(Function function);
|
||||
static const char* FunctionName(UnaryMathFunction function);
|
||||
|
||||
bool isFloat32Commutative() const override {
|
||||
return function_ == Floor || function_ == Ceil || function_ == Round ||
|
||||
function_ == Trunc;
|
||||
}
|
||||
bool isFloat32Commutative() const override;
|
||||
void trySpecializeFloat32(TempAllocator& alloc) override;
|
||||
|
||||
void computeRange(TempAllocator& alloc) override;
|
||||
|
||||
MOZ_MUST_USE bool writeRecoverData(
|
||||
CompactBufferWriter& writer) const override;
|
||||
bool canRecoverOnBailout() const override {
|
||||
switch (function_) {
|
||||
case Sin:
|
||||
case Log:
|
||||
case Ceil:
|
||||
case Floor:
|
||||
case Round:
|
||||
case Trunc:
|
||||
return true;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
bool canRecoverOnBailout() const override;
|
||||
|
||||
ALLOW_CLONE(MMathFunction)
|
||||
};
|
||||
|
@ -11,6 +11,7 @@
|
||||
|
||||
#include <algorithm>
|
||||
|
||||
#include "jsmath.h"
|
||||
#include "jsnum.h"
|
||||
|
||||
#include "jit/Ion.h"
|
||||
@ -1835,8 +1836,8 @@ void MArrayPush::computeRange(TempAllocator& alloc) {
|
||||
void MMathFunction::computeRange(TempAllocator& alloc) {
|
||||
Range opRange(getOperand(0));
|
||||
switch (function()) {
|
||||
case Sin:
|
||||
case Cos:
|
||||
case UnaryMathFunction::Sin:
|
||||
case UnaryMathFunction::Cos:
|
||||
if (!opRange.canBeInfiniteOrNaN()) {
|
||||
setRange(Range::NewDoubleRange(alloc, -1.0, 1.0));
|
||||
}
|
||||
|
@ -892,22 +892,23 @@ bool RSign::recover(JSContext* cx, SnapshotIterator& iter) const {
|
||||
bool MMathFunction::writeRecoverData(CompactBufferWriter& writer) const {
|
||||
MOZ_ASSERT(canRecoverOnBailout());
|
||||
switch (function_) {
|
||||
case Ceil:
|
||||
case UnaryMathFunction::Ceil:
|
||||
writer.writeUnsigned(uint32_t(RInstruction::Recover_Ceil));
|
||||
return true;
|
||||
case Floor:
|
||||
case UnaryMathFunction::Floor:
|
||||
writer.writeUnsigned(uint32_t(RInstruction::Recover_Floor));
|
||||
return true;
|
||||
case Round:
|
||||
case UnaryMathFunction::Round:
|
||||
writer.writeUnsigned(uint32_t(RInstruction::Recover_Round));
|
||||
return true;
|
||||
case Trunc:
|
||||
case UnaryMathFunction::Trunc:
|
||||
writer.writeUnsigned(uint32_t(RInstruction::Recover_Trunc));
|
||||
return true;
|
||||
case Sin:
|
||||
case Log:
|
||||
case UnaryMathFunction::Sin:
|
||||
case UnaryMathFunction::Log:
|
||||
static_assert(sizeof(UnaryMathFunction) == sizeof(uint8_t));
|
||||
writer.writeUnsigned(uint32_t(RInstruction::Recover_MathFunction));
|
||||
writer.writeByte(function_);
|
||||
writer.writeByte(uint8_t(function_));
|
||||
return true;
|
||||
default:
|
||||
MOZ_CRASH("Unknown math function.");
|
||||
@ -915,12 +916,12 @@ bool MMathFunction::writeRecoverData(CompactBufferWriter& writer) const {
|
||||
}
|
||||
|
||||
RMathFunction::RMathFunction(CompactBufferReader& reader) {
|
||||
function_ = reader.readByte();
|
||||
function_ = UnaryMathFunction(reader.readByte());
|
||||
}
|
||||
|
||||
bool RMathFunction::recover(JSContext* cx, SnapshotIterator& iter) const {
|
||||
switch (function_) {
|
||||
case MMathFunction::Sin: {
|
||||
case UnaryMathFunction::Sin: {
|
||||
RootedValue arg(cx, iter.read());
|
||||
RootedValue result(cx);
|
||||
|
||||
@ -931,7 +932,7 @@ bool RMathFunction::recover(JSContext* cx, SnapshotIterator& iter) const {
|
||||
iter.storeInstructionResult(result);
|
||||
return true;
|
||||
}
|
||||
case MMathFunction::Log: {
|
||||
case UnaryMathFunction::Log: {
|
||||
RootedValue arg(cx, iter.read());
|
||||
RootedValue result(cx);
|
||||
|
||||
|
@ -488,7 +488,7 @@ class RSign final : public RInstruction {
|
||||
|
||||
class RMathFunction final : public RInstruction {
|
||||
private:
|
||||
uint8_t function_;
|
||||
UnaryMathFunction function_;
|
||||
|
||||
public:
|
||||
RINSTRUCTION_HEADER_NUM_OP_(MathFunction, 1)
|
||||
|
@ -52,8 +52,6 @@ using mozilla::NumberEqualsInt32;
|
||||
using mozilla::PositiveInfinity;
|
||||
using mozilla::WrappingMultiply;
|
||||
|
||||
using UnaryMathFunctionType = double (*)(double);
|
||||
|
||||
template <UnaryMathFunctionType F>
|
||||
static bool math_function(JSContext* cx, HandleValue val,
|
||||
MutableHandleValue res) {
|
||||
|
@ -15,7 +15,36 @@
|
||||
|
||||
namespace js {
|
||||
|
||||
using UnaryFunType = double (*)(double);
|
||||
using UnaryMathFunctionType = double (*)(double);
|
||||
|
||||
// Used for inlining calls to double => double Math functions from JIT code.
|
||||
// Note that this list does not include all unary Math functions: abs and sqrt
|
||||
// for example are missing because the JITs optimize them without a C++ call.
|
||||
enum class UnaryMathFunction : uint8_t {
|
||||
Log,
|
||||
Sin,
|
||||
Cos,
|
||||
Exp,
|
||||
Tan,
|
||||
ACos,
|
||||
ASin,
|
||||
ATan,
|
||||
Log10,
|
||||
Log2,
|
||||
Log1P,
|
||||
ExpM1,
|
||||
CosH,
|
||||
SinH,
|
||||
TanH,
|
||||
ACosH,
|
||||
ASinH,
|
||||
ATanH,
|
||||
Trunc,
|
||||
Cbrt,
|
||||
Floor,
|
||||
Ceil,
|
||||
Round,
|
||||
};
|
||||
|
||||
/*
|
||||
* JS math functions.
|
||||
|
Loading…
Reference in New Issue
Block a user