[GR-23280] Various fixes for the pow builtin

PullRequest: graalpython/1016

Author: timfel

graalpython/com.oracle.graal.python.test/src/tests/pow_tests.py

@@ -0,0 +1,128 @@
+# Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+#
+# The Universal Permissive License (UPL), Version 1.0
+#
+# Subject to the condition set forth below, permission is hereby granted to any
+# person obtaining a copy of this software, associated documentation and/or
+# data (collectively the "Software"), free of charge and under any and all
+# copyright rights in the Software, and any and all patent rights owned or
+# freely licensable by each licensor hereunder covering either (i) the
+# unmodified Software as contributed to or provided by such licensor, or (ii)
+# the Larger Works (as defined below), to deal in both
+#
+# (a) the Software, and
+#
+# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if
+# one is included with the Software each a "Larger Work" to which the Software
+# is contributed by such licensors),
+#
+# without restriction, including without limitation the rights to copy, create
+# derivative works of, display, perform, and distribute the Software and make,
+# use, sell, offer for sale, import, export, have made, and have sold the
+# Software and the Larger Work(s), and to sublicense the foregoing rights on
+# either these or other terms.
+#
+# This license is subject to the following condition:
+#
+# The above copyright notice and either this complete permission notice or at a
+# minimum a reference to the UPL must be included in all copies or substantial
+# portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+import sys
+
+
+def test_pow():
+    if sys.implementation.name == "graalpython":
+        try:
+            2 ** (2**128)
+        except ArithmeticError:
+            assert True
+        else:
+            assert False
+
+    assert 2 ** -(2**128) == 0.0
+
+    class X(float):
+        def __rpow__(self, other):
+            return 42
+
+    assert 2 ** X() == 42
+
+    try:
+        2.0 .__pow__(2, 2)
+    except TypeError as e:
+        assert True
+    else:
+        assert False
+
+    try:
+        2.0 .__pow__(2.0, 2.0)
+    except TypeError as e:
+        assert True
+    else:
+        assert False
+
+    assert 2 ** 2.0 == 4.0
+
+    assert 2 .__pow__("a") == NotImplemented
+    assert 2 .__pow__("a", 2) == NotImplemented
+    assert 2 .__pow__(2**30, 2**128) == 0
+
+    # crafted to try specializations
+    def mypow(a, b, c):
+        return a.__pow__(b, c)
+
+    values = [
+        [1, 2, None, 1], # long
+        [1, 128, None, 1], # BigInteger
+        [1, -2, None, 1.0], # double result
+        [1, 0xffffffffffffffffffffffffffffffff & 0x80, None, 1], # narrow to long
+        [2, 0xffffffffffffffffffffffffffffffff & 0x80, None, 340282366920938463463374607431768211456], # cannot narrow
+        [2, -(0xffffffffffffffffffffffffffffffff & 0x80), None, 2.938735877055719e-39], # double result
+        [2**128, 0, None, 1], # narrow to long
+        [2**128, 1, None, 340282366920938463463374607431768211456], # cannot narrow
+        [2**128, -2, None, 8.636168555094445e-78], # double
+        [2**128, 0xffffffffffffffffffffffffffffffff & 0x2, None, 115792089237316195423570985008687907853269984665640564039457584007913129639936], # large
+        [2**128, -(0xffffffffffffffffffffffffffffffff & 0x8), None, 5.562684646268003e-309], # double result
+        [1, 2, 3, 1], # fast path
+        [2, 2**30, 2**128, 0], # generic
+        ] + []
+
+    if sys.version_info.minor >= 8:
+        values += [
+            [1, -2, 3, 1], # fast path double
+            [1, 2, -3, -2], # negative mod
+            [1, -2, -3, -2], # negative mod and negative right
+            [1, -2**128, 3, 1], # mod and large negative right
+            [1, -2**128, -3, -2], # negative mod and large negative right
+            [1, -2**128, -2**64, -18446744073709551615], # large negative mod and large negative right
+        ]
+
+    for args in values:
+        assert mypow(*args[:-1]) == args[-1], "%r -> %r == %r" % (args, mypow(*args[:-1]), args[-1])
+
+    def mypow_rev(a, b, c):
+        return a.__pow__(b, c)
+
+    for args in reversed(values):
+        assert mypow_rev(*args[:-1]) == args[-1], "%r -> %r == %r" % (args, mypow(*args[:-1]), args[-1])
+
+    assert 2**1.0 == 2.0
+
+    try:
+        pow(12,-2,100)
+    except ValueError as e:
+        assert "base is not invertible for the given modulus" in str(e)
+    else:
+        assert False
+
+    assert pow(1234567, -2, 100) == 9

