Diff
Modified: trunk/Source/_javascript_Core/ChangeLog (258062 => 258063)
--- trunk/Source/_javascript_Core/ChangeLog 2020-03-07 05:53:34 UTC (rev 258062)
+++ trunk/Source/_javascript_Core/ChangeLog 2020-03-07 06:28:57 UTC (rev 258063)
@@ -1,3 +1,116 @@
+2020-03-06 Mark Lam <[email protected]>
+
+ Add "AndOrdered" to the names of ordered DoubleConditions.
+ https://bugs.webkit.org/show_bug.cgi?id=208736
+
+ Reviewed by Keith Miller.
+
+ Renamed the following:
+ DoubleEqual ==> DoubleEqualAndOrdered
+ DoubleNotEqual ==> DoubleNotEqualAndOrdered
+ DoubleGreaterThan ==> DoubleGreaterThanAndOrdered
+ DoubleGreaterThanOrEqual ==> DoubleGreaterThanOrEqualAndOrdered
+ DoubleLessThan ==> DoubleLessThanAndOrdered
+ DoubleLessThanOrEqual ==> DoubleLessThanOrEqualAndOrdered
+
+ The comment for these enums in MacroAssemblerARM64.h says:
+ // These conditions will only evaluate to true if the comparison is ordered - i.e. neither operand is NaN.
+
+ Adding "AndOrdered" to their names makes this property explicit.
+
+ From reading the original names, one might intuitively think that these conditions
+ map directly to the C++ double comparisons. This intuition is incorrect.
+ Consider the DoubleNotEqual case: let's compare 2 doubles, a and b:
+
+ result = (a != b);
+
+ For C++, if either a or b are NaNs, then a != b will actually return true.
+ This is contrary to the behavior documented in the MacroAssemblerARM64.h comment
+ above about how DoubleNotEqual should behave. In our code, DoubleNotEqual actually
+ means DoubleNotEqualAndOrdered. The C++ != behavior actually matches our
+ DoubleNotEqualOrUnordered condition instead.
+
+ The tendency to want to associate DoubleNotEqual with the behavior of the C++
+ != operator is precisely why we should give these conditions better names.
+ Adding the "AndOperand" name make the expected behavior explicit in the name, and
+ leave no room for confusion with C++ double comparison semantics.
+
+ * assembler/MacroAssembler.cpp:
+ (WTF::printInternal):
+ * assembler/MacroAssembler.h:
+ (JSC::MacroAssembler::invert):
+ * assembler/MacroAssemblerARM64.h:
+ (JSC::MacroAssemblerARM64::moveConditionallyAfterFloatingPointCompare):
+ (JSC::MacroAssemblerARM64::moveDoubleConditionallyAfterFloatingPointCompare):
+ (JSC::MacroAssemblerARM64::jumpAfterFloatingPointCompare):
+ (JSC::MacroAssemblerARM64::floatingPointCompare):
+ * assembler/MacroAssemblerARMv7.h:
+ (JSC::MacroAssemblerARMv7::branchDouble):
+ * assembler/MacroAssemblerMIPS.h:
+ (JSC::MacroAssemblerMIPS::branchDouble):
+ (JSC::MacroAssemblerMIPS::branchDoubleNonZero):
+ * assembler/MacroAssemblerX86Common.h:
+ (JSC::MacroAssemblerX86Common::branchDoubleNonZero):
+ (JSC::MacroAssemblerX86Common::moveConditionallyDouble):
+ (JSC::MacroAssemblerX86Common::invert):
+ (JSC::MacroAssemblerX86Common::floatingPointCompare):
+ (JSC::MacroAssemblerX86Common::jumpAfterFloatingPointCompare):
+ (JSC::MacroAssemblerX86Common::moveConditionallyAfterFloatingPointCompare):
+ * assembler/MacroAssemblerX86_64.h:
+ (JSC::MacroAssemblerX86_64::truncateDoubleToUint64):
+ (JSC::MacroAssemblerX86_64::truncateFloatToUint64):
+ * assembler/testmasm.cpp:
+ (JSC::testCompareDouble):
+ (JSC::testCompareDoubleSameArg):
+ (JSC::testMoveConditionallyFloatingPoint):
+ (JSC::testMoveDoubleConditionallyDouble):
+ (JSC::testMoveDoubleConditionallyDoubleDestSameAsThenCase):
+ (JSC::testMoveDoubleConditionallyDoubleDestSameAsElseCase):
+ (JSC::testMoveDoubleConditionallyFloat):
+ (JSC::testMoveDoubleConditionallyFloatDestSameAsThenCase):
+ (JSC::testMoveDoubleConditionallyFloatDestSameAsElseCase):
+ (JSC::testMoveConditionallyFloatingPointSameArg):
+ (JSC::run):
+ * b3/B3LowerToAir.cpp:
+ * dfg/DFGSpeculativeJIT.cpp:
+ (JSC::DFG::compileClampDoubleToByte):
+ (JSC::DFG::SpeculativeJIT::compileArithRounding):
+ (JSC::DFG::SpeculativeJIT::compileArithMinMax):
+ (JSC::DFG::SpeculativeJIT::compileArithPow):
+ (JSC::DFG::SpeculativeJIT::compileStrictEq):
+ (JSC::DFG::SpeculativeJIT::compileArrayIndexOf):
+ (JSC::DFG::SpeculativeJIT::compileNormalizeMapKey):
+ * dfg/DFGSpeculativeJIT32_64.cpp:
+ (JSC::DFG::SpeculativeJIT::compile):
+ * dfg/DFGSpeculativeJIT64.cpp:
+ (JSC::DFG::SpeculativeJIT::compile):
+ * ftl/FTLLowerDFGToB3.cpp:
+ (JSC::FTL::DFG::LowerDFGToB3::compileNumberIsInteger):
+ * jit/AssemblyHelpers.h:
+ (JSC::AssemblyHelpers::branchIfNotNaN):
+ * jit/JITArithmetic.cpp:
+ (JSC::JIT::emitSlow_op_jless):
+ (JSC::JIT::emitSlow_op_jlesseq):
+ (JSC::JIT::emitSlow_op_jgreater):
+ (JSC::JIT::emitSlow_op_jgreatereq):
+ * jit/JITArithmetic32_64.cpp:
+ (JSC::JIT::emitBinaryDoubleOp):
+ * jit/ThunkGenerators.cpp:
+ (JSC::floorThunkGenerator):
+ (JSC::roundThunkGenerator):
+ * wasm/WasmAirIRGenerator.cpp:
+ (JSC::Wasm::AirIRGenerator::addOp<OpType::F64Le>):
+ (JSC::Wasm::AirIRGenerator::addOp<OpType::F64Lt>):
+ (JSC::Wasm::AirIRGenerator::addFloatingPointMinOrMax):
+ (JSC::Wasm::AirIRGenerator::addOp<OpType::F64Gt>):
+ (JSC::Wasm::AirIRGenerator::addOp<OpType::F64Ge>):
+ (JSC::Wasm::AirIRGenerator::addOp<OpType::F32Lt>):
+ (JSC::Wasm::AirIRGenerator::addOp<OpType::F64Eq>):
+ (JSC::Wasm::AirIRGenerator::addOp<OpType::F32Le>):
+ (JSC::Wasm::AirIRGenerator::addOp<OpType::F32Ge>):
+ (JSC::Wasm::AirIRGenerator::addOp<OpType::F32Eq>):
+ (JSC::Wasm::AirIRGenerator::addOp<OpType::F32Gt>):
+
2020-03-06 David Kilzer <[email protected]>
REGRESSION (r258038): Build failure on Windows 10 bots
Modified: trunk/Source/_javascript_Core/assembler/MacroAssembler.cpp (258062 => 258063)
--- trunk/Source/_javascript_Core/assembler/MacroAssembler.cpp 2020-03-07 05:53:34 UTC (rev 258062)
+++ trunk/Source/_javascript_Core/assembler/MacroAssembler.cpp 2020-03-07 06:28:57 UTC (rev 258063)
@@ -127,23 +127,23 @@
void printInternal(PrintStream& out, MacroAssembler::DoubleCondition cond)
{
switch (cond) {
- case MacroAssembler::DoubleEqual:
- out.print("DoubleEqual");
+ case MacroAssembler::DoubleEqualAndOrdered:
+ out.print("DoubleEqualAndOrdered");
return;
- case MacroAssembler::DoubleNotEqual:
- out.print("DoubleNotEqual");
+ case MacroAssembler::DoubleNotEqualAndOrdered:
+ out.print("DoubleNotEqualAndOrdered");
return;
- case MacroAssembler::DoubleGreaterThan:
- out.print("DoubleGreaterThan");
+ case MacroAssembler::DoubleGreaterThanAndOrdered:
+ out.print("DoubleGreaterThanAndOrdered");
return;
- case MacroAssembler::DoubleGreaterThanOrEqual:
- out.print("DoubleGreaterThanOrEqual");
+ case MacroAssembler::DoubleGreaterThanOrEqualAndOrdered:
+ out.print("DoubleGreaterThanOrEqualAndOrdered");
return;
- case MacroAssembler::DoubleLessThan:
- out.print("DoubleLessThan");
+ case MacroAssembler::DoubleLessThanAndOrdered:
+ out.print("DoubleLessThanAndOrdered");
return;
- case MacroAssembler::DoubleLessThanOrEqual:
- out.print("DoubleLessThanOrEqual");
+ case MacroAssembler::DoubleLessThanOrEqualAndOrdered:
+ out.print("DoubleLessThanOrEqualAndOrdered");
return;
case MacroAssembler::DoubleEqualOrUnordered:
out.print("DoubleEqualOrUnordered");
Modified: trunk/Source/_javascript_Core/assembler/MacroAssembler.h (258062 => 258063)
--- trunk/Source/_javascript_Core/assembler/MacroAssembler.h 2020-03-07 05:53:34 UTC (rev 258062)
+++ trunk/Source/_javascript_Core/assembler/MacroAssembler.h 2020-03-07 06:28:57 UTC (rev 258063)
@@ -164,33 +164,33 @@
static DoubleCondition invert(DoubleCondition cond)
{
switch (cond) {
- case DoubleEqual:
+ case DoubleEqualAndOrdered:
return DoubleNotEqualOrUnordered;
- case DoubleNotEqual:
+ case DoubleNotEqualAndOrdered:
return DoubleEqualOrUnordered;
- case DoubleGreaterThan:
+ case DoubleGreaterThanAndOrdered:
return DoubleLessThanOrEqualOrUnordered;
- case DoubleGreaterThanOrEqual:
+ case DoubleGreaterThanOrEqualAndOrdered:
return DoubleLessThanOrUnordered;
- case DoubleLessThan:
+ case DoubleLessThanAndOrdered:
return DoubleGreaterThanOrEqualOrUnordered;
- case DoubleLessThanOrEqual:
+ case DoubleLessThanOrEqualAndOrdered:
return DoubleGreaterThanOrUnordered;
case DoubleEqualOrUnordered:
- return DoubleNotEqual;
+ return DoubleNotEqualAndOrdered;
case DoubleNotEqualOrUnordered:
- return DoubleEqual;
+ return DoubleEqualAndOrdered;
case DoubleGreaterThanOrUnordered:
- return DoubleLessThanOrEqual;
+ return DoubleLessThanOrEqualAndOrdered;
case DoubleGreaterThanOrEqualOrUnordered:
- return DoubleLessThan;
+ return DoubleLessThanAndOrdered;
case DoubleLessThanOrUnordered:
- return DoubleGreaterThanOrEqual;
+ return DoubleGreaterThanOrEqualAndOrdered;
case DoubleLessThanOrEqualOrUnordered:
- return DoubleGreaterThan;
+ return DoubleGreaterThanAndOrdered;
}
RELEASE_ASSERT_NOT_REACHED();
- return DoubleEqual; // make compiler happy
+ return DoubleEqualAndOrdered; // make compiler happy
}
static bool isInvertible(ResultCondition cond)
Modified: trunk/Source/_javascript_Core/assembler/MacroAssemblerARM64.h (258062 => 258063)
--- trunk/Source/_javascript_Core/assembler/MacroAssemblerARM64.h 2020-03-07 05:53:34 UTC (rev 258062)
+++ trunk/Source/_javascript_Core/assembler/MacroAssemblerARM64.h 2020-03-07 06:28:57 UTC (rev 258063)
@@ -123,12 +123,12 @@
enum DoubleCondition {
// These conditions will only evaluate to true if the comparison is ordered - i.e. neither operand is NaN.
- DoubleEqual = Assembler::ConditionEQ,
- DoubleNotEqual = Assembler::ConditionVC, // Not the right flag! check for this & handle differently.
- DoubleGreaterThan = Assembler::ConditionGT,
- DoubleGreaterThanOrEqual = Assembler::ConditionGE,
- DoubleLessThan = Assembler::ConditionLO,
- DoubleLessThanOrEqual = Assembler::ConditionLS,
+ DoubleEqualAndOrdered = Assembler::ConditionEQ,
+ DoubleNotEqualAndOrdered = Assembler::ConditionVC, // Not the right flag! check for this & handle differently.
+ DoubleGreaterThanAndOrdered = Assembler::ConditionGT,
+ DoubleGreaterThanOrEqualAndOrdered = Assembler::ConditionGE,
+ DoubleLessThanAndOrdered = Assembler::ConditionLO,
+ DoubleLessThanOrEqualAndOrdered = Assembler::ConditionLS,
// If either operand is NaN, these conditions always evaluate to true.
DoubleEqualOrUnordered = Assembler::ConditionVS, // Not the right flag! check for this & handle differently.
DoubleNotEqualOrUnordered = Assembler::ConditionNE,
@@ -2006,7 +2006,7 @@
template<int datasize>
void moveConditionallyAfterFloatingPointCompare(DoubleCondition cond, RegisterID src, RegisterID dest)
{
- if (cond == DoubleNotEqual) {
+ if (cond == DoubleNotEqualAndOrdered) {
Jump unordered = makeBranch(Assembler::ConditionVS);
m_assembler.csel<datasize>(dest, src, dest, Assembler::ConditionNE);
unordered.link(this);
@@ -2027,7 +2027,7 @@
template<int datasize>
void moveConditionallyAfterFloatingPointCompare(DoubleCondition cond, RegisterID thenCase, RegisterID elseCase, RegisterID dest)
{
- if (cond == DoubleNotEqual) {
+ if (cond == DoubleNotEqualAndOrdered) {
if (dest == thenCase) {
// If the compare is unordered, elseCase is copied to thenCase and the
// next csel has all arguments equal to elseCase.
@@ -2065,7 +2065,7 @@
template<int datasize>
void moveDoubleConditionallyAfterFloatingPointCompare(DoubleCondition cond, FPRegisterID thenCase, FPRegisterID elseCase, FPRegisterID dest)
{
- if (cond == DoubleNotEqual) {
+ if (cond == DoubleNotEqualAndOrdered) {
if (dest == thenCase) {
// If the compare is unordered, elseCase is copied to thenCase and the
// next fcsel has all arguments equal to elseCase.
@@ -4617,7 +4617,7 @@
Jump jumpAfterFloatingPointCompare(DoubleCondition cond)
{
- if (cond == DoubleNotEqual) {
+ if (cond == DoubleNotEqualAndOrdered) {
// ConditionNE jumps if NotEqual *or* unordered - force the unordered cases not to jump.
Jump unordered = makeBranch(Assembler::ConditionVS);
Jump result = makeBranch(Assembler::ConditionNE);
@@ -4639,7 +4639,7 @@
template<typename Function>
void floatingPointCompare(DoubleCondition cond, FPRegisterID left, FPRegisterID right, RegisterID dest, Function compare)
{
- if (cond == DoubleNotEqual) {
+ if (cond == DoubleNotEqualAndOrdered) {
// ConditionNE sets 1 if NotEqual *or* unordered - force the unordered cases not to set 1.
move(TrustedImm32(0), dest);
compare(left, right);
Modified: trunk/Source/_javascript_Core/assembler/MacroAssemblerARMv7.h (258062 => 258063)
--- trunk/Source/_javascript_Core/assembler/MacroAssemblerARMv7.h 2020-03-07 05:53:34 UTC (rev 258062)
+++ trunk/Source/_javascript_Core/assembler/MacroAssemblerARMv7.h 2020-03-07 06:28:57 UTC (rev 258063)
@@ -128,12 +128,12 @@
enum DoubleCondition {
// These conditions will only evaluate to true if the comparison is ordered - i.e. neither operand is NaN.
- DoubleEqual = ARMv7Assembler::ConditionEQ,
- DoubleNotEqual = ARMv7Assembler::ConditionVC, // Not the right flag! check for this & handle differently.
- DoubleGreaterThan = ARMv7Assembler::ConditionGT,
- DoubleGreaterThanOrEqual = ARMv7Assembler::ConditionGE,
- DoubleLessThan = ARMv7Assembler::ConditionLO,
- DoubleLessThanOrEqual = ARMv7Assembler::ConditionLS,
+ DoubleEqualAndOrdered = ARMv7Assembler::ConditionEQ,
+ DoubleNotEqualAndOrdered = ARMv7Assembler::ConditionVC, // Not the right flag! check for this & handle differently.
+ DoubleGreaterThanAndOrdered = ARMv7Assembler::ConditionGT,
+ DoubleGreaterThanOrEqualAndOrdered = ARMv7Assembler::ConditionGE,
+ DoubleLessThanAndOrdered = ARMv7Assembler::ConditionLO,
+ DoubleLessThanOrEqualAndOrdered = ARMv7Assembler::ConditionLS,
// If either operand is NaN, these conditions always evaluate to true.
DoubleEqualOrUnordered = ARMv7Assembler::ConditionVS, // Not the right flag! check for this & handle differently.
DoubleNotEqualOrUnordered = ARMv7Assembler::ConditionNE,
@@ -1218,7 +1218,7 @@
m_assembler.vcmp(left, right);
m_assembler.vmrs();
- if (cond == DoubleNotEqual) {
+ if (cond == DoubleNotEqualAndOrdered) {
// ConditionNE jumps if NotEqual *or* unordered - force the unordered cases not to jump.
Jump unordered = makeBranch(ARMv7Assembler::ConditionVS);
Jump result = makeBranch(ARMv7Assembler::ConditionNE);
Modified: trunk/Source/_javascript_Core/assembler/MacroAssemblerMIPS.h (258062 => 258063)
--- trunk/Source/_javascript_Core/assembler/MacroAssemblerMIPS.h 2020-03-07 05:53:34 UTC (rev 258062)
+++ trunk/Source/_javascript_Core/assembler/MacroAssemblerMIPS.h 2020-03-07 06:28:57 UTC (rev 258063)
@@ -99,12 +99,12 @@
};
enum DoubleCondition {
- DoubleEqual,
- DoubleNotEqual,
- DoubleGreaterThan,
- DoubleGreaterThanOrEqual,
- DoubleLessThan,
- DoubleLessThanOrEqual,
+ DoubleEqualAndOrdered,
+ DoubleNotEqualAndOrdered,
+ DoubleGreaterThanAndOrdered,
+ DoubleGreaterThanOrEqualAndOrdered,
+ DoubleLessThanAndOrdered,
+ DoubleLessThanOrEqualAndOrdered,
DoubleEqualOrUnordered,
DoubleNotEqualOrUnordered,
DoubleGreaterThanOrUnordered,
@@ -3204,27 +3204,27 @@
Jump branchDouble(DoubleCondition cond, FPRegisterID left, FPRegisterID right)
{
- if (cond == DoubleEqual) {
+ if (cond == DoubleEqualAndOrdered) {
m_assembler.ceqd(left, right);
return branchTrue();
}
- if (cond == DoubleNotEqual) {
+ if (cond == DoubleNotEqualAndOrdered) {
m_assembler.cueqd(left, right);
return branchFalse(); // false
}
- if (cond == DoubleGreaterThan) {
+ if (cond == DoubleGreaterThanAndOrdered) {
m_assembler.cngtd(left, right);
return branchFalse(); // false
}
- if (cond == DoubleGreaterThanOrEqual) {
+ if (cond == DoubleGreaterThanOrEqualAndOrdered) {
m_assembler.cnged(left, right);
return branchFalse(); // false
}
- if (cond == DoubleLessThan) {
+ if (cond == DoubleLessThanAndOrdered) {
m_assembler.cltd(left, right);
return branchTrue();
}
- if (cond == DoubleLessThanOrEqual) {
+ if (cond == DoubleLessThanOrEqualAndOrdered) {
m_assembler.cled(left, right);
return branchTrue();
}
@@ -3305,7 +3305,7 @@
Jump branchDoubleNonZero(FPRegisterID reg, FPRegisterID scratch)
{
m_assembler.vmov(scratch, MIPSRegisters::zero, MIPSRegisters::zero);
- return branchDouble(DoubleNotEqual, reg, scratch);
+ return branchDouble(DoubleNotEqualAndOrdered, reg, scratch);
}
Jump branchDoubleZeroOrNaN(FPRegisterID reg, FPRegisterID scratch)
Modified: trunk/Source/_javascript_Core/assembler/MacroAssemblerX86Common.h (258062 => 258063)
--- trunk/Source/_javascript_Core/assembler/MacroAssemblerX86Common.h 2020-03-07 05:53:34 UTC (rev 258062)
+++ trunk/Source/_javascript_Core/assembler/MacroAssemblerX86Common.h 2020-03-07 06:28:57 UTC (rev 258063)
@@ -88,12 +88,12 @@
// FIXME: it would be neat to rename this to FloatingPointCondition in every assembler.
enum DoubleCondition {
// These conditions will only evaluate to true if the comparison is ordered - i.e. neither operand is NaN.
- DoubleEqual = X86Assembler::ConditionE | DoubleConditionBitSpecial,
- DoubleNotEqual = X86Assembler::ConditionNE,
- DoubleGreaterThan = X86Assembler::ConditionA,
- DoubleGreaterThanOrEqual = X86Assembler::ConditionAE,
- DoubleLessThan = X86Assembler::ConditionA | DoubleConditionBitInvert,
- DoubleLessThanOrEqual = X86Assembler::ConditionAE | DoubleConditionBitInvert,
+ DoubleEqualAndOrdered = X86Assembler::ConditionE | DoubleConditionBitSpecial,
+ DoubleNotEqualAndOrdered = X86Assembler::ConditionNE,
+ DoubleGreaterThanAndOrdered = X86Assembler::ConditionA,
+ DoubleGreaterThanOrEqualAndOrdered = X86Assembler::ConditionAE,
+ DoubleLessThanAndOrdered = X86Assembler::ConditionA | DoubleConditionBitInvert,
+ DoubleLessThanOrEqualAndOrdered = X86Assembler::ConditionAE | DoubleConditionBitInvert,
// If either operand is NaN, these conditions always evaluate to true.
DoubleEqualOrUnordered = X86Assembler::ConditionE,
DoubleNotEqualOrUnordered = X86Assembler::ConditionNE | DoubleConditionBitSpecial,
@@ -2080,7 +2080,7 @@
Jump branchDoubleNonZero(FPRegisterID reg, FPRegisterID scratch)
{
m_assembler.xorpd_rr(scratch, scratch);
- return branchDouble(DoubleNotEqual, reg, scratch);
+ return branchDouble(DoubleNotEqualAndOrdered, reg, scratch);
}
Jump branchDoubleZeroOrNaN(FPRegisterID reg, FPRegisterID scratch)
@@ -2324,7 +2324,7 @@
else
m_assembler.ucomisd_rr(right, left);
- if (cond == DoubleEqual) {
+ if (cond == DoubleEqualAndOrdered) {
if (left == right) {
m_assembler.cmovnpl_rr(src, dest);
return;
@@ -3037,33 +3037,33 @@
static DoubleCondition invert(DoubleCondition cond)
{
switch (cond) {
- case DoubleEqual:
+ case DoubleEqualAndOrdered:
return DoubleNotEqualOrUnordered;
- case DoubleNotEqual:
+ case DoubleNotEqualAndOrdered:
return DoubleEqualOrUnordered;
- case DoubleGreaterThan:
+ case DoubleGreaterThanAndOrdered:
return DoubleLessThanOrEqualOrUnordered;
- case DoubleGreaterThanOrEqual:
+ case DoubleGreaterThanOrEqualAndOrdered:
return DoubleLessThanOrUnordered;
- case DoubleLessThan:
+ case DoubleLessThanAndOrdered:
return DoubleGreaterThanOrEqualOrUnordered;
- case DoubleLessThanOrEqual:
+ case DoubleLessThanOrEqualAndOrdered:
return DoubleGreaterThanOrUnordered;
case DoubleEqualOrUnordered:
- return DoubleNotEqual;
+ return DoubleNotEqualAndOrdered;
case DoubleNotEqualOrUnordered:
- return DoubleEqual;
+ return DoubleEqualAndOrdered;
case DoubleGreaterThanOrUnordered:
- return DoubleLessThanOrEqual;
+ return DoubleLessThanOrEqualAndOrdered;
case DoubleGreaterThanOrEqualOrUnordered:
- return DoubleLessThan;
+ return DoubleLessThanAndOrdered;
case DoubleLessThanOrUnordered:
- return DoubleGreaterThanOrEqual;
+ return DoubleGreaterThanOrEqualAndOrdered;
case DoubleLessThanOrEqualOrUnordered:
- return DoubleGreaterThan;
+ return DoubleGreaterThanAndOrdered;
}
RELEASE_ASSERT_NOT_REACHED();
- return DoubleEqual; // make compiler happy
+ return DoubleEqualAndOrdered; // make compiler happy
}
static bool isInvertible(ResultCondition cond)
@@ -4122,7 +4122,7 @@
{
if (cond & DoubleConditionBitSpecial) {
ASSERT(!(cond & DoubleConditionBitInvert));
- if (cond == DoubleEqual) {
+ if (cond == DoubleEqualAndOrdered) {
if (left == right) {
compare(right, left);
set32(X86Assembler::ConditionNP, dest);
@@ -4164,7 +4164,7 @@
Jump jumpAfterFloatingPointCompare(DoubleCondition cond, FPRegisterID left, FPRegisterID right)
{
- if (cond == DoubleEqual) {
+ if (cond == DoubleEqualAndOrdered) {
if (left == right)
return Jump(m_assembler.jnp());
Jump isUnordered(m_assembler.jp());
@@ -4199,7 +4199,7 @@
#if CPU(X86_64)
void moveConditionallyAfterFloatingPointCompare(DoubleCondition cond, FPRegisterID left, FPRegisterID right, RegisterID src, RegisterID dest)
{
- if (cond == DoubleEqual) {
+ if (cond == DoubleEqualAndOrdered) {
if (left == right) {
m_assembler.cmovnpq_rr(src, dest);
return;
Modified: trunk/Source/_javascript_Core/assembler/MacroAssemblerX86_64.h (258062 => 258063)
--- trunk/Source/_javascript_Core/assembler/MacroAssemblerX86_64.h 2020-03-07 05:53:34 UTC (rev 258062)
+++ trunk/Source/_javascript_Core/assembler/MacroAssemblerX86_64.h 2020-03-07 06:28:57 UTC (rev 258063)
@@ -1783,7 +1783,7 @@
// instructions are the same. Otherwise, we need to: subtract int64_t::min(); truncate double to
// uint64_t; then add back int64_t::min() in the destination gpr.
- Jump large = branchDouble(DoubleGreaterThanOrEqual, src, int64Min);
+ Jump large = branchDouble(DoubleGreaterThanOrEqualAndOrdered, src, int64Min);
m_assembler.cvttsd2siq_rr(src, dest);
Jump done = jump();
large.link(this);
@@ -1816,7 +1816,7 @@
// instructions are the same. Otherwise, we need to: subtract int64_t::min(); truncate double to
// uint64_t; then add back int64_t::min() in the destination gpr.
- Jump large = branchFloat(DoubleGreaterThanOrEqual, src, int64Min);
+ Jump large = branchFloat(DoubleGreaterThanOrEqualAndOrdered, src, int64Min);
m_assembler.cvttss2siq_rr(src, dest);
Jump done = jump();
large.link(this);
Modified: trunk/Source/_javascript_Core/assembler/testmasm.cpp (258062 => 258063)
--- trunk/Source/_javascript_Core/assembler/testmasm.cpp 2020-03-07 05:53:34 UTC (rev 258062)
+++ trunk/Source/_javascript_Core/assembler/testmasm.cpp 2020-03-07 06:28:57 UTC (rev 258063)
@@ -504,17 +504,17 @@
return x != x;
};
switch (condition) {
- case MacroAssembler::DoubleEqual:
+ case MacroAssembler::DoubleEqualAndOrdered:
return !isUnordered(a) && !isUnordered(b) && (a == b);
- case MacroAssembler::DoubleNotEqual:
+ case MacroAssembler::DoubleNotEqualAndOrdered:
return !isUnordered(a) && !isUnordered(b) && (a != b);
- case MacroAssembler::DoubleGreaterThan:
+ case MacroAssembler::DoubleGreaterThanAndOrdered:
return !isUnordered(a) && !isUnordered(b) && (a > b);
- case MacroAssembler::DoubleGreaterThanOrEqual:
+ case MacroAssembler::DoubleGreaterThanOrEqualAndOrdered:
return !isUnordered(a) && !isUnordered(b) && (a >= b);
- case MacroAssembler::DoubleLessThan:
+ case MacroAssembler::DoubleLessThanAndOrdered:
return !isUnordered(a) && !isUnordered(b) && (a < b);
- case MacroAssembler::DoubleLessThanOrEqual:
+ case MacroAssembler::DoubleLessThanOrEqualAndOrdered:
return !isUnordered(a) && !isUnordered(b) && (a <= b);
case MacroAssembler::DoubleEqualOrUnordered:
return isUnordered(a) || isUnordered(b) || (a == b);
@@ -576,17 +576,17 @@
return x != x;
};
switch (condition) {
- case MacroAssembler::DoubleEqual:
+ case MacroAssembler::DoubleEqualAndOrdered:
return !isUnordered(a) && (a == a);
- case MacroAssembler::DoubleNotEqual:
+ case MacroAssembler::DoubleNotEqualAndOrdered:
return !isUnordered(a) && (a != a);
- case MacroAssembler::DoubleGreaterThan:
+ case MacroAssembler::DoubleGreaterThanAndOrdered:
return !isUnordered(a) && (a > a);
- case MacroAssembler::DoubleGreaterThanOrEqual:
+ case MacroAssembler::DoubleGreaterThanOrEqualAndOrdered:
return !isUnordered(a) && (a >= a);
- case MacroAssembler::DoubleLessThan:
+ case MacroAssembler::DoubleLessThanAndOrdered:
return !isUnordered(a) && (a < a);
- case MacroAssembler::DoubleLessThanOrEqual:
+ case MacroAssembler::DoubleLessThanOrEqualAndOrdered:
return !isUnordered(a) && (a <= a);
case MacroAssembler::DoubleEqualOrUnordered:
return isUnordered(a) || (a == a);
@@ -701,17 +701,17 @@
return x != x;
};
switch (condition) {
- case MacroAssembler::DoubleEqual:
+ case MacroAssembler::DoubleEqualAndOrdered:
return !isUnordered(a) && !isUnordered(b) && (a == b) ? selectionA : selectionB;
- case MacroAssembler::DoubleNotEqual:
+ case MacroAssembler::DoubleNotEqualAndOrdered:
return !isUnordered(a) && !isUnordered(b) && (a != b) ? selectionA : selectionB;
- case MacroAssembler::DoubleGreaterThan:
+ case MacroAssembler::DoubleGreaterThanAndOrdered:
return !isUnordered(a) && !isUnordered(b) && (a > b) ? selectionA : selectionB;
- case MacroAssembler::DoubleGreaterThanOrEqual:
+ case MacroAssembler::DoubleGreaterThanOrEqualAndOrdered:
return !isUnordered(a) && !isUnordered(b) && (a >= b) ? selectionA : selectionB;
- case MacroAssembler::DoubleLessThan:
+ case MacroAssembler::DoubleLessThanAndOrdered:
return !isUnordered(a) && !isUnordered(b) && (a < b) ? selectionA : selectionB;
- case MacroAssembler::DoubleLessThanOrEqual:
+ case MacroAssembler::DoubleLessThanOrEqualAndOrdered:
return !isUnordered(a) && !isUnordered(b) && (a <= b) ? selectionA : selectionB;
case MacroAssembler::DoubleEqualOrUnordered:
return isUnordered(a) || isUnordered(b) || (a == b) ? selectionA : selectionB;
@@ -1039,12 +1039,12 @@
FPRReg tempFPR = FPRInfo::fpRegT5;
jit.loadDouble(CCallHelpers::TrustedImmPtr(&selectionA), tempFPR);
- auto aIsUnchanged = jit.branchDouble(CCallHelpers::DoubleEqual, selectionAFPR, tempFPR);
+ auto aIsUnchanged = jit.branchDouble(CCallHelpers::DoubleEqualAndOrdered, selectionAFPR, tempFPR);
jit.loadDouble(CCallHelpers::TrustedImmPtr(&corruptedSelectionA), destFPR);
aIsUnchanged.link(&jit);
jit.loadDouble(CCallHelpers::TrustedImmPtr(&selectionB), tempFPR);
- auto bIsUnchanged = jit.branchDouble(CCallHelpers::DoubleEqual, selectionBFPR, tempFPR);
+ auto bIsUnchanged = jit.branchDouble(CCallHelpers::DoubleEqualAndOrdered, selectionBFPR, tempFPR);
jit.loadDouble(CCallHelpers::TrustedImmPtr(&corruptedSelectionB), destFPR);
bIsUnchanged.link(&jit);
@@ -1085,7 +1085,7 @@
FPRReg tempFPR = FPRInfo::fpRegT5;
jit.loadDouble(CCallHelpers::TrustedImmPtr(&selectionB), tempFPR);
- auto bIsUnchanged = jit.branchDouble(CCallHelpers::DoubleEqual, selectionBFPR, tempFPR);
+ auto bIsUnchanged = jit.branchDouble(CCallHelpers::DoubleEqualAndOrdered, selectionBFPR, tempFPR);
jit.loadDouble(CCallHelpers::TrustedImmPtr(&corruptedSelectionB), destFPR);
bIsUnchanged.link(&jit);
@@ -1126,7 +1126,7 @@
FPRReg tempFPR = FPRInfo::fpRegT5;
jit.loadDouble(CCallHelpers::TrustedImmPtr(&selectionA), tempFPR);
- auto aIsUnchanged = jit.branchDouble(CCallHelpers::DoubleEqual, selectionAFPR, tempFPR);
+ auto aIsUnchanged = jit.branchDouble(CCallHelpers::DoubleEqualAndOrdered, selectionAFPR, tempFPR);
jit.loadDouble(CCallHelpers::TrustedImmPtr(&corruptedSelectionA), destFPR);
aIsUnchanged.link(&jit);
@@ -1168,12 +1168,12 @@
FPRReg tempFPR = FPRInfo::fpRegT5;
jit.loadDouble(CCallHelpers::TrustedImmPtr(&selectionA), tempFPR);
- auto aIsUnchanged = jit.branchDouble(CCallHelpers::DoubleEqual, selectionAFPR, tempFPR);
+ auto aIsUnchanged = jit.branchDouble(CCallHelpers::DoubleEqualAndOrdered, selectionAFPR, tempFPR);
jit.loadDouble(CCallHelpers::TrustedImmPtr(&corruptedSelectionA), destFPR);
aIsUnchanged.link(&jit);
jit.loadDouble(CCallHelpers::TrustedImmPtr(&selectionB), tempFPR);
- auto bIsUnchanged = jit.branchDouble(CCallHelpers::DoubleEqual, selectionBFPR, tempFPR);
+ auto bIsUnchanged = jit.branchDouble(CCallHelpers::DoubleEqualAndOrdered, selectionBFPR, tempFPR);
jit.loadDouble(CCallHelpers::TrustedImmPtr(&corruptedSelectionB), destFPR);
bIsUnchanged.link(&jit);
@@ -1214,7 +1214,7 @@
FPRReg tempFPR = FPRInfo::fpRegT5;
jit.loadDouble(CCallHelpers::TrustedImmPtr(&selectionB), tempFPR);
- auto bIsUnchanged = jit.branchDouble(CCallHelpers::DoubleEqual, selectionBFPR, tempFPR);
+ auto bIsUnchanged = jit.branchDouble(CCallHelpers::DoubleEqualAndOrdered, selectionBFPR, tempFPR);
jit.loadDouble(CCallHelpers::TrustedImmPtr(&corruptedSelectionB), destFPR);
bIsUnchanged.link(&jit);
@@ -1255,7 +1255,7 @@
FPRReg tempFPR = FPRInfo::fpRegT5;
jit.loadDouble(CCallHelpers::TrustedImmPtr(&selectionA), tempFPR);
- auto aIsUnchanged = jit.branchDouble(CCallHelpers::DoubleEqual, selectionAFPR, tempFPR);
+ auto aIsUnchanged = jit.branchDouble(CCallHelpers::DoubleEqualAndOrdered, selectionAFPR, tempFPR);
jit.loadDouble(CCallHelpers::TrustedImmPtr(&corruptedSelectionA), destFPR);
aIsUnchanged.link(&jit);
@@ -1274,17 +1274,17 @@
return x != x;
};
switch (condition) {
- case MacroAssembler::DoubleEqual:
+ case MacroAssembler::DoubleEqualAndOrdered:
return !isUnordered(a) && (a == a) ? selectionA : selectionB;
- case MacroAssembler::DoubleNotEqual:
+ case MacroAssembler::DoubleNotEqualAndOrdered:
return !isUnordered(a) && (a != a) ? selectionA : selectionB;
- case MacroAssembler::DoubleGreaterThan:
+ case MacroAssembler::DoubleGreaterThanAndOrdered:
return !isUnordered(a) && (a > a) ? selectionA : selectionB;
- case MacroAssembler::DoubleGreaterThanOrEqual:
+ case MacroAssembler::DoubleGreaterThanOrEqualAndOrdered:
return !isUnordered(a) && (a >= a) ? selectionA : selectionB;
- case MacroAssembler::DoubleLessThan:
+ case MacroAssembler::DoubleLessThanAndOrdered:
return !isUnordered(a) && (a < a) ? selectionA : selectionB;
- case MacroAssembler::DoubleLessThanOrEqual:
+ case MacroAssembler::DoubleLessThanOrEqualAndOrdered:
return !isUnordered(a) && (a <= a) ? selectionA : selectionB;
case MacroAssembler::DoubleEqualOrUnordered:
return isUnordered(a) || (a == a) ? selectionA : selectionB;
@@ -2205,12 +2205,12 @@
#define FOR_EACH_DOUBLE_CONDITION_RUN(__test) \
do { \
- RUN(__test(MacroAssembler::DoubleEqual)); \
- RUN(__test(MacroAssembler::DoubleNotEqual)); \
- RUN(__test(MacroAssembler::DoubleGreaterThan)); \
- RUN(__test(MacroAssembler::DoubleGreaterThanOrEqual)); \
- RUN(__test(MacroAssembler::DoubleLessThan)); \
- RUN(__test(MacroAssembler::DoubleLessThanOrEqual)); \
+ RUN(__test(MacroAssembler::DoubleEqualAndOrdered)); \
+ RUN(__test(MacroAssembler::DoubleNotEqualAndOrdered)); \
+ RUN(__test(MacroAssembler::DoubleGreaterThanAndOrdered)); \
+ RUN(__test(MacroAssembler::DoubleGreaterThanOrEqualAndOrdered)); \
+ RUN(__test(MacroAssembler::DoubleLessThanAndOrdered)); \
+ RUN(__test(MacroAssembler::DoubleLessThanOrEqualAndOrdered)); \
RUN(__test(MacroAssembler::DoubleEqualOrUnordered)); \
RUN(__test(MacroAssembler::DoubleNotEqualOrUnordered)); \
RUN(__test(MacroAssembler::DoubleGreaterThanOrUnordered)); \
Modified: trunk/Source/_javascript_Core/b3/B3LowerToAir.cpp (258062 => 258063)
--- trunk/Source/_javascript_Core/b3/B3LowerToAir.cpp 2020-03-07 05:53:34 UTC (rev 258062)
+++ trunk/Source/_javascript_Core/b3/B3LowerToAir.cpp 2020-03-07 06:28:57 UTC (rev 258063)
@@ -1592,15 +1592,15 @@
case NotEqual:
return createRelCond(MacroAssembler::NotEqual, MacroAssembler::DoubleNotEqualOrUnordered);
case Equal:
- return createRelCond(MacroAssembler::Equal, MacroAssembler::DoubleEqual);
+ return createRelCond(MacroAssembler::Equal, MacroAssembler::DoubleEqualAndOrdered);
case LessThan:
- return createRelCond(MacroAssembler::LessThan, MacroAssembler::DoubleLessThan);
+ return createRelCond(MacroAssembler::LessThan, MacroAssembler::DoubleLessThanAndOrdered);
case GreaterThan:
- return createRelCond(MacroAssembler::GreaterThan, MacroAssembler::DoubleGreaterThan);
+ return createRelCond(MacroAssembler::GreaterThan, MacroAssembler::DoubleGreaterThanAndOrdered);
case LessEqual:
- return createRelCond(MacroAssembler::LessThanOrEqual, MacroAssembler::DoubleLessThanOrEqual);
+ return createRelCond(MacroAssembler::LessThanOrEqual, MacroAssembler::DoubleLessThanOrEqualAndOrdered);
case GreaterEqual:
- return createRelCond(MacroAssembler::GreaterThanOrEqual, MacroAssembler::DoubleGreaterThanOrEqual);
+ return createRelCond(MacroAssembler::GreaterThanOrEqual, MacroAssembler::DoubleGreaterThanOrEqualAndOrdered);
case EqualOrUnordered:
// The integer condition is never used in this case.
return createRelCond(MacroAssembler::Equal, MacroAssembler::DoubleEqualOrUnordered);
@@ -1607,13 +1607,13 @@
case Above:
// We use a bogus double condition because these integer comparisons won't got down that
// path anyway.
- return createRelCond(MacroAssembler::Above, MacroAssembler::DoubleEqual);
+ return createRelCond(MacroAssembler::Above, MacroAssembler::DoubleEqualAndOrdered);
case Below:
- return createRelCond(MacroAssembler::Below, MacroAssembler::DoubleEqual);
+ return createRelCond(MacroAssembler::Below, MacroAssembler::DoubleEqualAndOrdered);
case AboveEqual:
- return createRelCond(MacroAssembler::AboveOrEqual, MacroAssembler::DoubleEqual);
+ return createRelCond(MacroAssembler::AboveOrEqual, MacroAssembler::DoubleEqualAndOrdered);
case BelowEqual:
- return createRelCond(MacroAssembler::BelowOrEqual, MacroAssembler::DoubleEqual);
+ return createRelCond(MacroAssembler::BelowOrEqual, MacroAssembler::DoubleEqualAndOrdered);
case BitAnd: {
Value* left = value->child(0);
Value* right = value->child(1);
Modified: trunk/Source/_javascript_Core/dfg/DFGSpeculativeJIT.cpp (258062 => 258063)
--- trunk/Source/_javascript_Core/dfg/DFGSpeculativeJIT.cpp 2020-03-07 05:53:34 UTC (rev 258062)
+++ trunk/Source/_javascript_Core/dfg/DFGSpeculativeJIT.cpp 2020-03-07 06:28:57 UTC (rev 258063)
@@ -2806,7 +2806,7 @@
jit.loadDouble(JITCompiler::TrustedImmPtr(&zero), scratch);
MacroAssembler::Jump tooSmall = jit.branchDouble(MacroAssembler::DoubleLessThanOrEqualOrUnordered, source, scratch);
jit.loadDouble(JITCompiler::TrustedImmPtr(&byteMax), scratch);
- MacroAssembler::Jump tooBig = jit.branchDouble(MacroAssembler::DoubleGreaterThan, source, scratch);
+ MacroAssembler::Jump tooBig = jit.branchDouble(MacroAssembler::DoubleGreaterThanAndOrdered, source, scratch);
jit.loadDouble(JITCompiler::TrustedImmPtr(&half), scratch);
// FIXME: This should probably just use a floating point round!
@@ -5646,7 +5646,7 @@
m_jit.loadDouble(TrustedImmPtr(&halfConstant), scratchFPR);
m_jit.addDouble(resultFPR, scratchFPR);
- JITCompiler::Jump shouldUseCeiled = m_jit.branchDouble(JITCompiler::DoubleLessThanOrEqual, scratchFPR, valueFPR);
+ JITCompiler::Jump shouldUseCeiled = m_jit.branchDouble(JITCompiler::DoubleLessThanOrEqualAndOrdered, scratchFPR, valueFPR);
static constexpr double _oneConstant_ = -1.0;
m_jit.loadDouble(TrustedImmPtr(&oneConstant), scratchFPR);
m_jit.addDouble(scratchFPR, resultFPR);
@@ -5797,10 +5797,10 @@
MacroAssembler::JumpList done;
- MacroAssembler::Jump op1Less = m_jit.branchDouble(node->op() == ArithMin ? MacroAssembler::DoubleLessThan : MacroAssembler::DoubleGreaterThan, op1FPR, op2FPR);
+ MacroAssembler::Jump op1Less = m_jit.branchDouble(node->op() == ArithMin ? MacroAssembler::DoubleLessThanAndOrdered : MacroAssembler::DoubleGreaterThanAndOrdered, op1FPR, op2FPR);
// op2 is eather the lesser one or one of then is NaN
- MacroAssembler::Jump op2Less = m_jit.branchDouble(node->op() == ArithMin ? MacroAssembler::DoubleGreaterThanOrEqual : MacroAssembler::DoubleLessThanOrEqual, op1FPR, op2FPR);
+ MacroAssembler::Jump op2Less = m_jit.branchDouble(node->op() == ArithMin ? MacroAssembler::DoubleGreaterThanOrEqualAndOrdered : MacroAssembler::DoubleLessThanOrEqualAndOrdered, op1FPR, op2FPR);
// Unordered case. We don't know which of op1, op2 is NaN. Manufacture NaN by adding
// op1 + op2 and putting it into result.
@@ -5937,10 +5937,10 @@
FPRReg resultFpr = result.fpr();
m_jit.moveZeroToDouble(resultFpr);
- MacroAssembler::Jump xIsZeroOrNegativeZero = m_jit.branchDouble(MacroAssembler::DoubleEqual, xOperandFpr, resultFpr);
+ MacroAssembler::Jump xIsZeroOrNegativeZero = m_jit.branchDouble(MacroAssembler::DoubleEqualAndOrdered, xOperandFpr, resultFpr);
m_jit.loadDouble(TrustedImmPtr(&minusInfinityConstant), resultFpr);
- MacroAssembler::Jump xIsMinusInfinity = m_jit.branchDouble(MacroAssembler::DoubleEqual, xOperandFpr, resultFpr);
+ MacroAssembler::Jump xIsMinusInfinity = m_jit.branchDouble(MacroAssembler::DoubleEqualAndOrdered, xOperandFpr, resultFpr);
m_jit.sqrtDouble(xOperandFpr, resultFpr);
MacroAssembler::Jump doneWithSqrt = m_jit.jump();
@@ -5964,10 +5964,10 @@
FPRReg resultFpr = result.fpr();
m_jit.moveZeroToDouble(resultFpr);
- MacroAssembler::Jump xIsZeroOrNegativeZero = m_jit.branchDouble(MacroAssembler::DoubleEqual, xOperandFpr, resultFpr);
+ MacroAssembler::Jump xIsZeroOrNegativeZero = m_jit.branchDouble(MacroAssembler::DoubleEqualAndOrdered, xOperandFpr, resultFpr);
m_jit.loadDouble(TrustedImmPtr(&minusInfinityConstant), resultFpr);
- MacroAssembler::Jump xIsMinusInfinity = m_jit.branchDouble(MacroAssembler::DoubleEqual, xOperandFpr, resultFpr);
+ MacroAssembler::Jump xIsMinusInfinity = m_jit.branchDouble(MacroAssembler::DoubleEqualAndOrdered, xOperandFpr, resultFpr);
static constexpr double _oneConstant_ = 1.;
m_jit.loadDouble(TrustedImmPtr(&oneConstant), resultFpr);
@@ -6157,7 +6157,7 @@
unsigned branchIndexInBlock = detectPeepHoleBranch();
if (branchIndexInBlock != UINT_MAX) {
Node* branchNode = m_block->at(branchIndexInBlock);
- compilePeepHoleDoubleBranch(node, branchNode, MacroAssembler::DoubleEqual);
+ compilePeepHoleDoubleBranch(node, branchNode, MacroAssembler::DoubleEqualAndOrdered);
use(node->child1());
use(node->child2());
m_indexInBlock = branchIndexInBlock;
@@ -6164,7 +6164,7 @@
m_currentNode = branchNode;
return true;
}
- compileDoubleCompare(node, MacroAssembler::DoubleEqual);
+ compileDoubleCompare(node, MacroAssembler::DoubleEqualAndOrdered);
return false;
}
@@ -8710,7 +8710,7 @@
auto loop = m_jit.label();
auto notFound = m_jit.branch32(CCallHelpers::Equal, indexGPR, lengthGPR);
m_jit.loadDouble(MacroAssembler::BaseIndex(storageGPR, indexGPR, MacroAssembler::TimesEight), tempFPR);
- auto found = m_jit.branchDouble(CCallHelpers::DoubleEqual, tempFPR, searchElementFPR);
+ auto found = m_jit.branchDouble(CCallHelpers::DoubleEqualAndOrdered, tempFPR, searchElementFPR);
m_jit.add32(TrustedImm32(1), indexGPR);
m_jit.jump().linkTo(loop, &m_jit);
@@ -12023,7 +12023,7 @@
notNaN.link(&m_jit);
m_jit.truncateDoubleToInt32(doubleValueFPR, scratchGPR);
m_jit.convertInt32ToDouble(scratchGPR, tempFPR);
- passThroughCases.append(m_jit.branchDouble(JITCompiler::DoubleNotEqual, doubleValueFPR, tempFPR));
+ passThroughCases.append(m_jit.branchDouble(JITCompiler::DoubleNotEqualAndOrdered, doubleValueFPR, tempFPR));
m_jit.boxInt32(scratchGPR, resultRegs);
doneCases.append(m_jit.jump());
Modified: trunk/Source/_javascript_Core/dfg/DFGSpeculativeJIT32_64.cpp (258062 => 258063)
--- trunk/Source/_javascript_Core/dfg/DFGSpeculativeJIT32_64.cpp 2020-03-07 05:53:34 UTC (rev 258062)
+++ trunk/Source/_javascript_Core/dfg/DFGSpeculativeJIT32_64.cpp 2020-03-07 06:28:57 UTC (rev 258063)
@@ -2157,22 +2157,22 @@
break;
case CompareLess:
- if (compare(node, JITCompiler::LessThan, JITCompiler::DoubleLessThan, operationCompareLess))
+ if (compare(node, JITCompiler::LessThan, JITCompiler::DoubleLessThanAndOrdered, operationCompareLess))
return;
break;
case CompareLessEq:
- if (compare(node, JITCompiler::LessThanOrEqual, JITCompiler::DoubleLessThanOrEqual, operationCompareLessEq))
+ if (compare(node, JITCompiler::LessThanOrEqual, JITCompiler::DoubleLessThanOrEqualAndOrdered, operationCompareLessEq))
return;
break;
case CompareGreater:
- if (compare(node, JITCompiler::GreaterThan, JITCompiler::DoubleGreaterThan, operationCompareGreater))
+ if (compare(node, JITCompiler::GreaterThan, JITCompiler::DoubleGreaterThanAndOrdered, operationCompareGreater))
return;
break;
case CompareGreaterEq:
- if (compare(node, JITCompiler::GreaterThanOrEqual, JITCompiler::DoubleGreaterThanOrEqual, operationCompareGreaterEq))
+ if (compare(node, JITCompiler::GreaterThanOrEqual, JITCompiler::DoubleGreaterThanOrEqualAndOrdered, operationCompareGreaterEq))
return;
break;
@@ -2185,7 +2185,7 @@
break;
case CompareEq:
- if (compare(node, JITCompiler::Equal, JITCompiler::DoubleEqual, operationCompareEq))
+ if (compare(node, JITCompiler::Equal, JITCompiler::DoubleEqualAndOrdered, operationCompareEq))
return;
break;
Modified: trunk/Source/_javascript_Core/dfg/DFGSpeculativeJIT64.cpp (258062 => 258063)
--- trunk/Source/_javascript_Core/dfg/DFGSpeculativeJIT64.cpp 2020-03-07 05:53:34 UTC (rev 258062)
+++ trunk/Source/_javascript_Core/dfg/DFGSpeculativeJIT64.cpp 2020-03-07 06:28:57 UTC (rev 258063)
@@ -2305,22 +2305,22 @@
break;
case CompareLess:
- if (compare(node, JITCompiler::LessThan, JITCompiler::DoubleLessThan, operationCompareLess))
+ if (compare(node, JITCompiler::LessThan, JITCompiler::DoubleLessThanAndOrdered, operationCompareLess))
return;
break;
case CompareLessEq:
- if (compare(node, JITCompiler::LessThanOrEqual, JITCompiler::DoubleLessThanOrEqual, operationCompareLessEq))
+ if (compare(node, JITCompiler::LessThanOrEqual, JITCompiler::DoubleLessThanOrEqualAndOrdered, operationCompareLessEq))
return;
break;
case CompareGreater:
- if (compare(node, JITCompiler::GreaterThan, JITCompiler::DoubleGreaterThan, operationCompareGreater))
+ if (compare(node, JITCompiler::GreaterThan, JITCompiler::DoubleGreaterThanAndOrdered, operationCompareGreater))
return;
break;
case CompareGreaterEq:
- if (compare(node, JITCompiler::GreaterThanOrEqual, JITCompiler::DoubleGreaterThanOrEqual, operationCompareGreaterEq))
+ if (compare(node, JITCompiler::GreaterThanOrEqual, JITCompiler::DoubleGreaterThanOrEqualAndOrdered, operationCompareGreaterEq))
return;
break;
@@ -2333,7 +2333,7 @@
break;
case CompareEq:
- if (compare(node, JITCompiler::Equal, JITCompiler::DoubleEqual, operationCompareEq))
+ if (compare(node, JITCompiler::Equal, JITCompiler::DoubleEqualAndOrdered, operationCompareEq))
return;
break;
@@ -4114,7 +4114,7 @@
notNanNorInfinity.link(&m_jit);
m_jit.roundTowardZeroDouble(tempFPR1, tempFPR2);
- m_jit.compareDouble(JITCompiler::DoubleEqual, tempFPR1, tempFPR2, resultGPR);
+ m_jit.compareDouble(JITCompiler::DoubleEqualAndOrdered, tempFPR1, tempFPR2, resultGPR);
m_jit.or32(TrustedImm32(JSValue::ValueFalse), resultGPR);
done.append(m_jit.jump());
Modified: trunk/Source/_javascript_Core/ftl/FTLLowerDFGToB3.cpp (258062 => 258063)
--- trunk/Source/_javascript_Core/ftl/FTLLowerDFGToB3.cpp 2020-03-07 05:53:34 UTC (rev 258062)
+++ trunk/Source/_javascript_Core/ftl/FTLLowerDFGToB3.cpp 2020-03-07 06:28:57 UTC (rev 258063)
@@ -10496,7 +10496,7 @@
FPRReg input = params[1].fpr();
FPRReg temp = params.fpScratch(0);
jit.roundTowardZeroDouble(input, temp);
- jit.compareDouble(MacroAssembler::DoubleEqual, input, temp, result);
+ jit.compareDouble(MacroAssembler::DoubleEqualAndOrdered, input, temp, result);
});
ValueFromBlock patchpointResult = m_out.anchor(patchpoint);
m_out.jump(continuation);
Modified: trunk/Source/_javascript_Core/jit/AssemblyHelpers.h (258062 => 258063)
--- trunk/Source/_javascript_Core/jit/AssemblyHelpers.h 2020-03-07 05:53:34 UTC (rev 258062)
+++ trunk/Source/_javascript_Core/jit/AssemblyHelpers.h 2020-03-07 06:28:57 UTC (rev 258063)
@@ -1093,7 +1093,7 @@
Jump branchIfNotNaN(FPRReg fpr)
{
- return branchDouble(DoubleEqual, fpr, fpr);
+ return branchDouble(DoubleEqualAndOrdered, fpr, fpr);
}
Jump branchIfRopeStringImpl(GPRReg stringImplGPR)
Modified: trunk/Source/_javascript_Core/jit/JITArithmetic.cpp (258062 => 258063)
--- trunk/Source/_javascript_Core/jit/JITArithmetic.cpp 2020-03-07 05:53:34 UTC (rev 258062)
+++ trunk/Source/_javascript_Core/jit/JITArithmetic.cpp 2020-03-07 06:28:57 UTC (rev 258063)
@@ -95,22 +95,22 @@
void JIT::emitSlow_op_jless(const Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
{
- emit_compareAndJumpSlow<OpJless>(currentInstruction, DoubleLessThan, operationCompareLess, false, iter);
+ emit_compareAndJumpSlow<OpJless>(currentInstruction, DoubleLessThanAndOrdered, operationCompareLess, false, iter);
}
void JIT::emitSlow_op_jlesseq(const Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
{
- emit_compareAndJumpSlow<OpJlesseq>(currentInstruction, DoubleLessThanOrEqual, operationCompareLessEq, false, iter);
+ emit_compareAndJumpSlow<OpJlesseq>(currentInstruction, DoubleLessThanOrEqualAndOrdered, operationCompareLessEq, false, iter);
}
void JIT::emitSlow_op_jgreater(const Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
{
- emit_compareAndJumpSlow<OpJgreater>(currentInstruction, DoubleGreaterThan, operationCompareGreater, false, iter);
+ emit_compareAndJumpSlow<OpJgreater>(currentInstruction, DoubleGreaterThanAndOrdered, operationCompareGreater, false, iter);
}
void JIT::emitSlow_op_jgreatereq(const Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
{
- emit_compareAndJumpSlow<OpJgreatereq>(currentInstruction, DoubleGreaterThanOrEqual, operationCompareGreaterEq, false, iter);
+ emit_compareAndJumpSlow<OpJgreatereq>(currentInstruction, DoubleGreaterThanOrEqualAndOrdered, operationCompareGreaterEq, false, iter);
}
void JIT::emitSlow_op_jnless(const Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
Modified: trunk/Source/_javascript_Core/jit/JITArithmetic32_64.cpp (258062 => 258063)
--- trunk/Source/_javascript_Core/jit/JITArithmetic32_64.cpp 2020-03-07 05:53:34 UTC (rev 258062)
+++ trunk/Source/_javascript_Core/jit/JITArithmetic32_64.cpp 2020-03-07 06:28:57 UTC (rev 258063)
@@ -233,19 +233,19 @@
switch (opcodeID) {
case op_jless:
emitLoadDouble(op1, fpRegT2);
- addJump(branchDouble(DoubleLessThan, fpRegT2, fpRegT0), target);
+ addJump(branchDouble(DoubleLessThanAndOrdered, fpRegT2, fpRegT0), target);
break;
case op_jlesseq:
emitLoadDouble(op1, fpRegT2);
- addJump(branchDouble(DoubleLessThanOrEqual, fpRegT2, fpRegT0), target);
+ addJump(branchDouble(DoubleLessThanOrEqualAndOrdered, fpRegT2, fpRegT0), target);
break;
case op_jgreater:
emitLoadDouble(op1, fpRegT2);
- addJump(branchDouble(DoubleGreaterThan, fpRegT2, fpRegT0), target);
+ addJump(branchDouble(DoubleGreaterThanAndOrdered, fpRegT2, fpRegT0), target);
break;
case op_jgreatereq:
emitLoadDouble(op1, fpRegT2);
- addJump(branchDouble(DoubleGreaterThanOrEqual, fpRegT2, fpRegT0), target);
+ addJump(branchDouble(DoubleGreaterThanOrEqualAndOrdered, fpRegT2, fpRegT0), target);
break;
case op_jnless:
emitLoadDouble(op1, fpRegT2);
@@ -290,19 +290,19 @@
switch (opcodeID) {
case op_jless:
emitLoadDouble(op2, fpRegT1);
- addJump(branchDouble(DoubleLessThan, fpRegT0, fpRegT1), target);
+ addJump(branchDouble(DoubleLessThanAndOrdered, fpRegT0, fpRegT1), target);
break;
case op_jlesseq:
emitLoadDouble(op2, fpRegT1);
- addJump(branchDouble(DoubleLessThanOrEqual, fpRegT0, fpRegT1), target);
+ addJump(branchDouble(DoubleLessThanOrEqualAndOrdered, fpRegT0, fpRegT1), target);
break;
case op_jgreater:
emitLoadDouble(op2, fpRegT1);
- addJump(branchDouble(DoubleGreaterThan, fpRegT0, fpRegT1), target);
+ addJump(branchDouble(DoubleGreaterThanAndOrdered, fpRegT0, fpRegT1), target);
break;
case op_jgreatereq:
emitLoadDouble(op2, fpRegT1);
- addJump(branchDouble(DoubleGreaterThanOrEqual, fpRegT0, fpRegT1), target);
+ addJump(branchDouble(DoubleGreaterThanOrEqualAndOrdered, fpRegT0, fpRegT1), target);
break;
case op_jnless:
emitLoadDouble(op2, fpRegT1);
Modified: trunk/Source/_javascript_Core/jit/ThunkGenerators.cpp (258062 => 258063)
--- trunk/Source/_javascript_Core/jit/ThunkGenerators.cpp 2020-03-07 05:53:34 UTC (rev 258062)
+++ trunk/Source/_javascript_Core/jit/ThunkGenerators.cpp 2020-03-07 06:28:57 UTC (rev 258063)
@@ -900,7 +900,7 @@
SpecializedThunkJIT::JumpList doubleResult;
if (jit.supportsFloatingPointTruncate()) {
jit.moveZeroToDouble(SpecializedThunkJIT::fpRegT1);
- doubleResult.append(jit.branchDouble(MacroAssembler::DoubleEqual, SpecializedThunkJIT::fpRegT0, SpecializedThunkJIT::fpRegT1));
+ doubleResult.append(jit.branchDouble(MacroAssembler::DoubleEqualAndOrdered, SpecializedThunkJIT::fpRegT0, SpecializedThunkJIT::fpRegT1));
SpecializedThunkJIT::JumpList slowPath;
// Handle the negative doubles in the slow path for now.
slowPath.append(jit.branchDouble(MacroAssembler::DoubleLessThanOrUnordered, SpecializedThunkJIT::fpRegT0, SpecializedThunkJIT::fpRegT1));
@@ -977,13 +977,13 @@
SpecializedThunkJIT::JumpList doubleResult;
if (jit.supportsFloatingPointRounding()) {
jit.moveZeroToDouble(SpecializedThunkJIT::fpRegT1);
- doubleResult.append(jit.branchDouble(MacroAssembler::DoubleEqual, SpecializedThunkJIT::fpRegT0, SpecializedThunkJIT::fpRegT1));
+ doubleResult.append(jit.branchDouble(MacroAssembler::DoubleEqualAndOrdered, SpecializedThunkJIT::fpRegT0, SpecializedThunkJIT::fpRegT1));
jit.ceilDouble(SpecializedThunkJIT::fpRegT0, SpecializedThunkJIT::fpRegT1);
static constexpr double halfConstant = -0.5;
jit.loadDouble(MacroAssembler::TrustedImmPtr(&halfConstant), SpecializedThunkJIT::fpRegT2);
jit.addDouble(SpecializedThunkJIT::fpRegT1, SpecializedThunkJIT::fpRegT2);
- MacroAssembler::Jump shouldRoundDown = jit.branchDouble(MacroAssembler::DoubleGreaterThan, SpecializedThunkJIT::fpRegT2, SpecializedThunkJIT::fpRegT0);
+ MacroAssembler::Jump shouldRoundDown = jit.branchDouble(MacroAssembler::DoubleGreaterThanAndOrdered, SpecializedThunkJIT::fpRegT2, SpecializedThunkJIT::fpRegT0);
jit.moveDouble(SpecializedThunkJIT::fpRegT1, SpecializedThunkJIT::fpRegT0);
MacroAssembler::Jump continuation = jit.jump();
Modified: trunk/Source/_javascript_Core/wasm/WasmAirIRGenerator.cpp (258062 => 258063)
--- trunk/Source/_javascript_Core/wasm/WasmAirIRGenerator.cpp 2020-03-07 05:53:34 UTC (rev 258062)
+++ trunk/Source/_javascript_Core/wasm/WasmAirIRGenerator.cpp 2020-03-07 06:28:57 UTC (rev 258063)
@@ -3189,7 +3189,7 @@
template<> auto AirIRGenerator::addOp<OpType::F64Le>(ExpressionType arg0, ExpressionType arg1, ExpressionType& result) -> PartialResult
{
result = g32();
- append(CompareDouble, Arg::doubleCond(MacroAssembler::DoubleLessThanOrEqual), arg0, arg1, result);
+ append(CompareDouble, Arg::doubleCond(MacroAssembler::DoubleLessThanOrEqualAndOrdered), arg0, arg1, result);
return { };
}
@@ -3215,7 +3215,7 @@
template<> auto AirIRGenerator::addOp<OpType::F64Lt>(ExpressionType arg0, ExpressionType arg1, ExpressionType& result) -> PartialResult
{
result = g32();
- append(CompareDouble, Arg::doubleCond(MacroAssembler::DoubleLessThan), arg0, arg1, result);
+ append(CompareDouble, Arg::doubleCond(MacroAssembler::DoubleLessThanAndOrdered), arg0, arg1, result);
return { };
}
@@ -3233,13 +3233,13 @@
BasicBlock* continuation = m_code.addBlock();
auto branchOp = floatType == F32 ? BranchFloat : BranchDouble;
- append(m_currentBlock, branchOp, Arg::doubleCond(MacroAssembler::DoubleEqual), arg0, arg1);
+ append(m_currentBlock, branchOp, Arg::doubleCond(MacroAssembler::DoubleEqualAndOrdered), arg0, arg1);
m_currentBlock->setSuccessors(isEqual, notEqual);
- append(notEqual, branchOp, Arg::doubleCond(MacroAssembler::DoubleLessThan), arg0, arg1);
+ append(notEqual, branchOp, Arg::doubleCond(MacroAssembler::DoubleLessThanAndOrdered), arg0, arg1);
notEqual->setSuccessors(isLessThan, notLessThan);
- append(notLessThan, branchOp, Arg::doubleCond(MacroAssembler::DoubleGreaterThan), arg0, arg1);
+ append(notLessThan, branchOp, Arg::doubleCond(MacroAssembler::DoubleGreaterThanAndOrdered), arg0, arg1);
notLessThan->setSuccessors(isGreaterThan, isNaN);
auto andOp = floatType == F32 ? AndFloat : AndDouble;
@@ -3348,7 +3348,7 @@
template<> auto AirIRGenerator::addOp<OpType::F64Gt>(ExpressionType arg0, ExpressionType arg1, ExpressionType& result) -> PartialResult
{
result = g32();
- append(CompareDouble, Arg::doubleCond(MacroAssembler::DoubleGreaterThan), arg0, arg1, result);
+ append(CompareDouble, Arg::doubleCond(MacroAssembler::DoubleGreaterThanAndOrdered), arg0, arg1, result);
return { };
}
@@ -3362,7 +3362,7 @@
template<> auto AirIRGenerator::addOp<OpType::F64Ge>(ExpressionType arg0, ExpressionType arg1, ExpressionType& result) -> PartialResult
{
result = g32();
- append(CompareDouble, Arg::doubleCond(MacroAssembler::DoubleGreaterThanOrEqual), arg0, arg1, result);
+ append(CompareDouble, Arg::doubleCond(MacroAssembler::DoubleGreaterThanOrEqualAndOrdered), arg0, arg1, result);
return { };
}
@@ -3532,7 +3532,7 @@
template<> auto AirIRGenerator::addOp<OpType::F32Lt>(ExpressionType arg0, ExpressionType arg1, ExpressionType& result) -> PartialResult
{
result = g32();
- append(CompareFloat, Arg::doubleCond(MacroAssembler::DoubleLessThan), arg0, arg1, result);
+ append(CompareFloat, Arg::doubleCond(MacroAssembler::DoubleLessThanAndOrdered), arg0, arg1, result);
return { };
}
@@ -3546,7 +3546,7 @@
template<> auto AirIRGenerator::addOp<OpType::F64Eq>(ExpressionType arg0, ExpressionType arg1, ExpressionType& result) -> PartialResult
{
result = g32();
- append(CompareDouble, Arg::doubleCond(MacroAssembler::DoubleEqual), arg0, arg1, result);
+ append(CompareDouble, Arg::doubleCond(MacroAssembler::DoubleEqualAndOrdered), arg0, arg1, result);
return { };
}
@@ -3553,7 +3553,7 @@
template<> auto AirIRGenerator::addOp<OpType::F32Le>(ExpressionType arg0, ExpressionType arg1, ExpressionType& result) -> PartialResult
{
result = g32();
- append(CompareFloat, Arg::doubleCond(MacroAssembler::DoubleLessThanOrEqual), arg0, arg1, result);
+ append(CompareFloat, Arg::doubleCond(MacroAssembler::DoubleLessThanOrEqualAndOrdered), arg0, arg1, result);
return { };
}
@@ -3560,7 +3560,7 @@
template<> auto AirIRGenerator::addOp<OpType::F32Ge>(ExpressionType arg0, ExpressionType arg1, ExpressionType& result) -> PartialResult
{
result = g32();
- append(CompareFloat, Arg::doubleCond(MacroAssembler::DoubleGreaterThanOrEqual), arg0, arg1, result);
+ append(CompareFloat, Arg::doubleCond(MacroAssembler::DoubleGreaterThanOrEqualAndOrdered), arg0, arg1, result);
return { };
}
@@ -3772,7 +3772,7 @@
template<> auto AirIRGenerator::addOp<OpType::F32Eq>(ExpressionType arg0, ExpressionType arg1, ExpressionType& result) -> PartialResult
{
result = g32();
- append(CompareFloat, Arg::doubleCond(MacroAssembler::DoubleEqual), arg0, arg1, result);
+ append(CompareFloat, Arg::doubleCond(MacroAssembler::DoubleEqualAndOrdered), arg0, arg1, result);
return { };
}
@@ -3836,7 +3836,7 @@
template<> auto AirIRGenerator::addOp<OpType::F32Gt>(ExpressionType arg0, ExpressionType arg1, ExpressionType& result) -> PartialResult
{
result = g32();
- append(CompareFloat, Arg::doubleCond(MacroAssembler::DoubleGreaterThan), arg0, arg1, result);
+ append(CompareFloat, Arg::doubleCond(MacroAssembler::DoubleGreaterThanAndOrdered), arg0, arg1, result);
return { };
}
