[GR-25992] Do not catch arithmetic exceptions in PE code when working with ranges and BigDecimals.

PullRequest: graalpython/1253

Author: steve-s

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

@@ -154,6 +154,7 @@
 import com.oracle.graal.python.builtins.objects.range.PBigRange;
 import com.oracle.graal.python.builtins.objects.range.PIntRange;
 import com.oracle.graal.python.builtins.objects.range.RangeNodes;
+import com.oracle.graal.python.builtins.objects.range.RangeNodes.LenOfIntRangeNodeExact;
 import com.oracle.graal.python.builtins.objects.set.PFrozenSet;
 import com.oracle.graal.python.builtins.objects.set.PSet;
 import com.oracle.graal.python.builtins.objects.str.PString;
@@ -213,6 +214,7 @@
 import com.oracle.graal.python.runtime.sequence.storage.ObjectSequenceStorage;
 import com.oracle.graal.python.runtime.sequence.storage.SequenceStorage;
 import com.oracle.graal.python.util.PythonUtils;
+import com.oracle.graal.python.util.OverflowException;
 import com.oracle.truffle.api.Assumption;
 import com.oracle.truffle.api.CompilerAsserts;
 import com.oracle.truffle.api.CompilerDirectives;
@@ -701,7 +703,7 @@ public PythonObject reversed(@SuppressWarnings("unused") Object cls, PIntRange r
             int lstart = range.getIntStart();
             int lstop = range.getIntStop();
             int lstep = range.getIntStep();
-            int ulen = lenOfRangeNode.len(lstart, lstop, lstep);
+            int ulen = lenOfRangeNode.executeInt(lstart, lstop, lstep);
             int new_stop = lstart - lstep;
             int new_start = new_stop + ulen * lstep;
 
@@ -715,7 +717,7 @@ public PythonObject reversed(@SuppressWarnings("unused") Object cls, PBigRange r
             BigInteger lstart = range.getBigIntegerStart();
             BigInteger lstop = range.getBigIntegerStop();
             BigInteger lstep = range.getBigIntegerStep();
-            BigInteger ulen = (BigInteger) lenOfRangeNode.execute(lstart, lstop, lstep);
+            BigInteger ulen = lenOfRangeNode.execute(lstart, lstop, lstep);
 
             BigInteger new_stop = lstart.subtract(lstep);
             BigInteger new_start = new_stop.add(ulen.multiply(lstep));
@@ -1649,9 +1651,9 @@ public abstract static class RangeNode extends PythonQuaternaryBuiltinNode {
         Object doIntStop(Object cls, int stop, @SuppressWarnings("unused") PNone start, @SuppressWarnings("unused") PNone step,
                         @Shared("stepZeroProfile") @Cached ConditionProfile stepZeroProfile,
                         @Shared("exceptionProfile") @Cached BranchProfile exceptionProfile,
-                        @Shared("lenOfRangeNode") @Cached RangeNodes.LenOfRangeNode lenOfRangeNode,
+                        @Shared("lenOfRangeNodeExact") @Cached LenOfIntRangeNodeExact lenOfRangeNodeExact,
                         @Shared("createBigRangeNode") @Cached RangeNodes.CreateBigRangeNode createBigRangeNode) {
-            return doInt(cls, 0, stop, 1, stepZeroProfile, exceptionProfile, lenOfRangeNode, createBigRangeNode);
+            return doInt(cls, 0, stop, 1, stepZeroProfile, exceptionProfile, lenOfRangeNodeExact, createBigRangeNode);
         }
 
         @Specialization(guards = "isStop(start, stop, step)")
@@ -1665,21 +1667,21 @@ Object doPintStop(Object cls, PInt stop, @SuppressWarnings("unused") PNone start
         Object doGenericStop(Object cls, Object stop, @SuppressWarnings("unused") PNone start, @SuppressWarnings("unused") PNone step,
                         @Shared("stepZeroProfile") @Cached ConditionProfile stepZeroProfile,
                         @Shared("exceptionProfile") @Cached BranchProfile exceptionProfile,
-                        @Shared("lenOfRangeNode") @Cached RangeNodes.LenOfRangeNode lenOfRangeNode,
+                        @Shared("lenOfRangeNodeExact") @Cached LenOfIntRangeNodeExact lenOfRangeNodeExact,
                         @Shared("createBigRangeNode") @Cached RangeNodes.CreateBigRangeNode createBigRangeNode,
                         @Shared("polGeneric") @CachedLibrary(limit = "3") PythonObjectLibrary pol,
                         @Shared("libGeneric") @CachedLibrary(limit = "3") InteropLibrary lib) {
-            return doGeneric(cls, 0, stop, 1, stepZeroProfile, exceptionProfile, lenOfRangeNode, createBigRangeNode, pol, lib);
+            return doGeneric(cls, 0, stop, 1, stepZeroProfile, exceptionProfile, lenOfRangeNodeExact, createBigRangeNode, pol, lib);
         }
 
         // start stop
         @Specialization(guards = "isStartStop(start, stop, step)")
         Object doIntStartStop(Object cls, int start, int stop, @SuppressWarnings("unused") PNone step,
                         @Shared("stepZeroProfile") @Cached ConditionProfile stepZeroProfile,
                         @Shared("exceptionProfile") @Cached BranchProfile exceptionProfile,
-                        @Shared("lenOfRangeNode") @Cached RangeNodes.LenOfRangeNode lenOfRangeNode,
+                        @Shared("lenOfRangeNodeExact") @Cached LenOfIntRangeNodeExact lenOfRangeNodeExact,
                         @Shared("createBigRangeNode") @Cached RangeNodes.CreateBigRangeNode createBigRangeNode) {
-            return doInt(cls, start, stop, 1, stepZeroProfile, exceptionProfile, lenOfRangeNode, createBigRangeNode);
+            return doInt(cls, start, stop, 1, stepZeroProfile, exceptionProfile, lenOfRangeNodeExact, createBigRangeNode);
         }
 
         @Specialization(guards = "isStartStop(start, stop, step)")
@@ -1693,27 +1695,27 @@ Object doPintStartStop(Object cls, PInt start, PInt stop, @SuppressWarnings("unu
         Object doGenericStartStop(Object cls, Object start, Object stop, @SuppressWarnings("unused") PNone step,
                         @Shared("stepZeroProfile") @Cached ConditionProfile stepZeroProfile,
                         @Shared("exceptionProfile") @Cached BranchProfile exceptionProfile,
-                        @Shared("lenOfRangeNode") @Cached RangeNodes.LenOfRangeNode lenOfRangeNode,
+                        @Shared("lenOfRangeNodeExact") @Cached LenOfIntRangeNodeExact lenOfRangeNodeExact,
                         @Shared("createBigRangeNode") @Cached RangeNodes.CreateBigRangeNode createBigRangeNode,
                         @Shared("polGeneric") @CachedLibrary(limit = "3") PythonObjectLibrary pol,
                         @Shared("libGeneric") @CachedLibrary(limit = "3") InteropLibrary lib) {
-            return doGeneric(cls, start, stop, 1, stepZeroProfile, exceptionProfile, lenOfRangeNode, createBigRangeNode, pol, lib);
+            return doGeneric(cls, start, stop, 1, stepZeroProfile, exceptionProfile, lenOfRangeNodeExact, createBigRangeNode, pol, lib);
         }
 
         // start stop step
         @Specialization
         Object doInt(@SuppressWarnings("unused") Object cls, int start, int stop, int step,
                         @Shared("stepZeroProfile") @Cached ConditionProfile stepZeroProfile,
                         @Shared("exceptionProfile") @Cached BranchProfile exceptionProfile,
-                        @Shared("lenOfRangeNode") @Cached RangeNodes.LenOfRangeNode lenOfRangeNode,
+                        @Shared("lenOfRangeNodeExact") @Cached LenOfIntRangeNodeExact lenOfRangeNode,
                         @Shared("createBigRangeNode") @Cached RangeNodes.CreateBigRangeNode createBigRangeNode) {
             if (stepZeroProfile.profile(step == 0)) {
                 throw raise(ValueError, ARG_MUST_NOT_BE_ZERO, "range()", 3);
             }
             try {
-                int len = lenOfRangeNode.len(start, stop, step);
+                int len = lenOfRangeNode.executeInt(start, stop, step);
                 return factory().createIntRange(start, stop, step, len);
-            } catch (ArithmeticException e) {
+            } catch (OverflowException e) {
                 exceptionProfile.enter();
                 return createBigRangeNode.execute(start, stop, step, factory());
             }
@@ -1726,20 +1728,20 @@ Object doPint(@SuppressWarnings("unused") Object cls, PInt start, PInt stop, PIn
             if (stepZeroProfile.profile(step.isZero())) {
                 throw raise(ValueError, ARG_MUST_NOT_BE_ZERO, "range()", 3);
             }
-            BigInteger len = (BigInteger) lenOfRangeNode.execute(start, stop, step);
+            BigInteger len = lenOfRangeNode.execute(start.getValue(), stop.getValue(), step.getValue());
             return factory().createBigRange(start, stop, step, factory().createInt(len));
         }
 
         @Specialization(guards = "isStartStopStep(start, stop, step)")
         Object doGeneric(@SuppressWarnings("unused") Object cls, Object start, Object stop, Object step,
                         @Shared("stepZeroProfile") @Cached ConditionProfile stepZeroProfile,
                         @Shared("exceptionProfile") @Cached BranchProfile exceptionProfile,
-                        @Shared("lenOfRangeNode") @Cached RangeNodes.LenOfRangeNode lenOfRangeNode,
+                        @Shared("lenOfRangeNodeExact") @Cached LenOfIntRangeNodeExact lenOfRangeNodeExact,
                         @Shared("createBigRangeNode") @Cached RangeNodes.CreateBigRangeNode createBigRangeNode,
                         @Shared("polGeneric") @CachedLibrary(limit = "3") PythonObjectLibrary pol,
                         @Shared("libGeneric") @CachedLibrary(limit = "3") InteropLibrary lib) {
             if (canBeInt(start, stop, step, lib)) {
-                return doInt(cls, pol.asSize(start), pol.asSize(stop), pol.asSize(step), stepZeroProfile, exceptionProfile, lenOfRangeNode, createBigRangeNode);
+                return doInt(cls, pol.asSize(start), pol.asSize(stop), pol.asSize(step), stepZeroProfile, exceptionProfile, lenOfRangeNodeExact, createBigRangeNode);
             } else if (canBePint(start, stop, step, pol)) {
                 return createBigRangeNode.execute(start, stop, step, factory());
             } else {
@@ -1748,7 +1750,7 @@ Object doGeneric(@SuppressWarnings("unused") Object cls, Object start, Object st
                 Object lstep = pol.asIndex(step);
 
                 if (canBeInt(start, stop, step, lib)) {
-                    return doInt(cls, pol.asSize(start), pol.asSize(stop), pol.asSize(step), stepZeroProfile, exceptionProfile, lenOfRangeNode, createBigRangeNode);
+                    return doInt(cls, pol.asSize(start), pol.asSize(stop), pol.asSize(step), stepZeroProfile, exceptionProfile, lenOfRangeNodeExact, createBigRangeNode);
                 } else {
                     return createBigRangeNode.execute(lstart, lstop, lstep, factory());
                 }

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

@@ -125,10 +125,10 @@
 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;
-import com.oracle.graal.python.runtime.exception.PythonErrorType;
 import com.oracle.graal.python.runtime.object.PythonObjectFactory;
 import com.oracle.graal.python.runtime.sequence.PSequence;
 import com.oracle.graal.python.runtime.sequence.storage.BasicSequenceStorage;
@@ -2301,8 +2301,8 @@ public ExtendNode(GenNodeSupplier genNodeProvider) {
 
         private static int lengthResult(int current, int ext) {
             try {
-                return Math.addExact(current, ext);
-            } catch (ArithmeticException e) {
+                return ExactMath.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.
                 return current;
@@ -2314,9 +2314,7 @@ SequenceStorage doWithStorage(SequenceStorage left, PSequence seq, int len,
                         @SuppressWarnings("unused") @CachedLibrary(limit = "3") PythonObjectLibrary lib,
                         @Cached GetSequenceStorageNode getStorageNode,
                         @Cached LenNode lenNode,
-                        @Cached PRaiseNode raiseNode,
                         @Cached EnsureCapacityNode ensureCapacityNode,
-                        @Cached BranchProfile overflowErrorProfile,
                         @Cached ConcatBaseNode concatStoragesNode) {
             SequenceStorage right = getStorageNode.execute(seq);
             int lenLeft = lenNode.execute(left);
@@ -2328,15 +2326,13 @@ SequenceStorage doWithStorage(SequenceStorage left, PSequence seq, int len,
             }
             SequenceStorage dest = null;
             try {
+                // EnsureCapacityNode handles the overflow and raises an error
                 dest = ensureCapacityNode.execute(left, lenResult);
                 return concatStoragesNode.execute(dest, left, right);
             } catch (SequenceStoreException e) {
                 dest = generalizeStore(dest, e.getIndicationValue());
                 dest = ensureCapacityNode.execute(dest, lenResult);
                 return concatStoragesNode.execute(dest, left, right);
-            } catch (ArithmeticException e) {
-                overflowErrorProfile.enter();
-                throw raiseNode.raise(PythonErrorType.OverflowError);
             }
         }