Refine the FTL part of ArithPow
authorbenjamin@webkit.org <benjamin@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Thu, 19 Feb 2015 21:08:21 +0000 (21:08 +0000)
committerbenjamin@webkit.org <benjamin@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Thu, 19 Feb 2015 21:08:21 +0000 (21:08 +0000)
https://bugs.webkit.org/show_bug.cgi?id=141792

Patch by Benjamin Poulain <bpoulain@apple.com> on 2015-02-19
Reviewed by Filip Pizlo.

This patch refines the FTL lowering of ArithPow. This was left out
of the original patch to keep it simpler.

* ftl/FTLLowerDFGToLLVM.cpp:
(JSC::FTL::LowerDFGToLLVM::compileArithPow):
Two improvements here:
1) Do not generate the NaN check unless we know the exponent might be a NaN.
2) Use one BasicBlock per check with the appropriate weight. Now that we have
   one branch per test, move the Infinity check before the check for 1 since
   it is the less common case.

* tests/stress/math-pow-becomes-custom-function.js: Added.
Test for changing the Math.pow() function after it has been optimized.

* tests/stress/math-pow-nan-behaviors.js:
The previous tests were only going as far as the DFGAbstractInterpreter
were the operations were replaced by the equivalent constant.

I duplicated the test functions to also test the dynamic behavior of DFG
and FTL.

* tests/stress/math-pow-with-constants.js:
Add cases covering exponent constants. LLVM removes many value
checks for those.

* tests/stress/math-pow-with-never-NaN-exponent.js: Added.
Test for the new optimization removing the NaN check.

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@180360 268f45cc-cd09-0410-ab3c-d52691b4dbfc

Source/JavaScriptCore/ChangeLog
Source/JavaScriptCore/ftl/FTLLowerDFGToLLVM.cpp
Source/JavaScriptCore/tests/stress/math-pow-becomes-custom-function.js [new file with mode: 0644]
Source/JavaScriptCore/tests/stress/math-pow-nan-behaviors.js
Source/JavaScriptCore/tests/stress/math-pow-with-constants.js
Source/JavaScriptCore/tests/stress/math-pow-with-never-NaN-exponent.js [new file with mode: 0644]

index 9406a84..57de6dc 100644 (file)
@@ -1,3 +1,38 @@
+2015-02-19  Benjamin Poulain  <bpoulain@apple.com>
+
+        Refine the FTL part of ArithPow
+        https://bugs.webkit.org/show_bug.cgi?id=141792
+
+        Reviewed by Filip Pizlo.
+
+        This patch refines the FTL lowering of ArithPow. This was left out
+        of the original patch to keep it simpler.
+
+        * ftl/FTLLowerDFGToLLVM.cpp:
+        (JSC::FTL::LowerDFGToLLVM::compileArithPow):
+        Two improvements here:
+        1) Do not generate the NaN check unless we know the exponent might be a NaN.
+        2) Use one BasicBlock per check with the appropriate weight. Now that we have
+           one branch per test, move the Infinity check before the check for 1 since
+           it is the less common case.
+
+        * tests/stress/math-pow-becomes-custom-function.js: Added.
+        Test for changing the Math.pow() function after it has been optimized.
+
+        * tests/stress/math-pow-nan-behaviors.js:
+        The previous tests were only going as far as the DFGAbstractInterpreter
+        were the operations were replaced by the equivalent constant.
+
+        I duplicated the test functions to also test the dynamic behavior of DFG
+        and FTL.
+
+        * tests/stress/math-pow-with-constants.js:
+        Add cases covering exponent constants. LLVM removes many value
+        checks for those.
+
+        * tests/stress/math-pow-with-never-NaN-exponent.js: Added.
+        Test for the new optimization removing the NaN check.
+
 2015-02-19  Csaba Osztrogonác  <ossy@webkit.org>
 
         REGRESSION(r180279): It broke 20 tests on ARM Linux
index 38be905..86c9f2c 100644 (file)
@@ -1659,44 +1659,52 @@ private:
 
             LBasicBlock integerExponentIsSmallBlock = FTL_NEW_BLOCK(m_out, ("ArithPow test integer exponent is small."));
             LBasicBlock integerExponentPowBlock = FTL_NEW_BLOCK(m_out, ("ArithPow pow(double, (int)double)."));
