src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/calc/IntegerLessThanNode.java

rev 52509 : [mq]: graal2

@@ -1,7 +1,7 @@
 /*
- * Copyright (c) 2011, 2017, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2011, 2018, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.

@@ -45,11 +45,10 @@
 import org.graalvm.compiler.options.OptionValues;
 
 import jdk.vm.ci.code.CodeUtil;
 import jdk.vm.ci.meta.Constant;
 import jdk.vm.ci.meta.ConstantReflectionProvider;
-import jdk.vm.ci.meta.JavaConstant;
 import jdk.vm.ci.meta.JavaKind;
 import jdk.vm.ci.meta.MetaAccessProvider;
 import jdk.vm.ci.meta.PrimitiveConstant;
 
 @NodeInfo(shortName = "<")

@@ -173,11 +172,15 @@
             if (forX.stamp(view) instanceof IntegerStamp && forY.stamp(view) instanceof IntegerStamp) {
                 if (IntegerStamp.sameSign((IntegerStamp) forX.stamp(view), (IntegerStamp) forY.stamp(view))) {
                     return new IntegerBelowNode(forX, forY);
                 }
             }
-            if (forY.isConstant() && forX instanceof SubNode) {
+
+            // Attempt to optimize the case where we can fold a constant from the left side (either
+            // from an add or sub) into the constant on the right side.
+            if (forY.isConstant()) {
+                if (forX instanceof SubNode) {
                 SubNode sub = (SubNode) forX;
                 ValueNode xx = null;
                 ValueNode yy = null;
                 boolean negate = false;
                 if (forY.asConstant().isDefaultForKind()) {

@@ -203,59 +206,38 @@
                             logic = LogicNegationNode.create(logic);
                         }
                         return logic;
                     }
                 }
+                } else if (forX instanceof AddNode) {
+
+                    // (x + xConstant) < forY => x < (forY - xConstant)
+                    AddNode addNode = (AddNode) forX;
+                    if (addNode.getY().isJavaConstant()) {
+                        IntegerStamp xStamp = (IntegerStamp) addNode.getX().stamp(view);
+                        if (!IntegerStamp.addCanOverflow(xStamp, (IntegerStamp) addNode.getY().stamp(view))) {
+                            long minValue = CodeUtil.minValue(xStamp.getBits());
+                            long maxValue = CodeUtil.maxValue(xStamp.getBits());
+                            long yConstant = forY.asJavaConstant().asLong();
+                            long xConstant = addNode.getY().asJavaConstant().asLong();
+                            if (!subtractMayUnderflow(yConstant, xConstant, minValue) && !subtractMayOverflow(yConstant, xConstant, maxValue)) {
+                                long newConstant = yConstant - xConstant;
+                                return IntegerLessThanNode.create(addNode.getX(), ConstantNode.forIntegerStamp(xStamp, newConstant), view);
+                            }
+                        }
+                    }
+
+                }
             }
 
             if (forX.stamp(view) instanceof IntegerStamp) {
                 assert forY.stamp(view) instanceof IntegerStamp;
                 int bits = ((IntegerStamp) forX.stamp(view)).getBits();
                 assert ((IntegerStamp) forY.stamp(view)).getBits() == bits;
-                long min = OP.minValue(bits);
-                long xResidue = 0;
-                ValueNode left = null;
-                JavaConstant leftCst = null;
-                if (forX instanceof AddNode) {
-                    AddNode xAdd = (AddNode) forX;
-                    if (xAdd.getY().isJavaConstant()) {
-                        long xCst = xAdd.getY().asJavaConstant().asLong();
-                        xResidue = xCst - min;
-                        left = xAdd.getX();
-                    }
-                } else if (forX.isJavaConstant()) {
-                    leftCst = forX.asJavaConstant();
-                }
-                if (left != null || leftCst != null) {
-                    long yResidue = 0;
-                    ValueNode right = null;
-                    JavaConstant rightCst = null;
-                    if (forY instanceof AddNode) {
-                        AddNode yAdd = (AddNode) forY;
-                        if (yAdd.getY().isJavaConstant()) {
-                            long yCst = yAdd.getY().asJavaConstant().asLong();
-                            yResidue = yCst - min;
-                            right = yAdd.getX();
-                        }
-                    } else if (forY.isJavaConstant()) {
-                        rightCst = forY.asJavaConstant();
-                    }
-                    if (right != null || rightCst != null) {
-                        if ((xResidue == 0 && left != null) || (yResidue == 0 && right != null)) {
-                            if (left == null) {
-                                left = ConstantNode.forIntegerBits(bits, leftCst.asLong() - min);
-                            } else if (xResidue != 0) {
-                                left = AddNode.create(left, ConstantNode.forIntegerBits(bits, xResidue), view);
-                            }
-                            if (right == null) {
-                                right = ConstantNode.forIntegerBits(bits, rightCst.asLong() - min);
-                            } else if (yResidue != 0) {
-                                right = AddNode.create(right, ConstantNode.forIntegerBits(bits, yResidue), view);
-                            }
-                            return new IntegerBelowNode(left, right);
-                        }
-                    }
+                LogicNode logic = canonicalizeRangeFlip(forX, forY, bits, true, view);
+                if (logic != null) {
+                    return logic;
                 }
             }
             return null;
         }