graalpython/com.oracle.graal.python.test/src/tests/test_binary_arithmetic.py

@@ -21,6 +21,9 @@
 # AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 # NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 # OF THE POSSIBILITY OF SUCH DAMAGE.
+
+import sys
+
 def test_add_long_overflow():
     # max long value is written as long primitive
     val = 0x7fffffffffffffff
@@ -295,3 +298,8 @@ def test_lshift():
 def test_pow():
     # (0xffffffffffffffff >> 63) is used to produce a non-narrowed int
     assert 2**(0xffffffffffffffff >> 63) == 2
+
+    if sys.version_info.minor >= 8:
+        # for some reason this hangs CPython on the CI even if it's just parsed
+        from pow_tests import test_pow
+        test_pow()

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/BuiltinFunctions.java

@@ -1693,7 +1693,7 @@ private int getDebuggerSessionCount() {
         }
     }
 
-    @Builtin(name = POW, minNumOfPositionalArgs = 2, parameterNames = {"x", "y", "z"})
+    @Builtin(name = POW, minNumOfPositionalArgs = 2, parameterNames = {"base", "exp", "mod"})
     @GenerateNodeFactory
     public abstract static class PowNode extends PythonBuiltinNode {
         @Child private LookupAndCallTernaryNode powNode = TernaryArithmetic.Pow.create();

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/floats/FloatBuiltins.java

@@ -81,6 +81,7 @@
 import com.oracle.graal.python.builtins.objects.type.LazyPythonClass;
 import com.oracle.graal.python.nodes.ErrorMessages;
 import com.oracle.graal.python.nodes.SpecialMethodNames;
+import com.oracle.graal.python.nodes.call.special.LookupAndCallTernaryNode;
 import com.oracle.graal.python.nodes.call.special.LookupAndCallVarargsNode;
 import com.oracle.graal.python.nodes.classes.IsSubtypeNode;
 import com.oracle.graal.python.nodes.function.PythonBuiltinBaseNode;
@@ -95,17 +96,22 @@
 import com.oracle.graal.python.runtime.formatting.FloatFormatter;
 import com.oracle.graal.python.runtime.formatting.InternalFormat;
 import com.oracle.graal.python.runtime.formatting.InternalFormat.Formatter;
+import com.oracle.truffle.api.CompilerDirectives;
 import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
 import com.oracle.truffle.api.dsl.Cached;
+import com.oracle.truffle.api.dsl.Cached.Shared;
 import com.oracle.truffle.api.dsl.CachedContext;
 import com.oracle.truffle.api.dsl.Fallback;
 import com.oracle.truffle.api.dsl.GenerateNodeFactory;
 import com.oracle.truffle.api.dsl.ImportStatic;
 import com.oracle.truffle.api.dsl.NodeFactory;
+import com.oracle.truffle.api.dsl.ReportPolymorphism;
 import com.oracle.truffle.api.dsl.Specialization;
 import com.oracle.truffle.api.dsl.TypeSystemReference;
 import com.oracle.truffle.api.frame.VirtualFrame;
 import com.oracle.truffle.api.library.CachedLibrary;
+import com.oracle.truffle.api.nodes.UnexpectedResultException;
+import com.oracle.truffle.api.profiles.BranchProfile;
 import com.oracle.truffle.api.profiles.ConditionProfile;
 
 @CoreFunctions(extendClasses = PythonBuiltinClassType.PFloat)
@@ -451,71 +457,131 @@ PNotImplemented doGeneric(Object left, Object right) {
     @Builtin(name = __POW__, minNumOfPositionalArgs = 2, maxNumOfPositionalArgs = 3)
     @TypeSystemReference(PythonArithmeticTypes.class)
     @GenerateNodeFactory
+    @ReportPolymorphism
     abstract static class PowerNode extends PythonTernaryBuiltinNode {
         @Specialization
-        double doDL(double left, long right, @SuppressWarnings("unused") PNone none) {
-            return Math.pow(left, right);
+        double doDL(double left, long right, @SuppressWarnings("unused") PNone none,
+                        @Shared("negativeRaise") @Cached BranchProfile negativeRaise) {
+            return doOperation(left, right, negativeRaise);
         }
 
         @Specialization
-        double doDPi(double left, PInt right, @SuppressWarnings("unused") PNone none) {
-            return Math.pow(left, right.doubleValue());
-        }
-
-        @Specialization
-        double doDD(double left, double right, @SuppressWarnings("unused") PNone none) {
-            return Math.pow(left, right);
+        double doDPi(double left, PInt right, @SuppressWarnings("unused") PNone none,
+                        @Shared("negativeRaise") @Cached BranchProfile negativeRaise) {
+            return doOperation(left, right.doubleValue(), negativeRaise);
         }
 
-        @Specialization
-        double doDL(double left, long right, long mod) {
-            return Math.pow(left, right) % mod;
+        /**
+         * The special cases we need to deal with always return 1, so 0 means no special case, not a
+         * result.
+         */
+        private double doSpecialCases(double left, double right, BranchProfile negativeRaise) {
+            // see cpython://Objects/floatobject.c#float_pow for special cases
+            if (Double.isNaN(right) && left == 1) {
+                // 1**nan = 1, unlike on Java
+                return 1;
+            }
+            if (Double.isInfinite(right) && (left == 1 || left == -1)) {
+                // v**(+/-)inf is 1.0 if abs(v) == 1, unlike on Java
+                return 1;
+            }
+            if (left == 0 && right < 0) {
+                negativeRaise.enter();
+                // 0**w is an error if w is negative, unlike Java
+                throw raise(PythonBuiltinClassType.ZeroDivisionError, ErrorMessages.POW_ZERO_CANNOT_RAISE_TO_NEGATIVE_POWER);
+            }
+            return 0;
         }
 
-        @Specialization
-        double doDPi(double left, PInt right, long mod) {
-            return Math.pow(left, right.doubleValue()) % mod;
+        private double doOperation(double left, double right, BranchProfile negativeRaise) {
+            if (doSpecialCases(left, right, negativeRaise) == 1) {
+                return 1.0;
+            }
+            return Math.pow(left, right);
         }
 
-        @Specialization
-        double doDD(double left, double right, long mod) {
-            return Math.pow(left, right) % mod;
+        @Specialization(rewriteOn = UnexpectedResultException.class)
+        double doDD(VirtualFrame frame, double left, double right, @SuppressWarnings("unused") PNone none,
+                        @Shared("powCall") @Cached("create(__POW__)") LookupAndCallTernaryNode callPow,
+                        @Shared("negativeRaise") @Cached BranchProfile negativeRaise) throws UnexpectedResultException {
+            if (doSpecialCases(left, right, negativeRaise) == 1) {
+                return 1.0;
+            }
+            if (left < 0 && (right % 1 != 0)) {
+                CompilerDirectives.transferToInterpreterAndInvalidate();
+                // Negative numbers raised to fractional powers become complex.
+                throw new UnexpectedResultException(callPow.execute(frame, factory().createComplex(left, 0), factory().createComplex(right, 0), none));
+            }
+            return Math.pow(left, right);
         }
 
-        @Specialization
-        double doDL(double left, long right, PInt mod) {
-            return Math.pow(left, right) % mod.doubleValue();
+        @Specialization(replaces = "doDD")
+        Object doDDToComplex(VirtualFrame frame, double left, double right, PNone none,
+                        @Shared("powCall") @Cached("create(__POW__)") LookupAndCallTernaryNode callPow,
+                        @Shared("negativeRaise") @Cached BranchProfile negativeRaise) {
+            if (doSpecialCases(left, right, negativeRaise) == 1) {
+                return 1.0;
+            }
+            if (left < 0 && (right % 1 != 0)) {
+                // Negative numbers raised to fractional powers become complex.
+                return callPow.execute(frame, factory().createComplex(left, 0), factory().createComplex(right, 0), none);
+            }
+            return Math.pow(left, right);
         }
 
-        @Specialization
-        double doDPi(double left, PInt right, PInt mod) {
-            return Math.pow(left, right.doubleValue()) % mod.doubleValue();
+        @Specialization(rewriteOn = UnexpectedResultException.class)
+        double doDL(VirtualFrame frame, long left, double right, PNone none,
+                        @Shared("powCall") @Cached("create(__POW__)") LookupAndCallTernaryNode callPow,
+                        @Shared("negativeRaise") @Cached BranchProfile negativeRaise) throws UnexpectedResultException {
+            return doDD(frame, left, right, none, callPow, negativeRaise);
         }
 
-        @Specialization
-        double doDD(double left, double right, PInt mod) {
-            return Math.pow(left, right) % mod.doubleValue();
+        @Specialization(replaces = "doDL")
+        Object doDLComplex(VirtualFrame frame, long left, double right, PNone none,
+                        @Shared("powCall") @Cached("create(__POW__)") LookupAndCallTernaryNode callPow,
+                        @Shared("negativeRaise") @Cached BranchProfile negativeRaise) {
+            return doDDToComplex(frame, left, right, none, callPow, negativeRaise);
         }
 
-        @Specialization
-        double doDL(double left, long right, double mod) {
-            return Math.pow(left, right) % mod;
+        @Specialization(rewriteOn = UnexpectedResultException.class)
+        double doDPi(VirtualFrame frame, PInt left, double right, @SuppressWarnings("unused") PNone none,
+                        @Shared("powCall") @Cached("create(__POW__)") LookupAndCallTernaryNode callPow,
+                        @Shared("negativeRaise") @Cached BranchProfile negativeRaise) throws UnexpectedResultException {
+            return doDD(frame, left.doubleValue(), right, none, callPow, negativeRaise);
         }
 
-        @Specialization
-        double doDPi(double left, PInt right, double mod) {
-            return Math.pow(left, right.doubleValue()) % mod;
+        @Specialization(replaces = "doDPi")
+        Object doDPiToComplex(VirtualFrame frame, PInt left, double right, @SuppressWarnings("unused") PNone none,
+                        @Shared("powCall") @Cached("create(__POW__)") LookupAndCallTernaryNode callPow,
+                        @Shared("negativeRaise") @Cached BranchProfile negativeRaise) {
+            return doDDToComplex(frame, left.doubleValue(), right, none, callPow, negativeRaise);
         }
 
         @Specialization
-        double doDD(double left, double right, double mod) {
-            return Math.pow(left, right) % mod;
-        }
-
-        @SuppressWarnings("unused")
-        @Fallback
-        PNotImplemented doGeneric(Object left, Object right, Object none) {
-            return PNotImplemented.NOT_IMPLEMENTED;
+        Object doGeneric(VirtualFrame frame, Object left, Object right, Object mod,
+                        @CachedLibrary(limit = "5") PythonObjectLibrary lib,
+                        @Shared("powCall") @Cached("create(__POW__)") LookupAndCallTernaryNode callPow,
+                        @Shared("negativeRaise") @Cached BranchProfile negativeRaise) {
+            if (!(mod instanceof PNone)) {
+                throw raise(PythonBuiltinClassType.TypeError, "pow() 3rd argument not allowed unless all arguments are integers");
+            }
+            double leftDouble;
+            double rightDouble;
+            if (lib.canBeJavaDouble(left)) {
+                leftDouble = lib.asJavaDouble(left);
+            } else if (left instanceof PInt) {
+                leftDouble = ((PInt) left).doubleValue();
+            } else {
+                return PNotImplemented.NOT_IMPLEMENTED;
+            }
+            if (lib.canBeJavaDouble(right)) {
+                rightDouble = lib.asJavaDouble(right);
+            } else if (right instanceof PInt) {
+                rightDouble = ((PInt) right).doubleValue();
+            } else {
+                return PNotImplemented.NOT_IMPLEMENTED;
+            }
+            return doDDToComplex(frame, leftDouble, rightDouble, PNone.NONE, callPow, negativeRaise);
         }
     }