-            LBasicBlock doubleExponentPowBlock = FTL_NEW_BLOCK(m_out, ("ArithPow pow(double, double)."));
+            LBasicBlock doubleExponentPowBlockEntry = FTL_NEW_BLOCK(m_out, ("ArithPow pow(double, double)."));
+            LBasicBlock nanExceptionExponentIsInfinity = FTL_NEW_BLOCK(m_out, ("ArithPow NaN Exception, check exponent is infinity."));
+            LBasicBlock nanExceptionBaseIsOne = FTL_NEW_BLOCK(m_out, ("ArithPow NaN Exception, check base is one."));
             LBasicBlock powBlock = FTL_NEW_BLOCK(m_out, ("ArithPow regular pow"));
-            LBasicBlock nanException = FTL_NEW_BLOCK(m_out, ("ArithPow NaN Exception"));
+            LBasicBlock nanExceptionResultIsNaN = FTL_NEW_BLOCK(m_out, ("ArithPow NaN Exception, result is NaN."));
             LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("ArithPow continuation"));
 
             LValue integerExponent = m_out.fpToInt32(exponent);
             LValue integerExponentConvertedToDouble = m_out.intToDouble(integerExponent);
             LValue exponentIsInteger = m_out.doubleEqual(exponent, integerExponentConvertedToDouble);
-            m_out.branch(exponentIsInteger, unsure(integerExponentIsSmallBlock), unsure(doubleExponentPowBlock));
+            m_out.branch(exponentIsInteger, unsure(integerExponentIsSmallBlock), unsure(doubleExponentPowBlockEntry));
 
             LBasicBlock lastNext = m_out.appendTo(integerExponentIsSmallBlock, integerExponentPowBlock);
             LValue integerExponentBelow1000 = m_out.below(integerExponent, m_out.constInt32(1000));
-            m_out.branch(integerExponentBelow1000, usually(integerExponentPowBlock), rarely(doubleExponentPowBlock));
+            m_out.branch(integerExponentBelow1000, usually(integerExponentPowBlock), rarely(doubleExponentPowBlockEntry));
 
-            m_out.appendTo(integerExponentPowBlock, doubleExponentPowBlock);
+            m_out.appendTo(integerExponentPowBlock, doubleExponentPowBlockEntry);
             ValueFromBlock powDoubleIntResult = m_out.anchor(m_out.doublePowi(base, integerExponent));
             m_out.jump(continuation);
 
-            m_out.appendTo(doubleExponentPowBlock, powBlock);
             // If y is NaN, the result is NaN.
-            // FIXME: shouldn't we only check that if the type of child2() might have NaN?
-            LValue exponentIsNaN = m_out.doubleNotEqualOrUnordered(exponent, exponent);
+            m_out.appendTo(doubleExponentPowBlockEntry, nanExceptionExponentIsInfinity);
+            LValue exponentIsNaN;
+            if (m_state.forNode(m_node->child2()).m_type & SpecDoubleNaN)
+                exponentIsNaN = m_out.doubleNotEqualOrUnordered(exponent, exponent);
+            else
+                exponentIsNaN = m_out.booleanFalse;
+            m_out.branch(exponentIsNaN, rarely(nanExceptionResultIsNaN), usually(nanExceptionExponentIsInfinity));
 
             // If abs(x) is 1 and y is +infinity, the result is NaN.
             // If abs(x) is 1 and y is -infinity, the result is NaN.
+            m_out.appendTo(nanExceptionExponentIsInfinity, nanExceptionBaseIsOne);
             LValue absoluteExponent = m_out.doubleAbs(exponent);
             LValue absoluteExponentIsInfinity = m_out.doubleEqual(absoluteExponent, m_out.constDouble(std::numeric_limits<double>::infinity()));
+            m_out.branch(absoluteExponentIsInfinity, rarely(nanExceptionBaseIsOne), usually(powBlock));
+
+            m_out.appendTo(nanExceptionBaseIsOne, powBlock);
             LValue absoluteBase = m_out.doubleAbs(base);
             LValue absoluteBaseIsOne = m_out.doubleEqual(absoluteBase, m_out.constDouble(1));
