Changeset 219038 in webkit for trunk/Source/JavaScriptCore/b3/testb3.cpp

Timestamp:

Jun 30, 2017, 8:35:47 PM (8 years ago)

Author:

[email protected]

Message:

B3ReduceStrength should reduce EqualOrUnordered over const float input
​https://bugs.webkit.org/show_bug.cgi?id=174039

Reviewed by Michael Saboff.

We perform this folding for ConstDoubleValue. It is simply
an oversight that we didn't do it for ConstFloatValue.

• b3/B3ConstFloatValue.cpp:

(JSC::B3::ConstFloatValue::equalOrUnorderedConstant):

• b3/B3ConstFloatValue.h:
• b3/testb3.cpp:

(JSC::B3::testFloatEqualOrUnorderedFolding):
(JSC::B3::testFloatEqualOrUnorderedFoldingNaN):
(JSC::B3::testFloatEqualOrUnorderedDontFold):
(JSC::B3::run):

File:

• trunk/Source/JavaScriptCore/b3/testb3.cpp (modified) (2 diffs)

trunk/Source/JavaScriptCore/b3/testb3.cpp

@@ -15471 +15471 @@
 
         CHECK(!!compileAndRun<int32_t>(proc) == std::get<1>(test)(a, b));
+    }
+}
+
+void testFloatEqualOrUnorderedFolding()
+{
+    for (auto& first : floatingPointOperands<float>()) {
+        for (auto& second : floatingPointOperands<float>()) {
+            float a = first.value;
+            float b = second.value;
+            bool expectedResult = (a == b) || std::isunordered(a, b);
+            Procedure proc;
+            BasicBlock* root = proc.addBlock();
+            Value* constA = root->appendNew<ConstFloatValue>(proc, Origin(), a);
+            Value* constB = root->appendNew<ConstFloatValue>(proc, Origin(), b);
+
+            root->appendNewControlValue(proc, Return, Origin(),
+                root->appendNew<Value>(
+                    proc, EqualOrUnordered, Origin(),
+                    constA,
+                    constB));
+            CHECK(!!compileAndRun<int32_t>(proc) == expectedResult);
+        }
+    }
+}
+
+void testFloatEqualOrUnorderedFoldingNaN()
+{
+    std::list<float> nans = {
+        bitwise_cast<float>(0xfffffffd),
+        bitwise_cast<float>(0xfffffffe),
+        bitwise_cast<float>(0xfffffff0),
+        static_cast<float>(PNaN),
+    };
+
+    unsigned i = 0;
+    for (float nan : nans) {
+        RELEASE_ASSERT(std::isnan(nan));
+        Procedure proc;
+        BasicBlock* root = proc.addBlock();
+        Value* a = root->appendNew<ConstFloatValue>(proc, Origin(), nan);
+        Value* b = root->appendNew<Value>(proc, DoubleToFloat, Origin(),
+            root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0));
+
+        if (i % 2)
+            std::swap(a, b);
+        ++i;
+        root->appendNewControlValue(proc, Return, Origin(),
+            root->appendNew<Value>(proc, EqualOrUnordered, Origin(), a, b));
+        CHECK(!!compileAndRun<int32_t>(proc, static_cast<double>(1.0)));
+    }
+}
+
+void testFloatEqualOrUnorderedDontFold()
+{
+    for (auto& first : floatingPointOperands<float>()) {
+        float a = first.value;
+        Procedure proc;
+        BasicBlock* root = proc.addBlock();
+        Value* constA = root->appendNew<ConstFloatValue>(proc, Origin(), a);
+        Value* b = root->appendNew<Value>(proc, DoubleToFloat, Origin(),
+            root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0));
+        root->appendNewControlValue(proc, Return, Origin(),
+            root->appendNew<Value>(
+                proc, EqualOrUnordered, Origin(), constA, b));
+
+        auto code = compileProc(proc);
+
+        for (auto& second : floatingPointOperands<float>()) {
+            float b = second.value;
+            bool expectedResult = (a == b) || std::isunordered(a, b);
+            CHECK(!!invoke<int32_t>(*code, static_cast<double>(b)) == expectedResult);
+        }
     }
 }
@@ -17013 +17085 @@
     RUN(testDoubleLiteralComparison(125.3144446948242, 125.3144446948241));
 
+    RUN(testFloatEqualOrUnorderedFolding());
+    RUN(testFloatEqualOrUnorderedFoldingNaN());
+    RUN(testFloatEqualOrUnorderedDontFold());
+
     if (isX86()) {
         RUN(testBranchBitAndImmFusion(Identity, Int64, 1, Air::BranchTest32, Air::Arg::Tmp));