consolidate util methods in PythonUtils

Author: timfel

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/common/SequenceStorageNodes.java

@@ -124,7 +124,6 @@
 import com.oracle.graal.python.nodes.subscript.SliceLiteralNode.ComputeIndices;
 import com.oracle.graal.python.nodes.util.CastToByteNode;
 import com.oracle.graal.python.nodes.util.CastToJavaByteNode;
-import com.oracle.graal.python.nodes.util.ExactMath;
 import com.oracle.graal.python.runtime.PythonContext;
 import com.oracle.graal.python.runtime.PythonOptions;
 import com.oracle.graal.python.runtime.exception.PException;
@@ -2408,7 +2407,7 @@ public ExtendNode(GenNodeSupplier genNodeProvider) {
 
         private static int lengthResult(int current, int ext) {
             try {
-                return ExactMath.addExact(current, ext);
+                return PythonUtils.addExact(current, ext);
             } catch (OverflowException e) {
                 // (mq) There is no need to ensure capacity as we either
                 // run out of memory or dealing with a fake length.

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/range/RangeNodes.java

@@ -50,9 +50,9 @@
 import com.oracle.graal.python.nodes.PRaiseNode;
 import com.oracle.graal.python.nodes.SpecialMethodNames;
 import com.oracle.graal.python.nodes.util.CastToJavaBigIntegerNode;
-import com.oracle.graal.python.nodes.util.ExactMath;
 import com.oracle.graal.python.runtime.object.PythonObjectFactory;
 import com.oracle.graal.python.util.OverflowException;
+import com.oracle.graal.python.util.PythonUtils;
 import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
 import com.oracle.truffle.api.dsl.Cached;
 import com.oracle.truffle.api.dsl.GenerateNodeFactory;
@@ -189,14 +189,14 @@ static Object doBigInt(BigInteger lo, BigInteger hi, BigInteger step) {
     public abstract static class LenOfIntRangeNodeExact extends LenOfIntRangeBaseNode {
         @Specialization(guards = {"step > 0", "lo < hi"})
         static int mightBeBig1(int lo, int hi, int step) throws OverflowException {
-            long diff = ExactMath.subtractExact(ExactMath.subtractExact(hi, (long) lo), 1);
-            return ExactMath.toIntExact(ExactMath.addExact(diff / step, 1));
+            long diff = PythonUtils.subtractExact(PythonUtils.subtractExact(hi, (long) lo), 1);
+            return PythonUtils.toIntExact(PythonUtils.addExact(diff / step, 1));
         }
 
         @Specialization(guards = {"step < 0", "lo > hi"})
         static int mightBeBig2(int lo, int hi, int step) throws OverflowException {
-            long diff = ExactMath.subtractExact(ExactMath.subtractExact(lo, (long) hi), 1);
-            return ExactMath.toIntExact(ExactMath.addExact(diff / -(long) step, 1));
+            long diff = PythonUtils.subtractExact(PythonUtils.subtractExact(lo, (long) hi), 1);
+            return PythonUtils.toIntExact(PythonUtils.addExact(diff / -(long) step, 1));
         }
     }
 

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/util/ExactMath.java

@@ -94,6 +94,50 @@ public static void getChars(String str, int srcBegin, int srcEnd, char[] dst, in
         str.getChars(srcBegin, srcEnd, dst, dstBegin);
     }
 
+    /*
+     * Replacements for JDK's exact math methods that throw the checked singleton
+     * {@link OverflowException}. The implementation is taken from JDK.
+     */
+    public static int addExact(int x, int y) throws OverflowException {
+        int r = x + y;
+        if (((x ^ r) & (y ^ r)) < 0) {
+            throw OverflowException.INSTANCE;
+        }
+        return r;
+    }
+
+    public static long addExact(long x, long y) throws OverflowException {
+        long r = x + y;
+        if (((x ^ r) & (y ^ r)) < 0) {
+            throw OverflowException.INSTANCE;
+        }
+        return r;
+    }
+
+    public static int subtractExact(int x, int y) throws OverflowException {
+        int r = x - y;
+        if (((x ^ y) & (x ^ r)) < 0) {
+            throw OverflowException.INSTANCE;
+        }
+        return r;
+    }
+
+    public static long subtractExact(long x, long y) throws OverflowException {
+        long r = x - y;
+        if (((x ^ y) & (x ^ r)) < 0) {
+            throw OverflowException.INSTANCE;
+        }
+        return r;
+    }
+
+    public static int toIntExact(long x) throws OverflowException {
+        int r = (int) x;
+        if (r != x) {
+            throw OverflowException.INSTANCE;
+        }
+        return r;
+    }
+
     public static int multiplyExact(int x, int y) throws OverflowException {
         // copy&paste from Math.multiplyExact
         long r = (long) x * (long) y;