-            LValue oneBaseInfiniteExponent = m_out.bitAnd(absoluteExponentIsInfinity, absoluteBaseIsOne);
-
-            m_out.branch(m_out.bitOr(exponentIsNaN, oneBaseInfiniteExponent), rarely(nanException), usually(powBlock));
+            m_out.branch(absoluteBaseIsOne, unsure(nanExceptionResultIsNaN), unsure(powBlock));
 
-            m_out.appendTo(powBlock, nanException);
+            m_out.appendTo(powBlock, nanExceptionResultIsNaN);
             ValueFromBlock powResult = m_out.anchor(m_out.doublePow(base, exponent));
             m_out.jump(continuation);
 
-            m_out.appendTo(nanException, continuation);
+            m_out.appendTo(nanExceptionResultIsNaN, continuation);
             ValueFromBlock pureNan = m_out.anchor(m_out.constDouble(PNaN));
             m_out.jump(continuation);
 
diff --git a/Source/JavaScriptCore/tests/stress/math-pow-becomes-custom-function.js b/Source/JavaScriptCore/tests/stress/math-pow-becomes-custom-function.js
new file mode 100644 (file)
index 0000000..8893acc
--- /dev/null
@@ -0,0 +1,18 @@
+function mathPowWrapper(x, y) {
+    return Math.pow(x, y);
+}
+noInline(mathPowWrapper);
+
+function testChangingMathPow() {
+    var result = 0;
+    for (var i = 0; i < 10000; ++i) {
+        result += mathPowWrapper(3, 2);
+    }
+    Math.pow = function(a, b) { return a + b; }
+    for (var i = 0; i < 10000; ++i) {
+        result += mathPowWrapper(3, 2);
+    }
+    if (result !== 140000)
+        throw "Result = " + result + ", expected 140000";
+}
+testChangingMathPow();
\ No newline at end of file
index da7dd44..0bdd698 100644 (file)
@@ -1,5 +1,5 @@
 // If y is NaN, the result is NaN.
