[GR-51581] Backport to 24.0.0: Compilation fails with java.lang.Arith…

…meticException: / by zero in LoopSafepointEliminationPhase::loopIsIn32BitRange. PullRequest: graal/16704
oracle · Jan 24, 2024 · 7141c12 · 7141c12
2 parents bca99e0 + f1444ca
commit 7141c12
Show file tree

Hide file tree

Showing 3 changed files with 105 additions and 41 deletions.
diff --git a/...k.graal.compiler/src/jdk/graal/compiler/nodes/loop/DerivedConvertedInductionVariable.java b/...k.graal.compiler/src/jdk/graal/compiler/nodes/loop/DerivedConvertedInductionVariable.java
@@ -81,6 +81,16 @@ public long constantStride() {
         return base.constantStride();
     }
 
+    @Override
+    public boolean isConstantExtremum() {
+        return base.isConstantExtremum();
+    }
+
+    @Override
+    public long constantExtremum() {
+        return base.constantExtremum();
+    }
+
     @Override
     public ValueNode extremumNode(boolean assumeLoopEntered, Stamp s) {
         // base.extremumNode will already perform any necessary conversion operation based on the
@@ -102,16 +112,6 @@ public ValueNode exitValueNode() {
         return op(base.exitValueNode(), true);
     }
 
-    @Override
-    public boolean isConstantExtremum() {
-        return base.isConstantExtremum();
-    }
-
-    @Override
-    public long constantExtremum() {
-        return base.constantExtremum();
-    }
-
     @Override
     public void deleteUnusedNodes() {
     }

diff --git a/.../jdk.graal.compiler/src/jdk/graal/compiler/nodes/loop/DerivedOffsetInductionVariable.java b/.../jdk.graal.compiler/src/jdk/graal/compiler/nodes/loop/DerivedOffsetInductionVariable.java
@@ -69,7 +69,15 @@ public ValueNode valueNode() {
 
     @Override
     public boolean isConstantInit() {
-        return offset.isConstant() && base.isConstantInit();
+        try {
+            if (offset.isConstant() && base.isConstantInit()) {
+                constantInitSafe();
+                return true;
+            }
+        } catch (ArithmeticException e) {
+            // fall through to return false
+        }
+        return false;
     }
 
     @Override
@@ -79,17 +87,47 @@ public boolean isConstantStride() {
 
     @Override
     public long constantInit() {
-        return op(base.constantInit(), offset.asJavaConstant().asLong());
+        return constantInitSafe();
+    }
+
+    private long constantInitSafe() throws ArithmeticException {
+        return opSafe(base.constantInit(), offset.asJavaConstant().asLong());
     }
 
     @Override
     public long constantStride() {
+        return constantStrideSafe();
+    }
+
+    private long constantStrideSafe() throws ArithmeticException {
         if (value instanceof SubNode && base.valueNode() == value.getY()) {
-            return -base.constantStride();
+            return Math.multiplyExact(base.constantStride(), -1);
         }
         return base.constantStride();
     }
 
+    @Override
+    public boolean isConstantExtremum() {
+        try {
+            if (offset.isConstant() && base.isConstantExtremum()) {
+                constantExtremumSafe();
+                return true;
+            }
+        } catch (ArithmeticException e) {
+            // fall through to return false
+        }
+        return false;
+    }
+
+    @Override
+    public long constantExtremum() {
+        return constantExtremumSafe();
+    }
+
+    private long constantExtremumSafe() throws ArithmeticException {
+        return opSafe(base.constantExtremum(), offset.asJavaConstant().asLong());
+    }
+
     @Override
     public ValueNode initNode() {
         return op(base.initNode(), offset);
@@ -118,26 +156,16 @@ public ValueNode exitValueNode() {
         return op(base.exitValueNode(), offset);
     }
 
-    @Override
-    public boolean isConstantExtremum() {
-        return offset.isConstant() && base.isConstantExtremum();
-    }
-
-    @Override
-    public long constantExtremum() {
-        return op(base.constantExtremum(), offset.asJavaConstant().asLong());
-    }
-
-    private long op(long b, long o) {
+    private long opSafe(long b, long o) throws ArithmeticException {
         if (value instanceof AddNode) {
-            return b + o;
+            return Math.addExact(b, o);
         }
         if (value instanceof SubNode) {
             if (base.valueNode() == value.getX()) {
-                return b - o;
+                return Math.subtractExact(b, o);
             } else {
                 assert base.valueNode() == value.getY() : Assertions.errorMessage(base, base.valueNode(), value, value.getY());
-                return o - b;
+                return Math.subtractExact(b, o);
             }
         }
         throw GraalError.shouldNotReachHereUnexpectedValue(value); // ExcludeFromJacocoGeneratedReport

diff --git a/.../jdk.graal.compiler/src/jdk/graal/compiler/nodes/loop/DerivedScaledInductionVariable.java b/.../jdk.graal.compiler/src/jdk/graal/compiler/nodes/loop/DerivedScaledInductionVariable.java
@@ -91,47 +91,83 @@ public ValueNode strideNode() {
 
     @Override
     public boolean isConstantInit() {
-        return scale.isConstant() && base.isConstantInit();
+        try {
+            if (scale.isConstant() && base.isConstantInit()) {
+                constantInitSafe();
+                return true;
+            }
+        } catch (ArithmeticException e) {
+            // fall through to return false
+        }
+        return false;
     }
 
     @Override
     public boolean isConstantStride() {
-        return scale.isConstant() && base.isConstantStride();
+        try {
+            if (scale.isConstant() && base.isConstantStride()) {
+                constantStrideSafe();
+                return true;
+            }
+        } catch (ArithmeticException e) {
+            // fall through to return false
+        }
+        return false;
     }
 
     @Override
     public long constantInit() {
-        return base.constantInit() * scale.asJavaConstant().asLong();
+        return constantInitSafe();
+    }
+
+    private long constantInitSafe() throws ArithmeticException {
+        return Math.multiplyExact(base.constantInit(), scale.asJavaConstant().asLong());
     }
 
     @Override
     public long constantStride() {
-        return base.constantStride() * scale.asJavaConstant().asLong();
+        return constantStrideSafe();
+    }
+
+    private long constantStrideSafe() throws ArithmeticException {
+        return Math.multiplyExact(base.constantStride(), scale.asJavaConstant().asLong());
     }
 
     @Override
-    public ValueNode extremumNode(boolean assumeLoopEntered, Stamp stamp) {
-        return mul(graph(), base.extremumNode(assumeLoopEntered, stamp), IntegerConvertNode.convert(scale, stamp, graph(), NodeView.DEFAULT));
+    public boolean isConstantExtremum() {
+        try {
+            if (scale.isConstant() && base.isConstantExtremum()) {
+                constantExtremumSafe();
+                return true;
+            }
+        } catch (ArithmeticException e) {
+            // fall through to return false
+        }
+        return false;
     }
 
     @Override
-    public ValueNode extremumNode(boolean assumeLoopEntered, Stamp stamp, ValueNode maxTripCount) {
-        return mul(graph(), base.extremumNode(assumeLoopEntered, stamp, maxTripCount), IntegerConvertNode.convert(scale, stamp, graph(), NodeView.DEFAULT));
+    public long constantExtremum() {
+        return constantExtremumSafe();
+    }
+
+    private long constantExtremumSafe() throws ArithmeticException {
+        return Math.multiplyExact(base.constantExtremum(), scale.asJavaConstant().asLong());
     }
 
     @Override
-    public ValueNode exitValueNode() {
-        return mul(graph(), base.exitValueNode(), scale);
+    public ValueNode extremumNode(boolean assumeLoopEntered, Stamp stamp) {
+        return mul(graph(), base.extremumNode(assumeLoopEntered, stamp), IntegerConvertNode.convert(scale, stamp, graph(), NodeView.DEFAULT));
     }
 
     @Override
-    public boolean isConstantExtremum() {
-        return scale.isConstant() && base.isConstantExtremum();
+    public ValueNode extremumNode(boolean assumeLoopEntered, Stamp stamp, ValueNode maxTripCount) {
+        return mul(graph(), base.extremumNode(assumeLoopEntered, stamp, maxTripCount), IntegerConvertNode.convert(scale, stamp, graph(), NodeView.DEFAULT));
     }
 
     @Override
-    public long constantExtremum() {
-        return base.constantExtremum() * scale.asJavaConstant().asLong();
+    public ValueNode exitValueNode() {
+        return mul(graph(), base.exitValueNode(), scale);
     }
 
     @Override