-function testIntegerBaseWithNaNExponent() {
+function testIntegerBaseWithNaNExponentStatic() {
     for (var i = 0; i < 10000; ++i) {
         var result = Math.pow(5, NaN);
         if (!isNaN(result))
@@ -11,28 +11,70 @@ function testIntegerBaseWithNaNExponent() {
             throw "Error: bad result, Math.pow(i, NaN) = " + result + " with i = " + i;
     }
 }
-noInline(testIntegerBaseWithNaNExponent);
-testIntegerBaseWithNaNExponent();
+noInline(testIntegerBaseWithNaNExponentStatic);
+testIntegerBaseWithNaNExponentStatic();
 
-function testFloatingPointBaseWithNaNExponent() {
+function mathPowIntegerBaseWithNaNExponentDynamic(x, y) {
+    return Math.pow(x, y);
+}
+noInline(mathPowIntegerBaseWithNaNExponentDynamic);
+function testIntegerBaseWithNaNExponentDynamic() {
+    // Warm up with 2 integers.
+    for (var i = 0; i < 10000; ++i) {
+        var result = mathPowIntegerBaseWithNaNExponentDynamic(2, 5);
+        if (result !== 32)
+            throw "Error: bad result, mathPowIntegerBaseWithNaNExponentDynamic(2, 5) = " + result + ", expected 32."
+    }
+
+    for (var i = 0; i < 10000; ++i) {
+        var result = mathPowIntegerBaseWithNaNExponentDynamic(i, NaN);
+        if (!isNaN(result))
+            throw "Error: bad result, mathPowIntegerBaseWithNaNExponentDynamic(i, NaN) = " + result + " with i = " + i + ", expected NaN";
+    }
+}
+noInline(testIntegerBaseWithNaNExponentDynamic);
+testIntegerBaseWithNaNExponentDynamic();
+
+function testFloatingPointBaseWithNaNExponentStatic() {
     for (var i = 0; i < 10000; ++i) {
         var result = Math.pow(5.5, NaN);
         if (!isNaN(result))
             throw "Error: bad result, Math.pow(5.5, NaN) = " + result;
     }
     for (var i = 0; i < 10000; ++i) {
-        var result = Math.pow(i + 1, NaN);
+        var result = Math.pow(i + 0.5, NaN);
         if (!isNaN(result))
             throw "Error: bad result, Math.pow(i + 0.5, NaN) = " + result + " with i = " + i;
     }
 }
-noInline(testFloatingPointBaseWithNaNExponent);
-testFloatingPointBaseWithNaNExponent();
+noInline(testFloatingPointBaseWithNaNExponentStatic);
+testFloatingPointBaseWithNaNExponentStatic();
+
+function mathPowFloatingPointBaseWithNaNExponentDynamic(x, y) {
+    return Math.pow(x, y);
+}
+noInline(mathPowFloatingPointBaseWithNaNExponentDynamic);
+function testFloatingPointBaseWithNaNExponentDynamic() {
+    // Warm up with 2 double.
+    for (var i = 0; i < 10000; ++i) {
+        var result = mathPowFloatingPointBaseWithNaNExponentDynamic(2.5, 5.1);
+        if (result !== 107.02717054543135)
+            throw "Error: bad result, mathPowFloatingPointBaseWithNaNExponentDynamic(2.5, 5.1) = " + result + ", expected 107.02717054543135."
+    }
+
+    for (var i = 0; i < 10000; ++i) {
+        var result = mathPowFloatingPointBaseWithNaNExponentDynamic(i + 0.5, NaN);
+        if (!isNaN(result))
+            throw "Error: bad result, mathPowFloatingPointBaseWithNaNExponentDynamic(i + 0.5, NaN) = " + result + " with i = " + i + ", expected NaN";
+    }
+}
+noInline(testFloatingPointBaseWithNaNExponentDynamic);
+testFloatingPointBaseWithNaNExponentDynamic();
 
 // If y is +0, the result is 1, even if x is NaN.
 // If y is −0, the result is 1, even if x is NaN.
 // If x is NaN and y is nonzero, the result is NaN.
-function testNaNBase() {
+function testNaNBaseStatic() {
     for (var i = 0; i < 10000; ++i) {
         var result = Math.pow(NaN, i + 1);
         if (!isNaN(result))
@@ -54,12 +96,53 @@ function testNaNBase() {
             throw "Error: bad result, Math.pow(NaN, -0) = " + result;
     }
 }
-noInline(testNaNBase);
-testNaNBase();
+noInline(testNaNBaseStatic);
+testNaNBaseStatic();
+
+function mathPowNaNBaseDynamic1(x, y) {
+    return Math.pow(x, y);
+}
+function mathPowNaNBaseDynamic2(x, y) {
+    return Math.pow(x, y);
+}
+function mathPowNaNBaseDynamic3(x, y) {
+    return Math.pow(x, y);
+}
+function mathPowNaNBaseDynamic4(x, y) {
+    return Math.pow(x, y);
+}
+noInline(mathPowNaNBaseDynamic1);
+noInline(mathPowNaNBaseDynamic2);
+noInline(mathPowNaNBaseDynamic3);
+noInline(mathPowNaNBaseDynamic4);
+function testNaNBaseDynamic() {
+    for (var i = 0; i < 10000; ++i) {
+        var result = mathPowNaNBaseDynamic1(NaN, i + 1);
+        if (!isNaN(result))
+            throw "Error: bad result, mathPowNaNBaseDynamic1(NaN, i + 1) = " + result + " with i = " + i;
+    }
+    for (var i = 0; i < 10000; ++i) {
+        var result = mathPowNaNBaseDynamic2(NaN, i + 1.5);
+        if (!isNaN(result))
+            throw "Error: bad result, mathPowNaNBaseDynamic2(NaN, i + 1.5) = " + result + " with i = " + i;
+    }
+    for (var i = 0; i < 10000; ++i) {
+        var result = mathPowNaNBaseDynamic3(NaN, 0);
+        if (result !== 1)
+            throw "Error: bad result, mathPowNaNBaseDynamic3(NaN, 0) = " + result;
+    }
+    for (var i = 0; i < 10000; ++i) {
+        var result = mathPowNaNBaseDynamic4(NaN, -0);
+        if (result !== 1)
+            throw "Error: bad result, mathPowNaNBaseDynamic4(NaN, -0) = " + result;
+    }
+}
+noInline(testNaNBaseDynamic);
+testNaNBaseDynamic();
 
 // If abs(x) is 1 and y is +∞, the result is NaN.
 // If abs(x) is 1 and y is −∞, the result is NaN.
-function infiniteExponents() {
+function infiniteExponentsStatic() {
     for (var i = 0; i < 10000; ++i) {
         var result = Math.pow(1, Number.POSITIVE_INFINITY);
         if (!isNaN(result))
@@ -81,5 +164,46 @@ function infiniteExponents() {
             throw "Error: bad result, Math.pow(-1, Number.NEGATIVE_INFINITY) = " + result;
     }
 }
-noInline(infiniteExponents);
-infiniteExponents();
+noInline(infiniteExponentsStatic);
+infiniteExponentsStatic();
+
+function mathPowInfiniteExponentsDynamic1(x, y) {
+    return Math.pow(x, y);
+}
+function mathPowInfiniteExponentsDynamic2(x, y) {
+    return Math.pow(x, y);
+}
+function mathPowInfiniteExponentsDynamic3(x, y) {
+    return Math.pow(x, y);
+}
+function mathPowInfiniteExponentsDynamic4(x, y) {
+    return Math.pow(x, y);
+}
+noInline(mathPowInfiniteExponentsDynamic1);
+noInline(mathPowInfiniteExponentsDynamic2);
+noInline(mathPowInfiniteExponentsDynamic3);
+noInline(mathPowInfiniteExponentsDynamic4);
+function infiniteExponentsDynamic() {
+    for (var i = 0; i < 10000; ++i) {
+        var result = mathPowInfiniteExponentsDynamic1(1, Number.POSITIVE_INFINITY);
+        if (!isNaN(result))
+            throw "Error: bad result, mathPowInfiniteExponentsDynamic1(1, Number.POSITIVE_INFINITY) = " + result;
+    }
+    for (var i = 0; i < 10000; ++i) {
+        var result = mathPowInfiniteExponentsDynamic2(-1, Number.POSITIVE_INFINITY);
+        if (!isNaN(result))
+            throw "Error: bad result, mathPowInfiniteExponentsDynamic2(-1, Number.POSITIVE_INFINITY) = " + result;
+    }
+    for (var i = 0; i < 10000; ++i) {
+        var result = mathPowInfiniteExponentsDynamic3(1, Number.NEGATIVE_INFINITY);
+        if (!isNaN(result))
+            throw "Error: bad result, mathPowInfiniteExponentsDynamic3(1, Number.NEGATIVE_INFINITY) = " + result;
+    }
+    for (var i = 0; i < 10000; ++i) {
+        var result = mathPowInfiniteExponentsDynamic4(-1, Number.NEGATIVE_INFINITY);
+        if (!isNaN(result))
+            throw "Error: bad result, mathPowInfiniteExponentsDynamic4(-1, Number.NEGATIVE_INFINITY) = " + result;
+    }
+}
+noInline(infiniteExponentsDynamic);
+infiniteExponentsDynamic();
\ No newline at end of file
index a4c108c..d25902d 100644 (file)
@@ -113,3 +113,103 @@ function testBaseAndExponentConstantLiterals()
     }
 }
 testBaseAndExponentConstantLiterals();
+
+
+function exponentIsIntegerConstant(x) {
+    return Math.pow(x, 42);
+}
+noInline(exponentIsIntegerConstant);
+
+function testExponentIsIntegerConstant() {
+    for (var i = 0; i < 1000; ++i) {
+        var result = exponentIsIntegerConstant(2);
+        if (result !== 4398046511104)
+            throw "Error: exponentIsIntegerConstant(2) should be 4398046511104, was = " + result;
+    }
+    for (var i = 0; i < 1000; ++i) {
+        var result = exponentIsIntegerConstant(5);
+        if (result !== 2.2737367544323207e+29)
+            throw "Error: exponentIsIntegerConstant(5) should be 2.2737367544323207e+29, was = " + result;
+    }
+    for (var i = 0; i < 1000; ++i) {
+        var result = exponentIsIntegerConstant(2.1);
+        if (result !== 34135823067412.42)
+            throw "Error: exponentIsIntegerConstant(2.1) should be 34135823067412.42, was = " + result;
+    }
+}
+testExponentIsIntegerConstant();
+
+
+function exponentIsDoubleConstant(x) {
+    return Math.pow(x, 42.5);
+}
+noInline(exponentIsDoubleConstant);
+
+function testExponentIsDoubleConstant() {
+    for (var i = 0; i < 1000; ++i) {
+        var result = exponentIsDoubleConstant(2);
+        if (result !== 6219777023950.95)
+            throw "Error: exponentIsDoubleConstant(2) should be 6219777023950.95, was = " + result;
+    }
+    for (var i = 0; i < 1000; ++i) {
+        var result = exponentIsDoubleConstant(5);
+        if (result !== 5.084229945850415e+29)
+            throw "Error: exponentIsDoubleConstant(5) should be 5.084229945850415e+29, was = " + result;
+    }
+    for (var i = 0; i < 1000; ++i) {
+        var result = exponentIsDoubleConstant(2.1);
+        if (result !== 49467507261113.805)
+            throw "Error: exponentIsDoubleConstant(2.1) should be 49467507261113.805, was = " + result;
+    }
+}
+testExponentIsDoubleConstant();
+
+
+function exponentIsInfinityConstant(x) {
+    return Math.pow(x, Infinity);
+}
+noInline(exponentIsInfinityConstant);
+
+function testExponentIsInfinityConstant() {
+    for (var i = 0; i < 1000; ++i) {
+        var result = exponentIsInfinityConstant(2);
+        if (result !== Infinity)
+            throw "Error: exponentIsInfinityConstant(2) should be Infinity, was = " + result;
+    }
+    for (var i = 0; i < 1000; ++i) {
+        var result = exponentIsInfinityConstant(5);
+        if (result !== Infinity)
+            throw "Error: exponentIsInfinityConstant(5) should be Infinity, was = " + result;
+    }
+    for (var i = 0; i < 1000; ++i) {
+        var result = exponentIsInfinityConstant(2.1);
+        if (result !== Infinity)
+            throw "Error: exponentIsInfinityConstant(2.1) should be Infinity, was = " + result;
+    }
+}
+testExponentIsInfinityConstant();
+
+
+function exponentIsNegativeInfinityConstant(x) {
+    return Math.pow(x, -Infinity);
+}
+noInline(exponentIsNegativeInfinityConstant);
+
+function testExponentIsNegativeInfinityConstant() {
+    for (var i = 0; i < 1000; ++i) {
+        var result = exponentIsNegativeInfinityConstant(2);
+        if (result !== 0)
+            throw "Error: exponentIsNegativeInfinityConstant(2) should be zero, was = " + result;
+    }
+    for (var i = 0; i < 1000; ++i) {
+        var result = exponentIsNegativeInfinityConstant(5);
+        if (result !== 0)
+            throw "Error: exponentIsNegativeInfinityConstant(5) should be zero, was = " + result;
+    }
+    for (var i = 0; i < 1000; ++i) {
+        var result = exponentIsNegativeInfinityConstant(2.1);
+        if (result !== 0)
+            throw "Error: exponentIsNegativeInfinityConstant(2.1) should be zero, was = " + result;
+    }
+}
+testExponentIsNegativeInfinityConstant();
\ No newline at end of file
diff --git a/Source/JavaScriptCore/tests/stress/math-pow-with-never-NaN-exponent.js b/Source/JavaScriptCore/tests/stress/math-pow-with-never-NaN-exponent.js
new file mode 100644 (file)
index 0000000..d5d6bc0
--- /dev/null
@@ -0,0 +1,24 @@
+function exponentIsNonNanDouble1(x, doubleArrayIndex) {
+    var doubleArray = [4.4];
+    return Math.pow(x, doubleArray[doubleArrayIndex]);
+}
+noInline(exponentIsNonNanDouble1);
+
+function exponentIsNonNanDouble2(x, doubleArray) {
+    return Math.pow(x, doubleArray[0]);
+}
+noInline(exponentIsNonNanDouble2);
+
+function testExponentIsDoubleConstant() {
+    for (var i = 0; i < 10000; ++i) {
+        var result = exponentIsNonNanDouble1(2, 0);
+        if (result !== 21.112126572366314)
+            throw "Error: exponentIsNonNanDouble1(2, 0) should be 21.112126572366314, was = " + result;
+    }
+    for (var i = 0; i < 10000; ++i) {
+        var result = exponentIsNonNanDouble2(3, [-1.5]);
+        if (result !== 0.19245008972987526)
+            throw "Error: exponentIsNonNanDouble2(3, [-1.5]) should be 0.19245008972987526, was = " + result;
+    }
+}
+testExponentIsDoubleConstant();