*** old/src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/calc/IntegerEqualsNode.java	Mon Mar 20 17:40:38 2017
--- new/src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/calc/IntegerEqualsNode.java	Mon Mar 20 17:40:37 2017

*** 26,36 ****
--- 26,35 ----
  import org.graalvm.compiler.core.common.type.AbstractPointerStamp;
  import org.graalvm.compiler.core.common.type.FloatStamp;
  import org.graalvm.compiler.core.common.type.IntegerStamp;
  import org.graalvm.compiler.core.common.type.Stamp;
  import org.graalvm.compiler.debug.GraalError;
  import org.graalvm.compiler.graph.IterableNodeType;
  import org.graalvm.compiler.graph.NodeClass;
  import org.graalvm.compiler.graph.spi.Canonicalizable.BinaryCommutative;
  import org.graalvm.compiler.graph.spi.CanonicalizerTool;
  import org.graalvm.compiler.nodeinfo.NodeInfo;
  import org.graalvm.compiler.nodes.ConstantNode;

*** 45,55 ****
--- 44,54 ----
  import jdk.vm.ci.meta.JavaKind;
  import jdk.vm.ci.meta.PrimitiveConstant;
  import jdk.vm.ci.meta.TriState;
  
  @NodeInfo(shortName = "==")
- public final class IntegerEqualsNode extends CompareNode implements BinaryCommutative<ValueNode>, IterableNodeType {
      public static final NodeClass<IntegerEqualsNode> TYPE = NodeClass.create(IntegerEqualsNode.class);
  
      public IntegerEqualsNode(ValueNode x, ValueNode y) {
          super(TYPE, Condition.EQ, false, x, y);
          assert !x.getStackKind().isNumericFloat() && x.getStackKind() != JavaKind.Object;

*** 121,131 ****
--- 120,139 ----
          return super.canonical(tool, forX, forY);
      }
  
      @Override
      protected ValueNode canonicalizeSymmetricConstant(CanonicalizerTool tool, Constant constant, ValueNode nonConstant, boolean mirrored) {
-         if (constant instanceof PrimitiveConstant && ((PrimitiveConstant) constant).asLong() == 0) {
+             PrimitiveConstant primitiveConstant = (PrimitiveConstant) constant;
+             IntegerStamp nonConstantStamp = ((IntegerStamp) nonConstant.stamp());
+             if ((primitiveConstant.asLong() == 1 && nonConstantStamp.upperBound() == 1 && nonConstantStamp.lowerBound() == 0) ||
+                             (primitiveConstant.asLong() == -1 && nonConstantStamp.upperBound() == 0 && nonConstantStamp.lowerBound() == -1)) {
+                 // nonConstant can only be 0 or 1 (respective -1), test against 0 instead of 1
+                 // (respective -1) for a more canonical graph and also to allow for faster execution
+                 // on specific platforms.
+                 return LogicNegationNode.create(IntegerEqualsNode.create(nonConstant, ConstantNode.forIntegerKind(nonConstant.getStackKind(), 0), null));
+             } else if (primitiveConstant.asLong() == 0) {
                  if (nonConstant instanceof AndNode) {
                      AndNode andNode = (AndNode) nonConstant;
                      return new IntegerTestNode(andNode.getX(), andNode.getY());
                  } else if (nonConstant instanceof SubNode) {
                      SubNode subNode = (SubNode) nonConstant;

*** 168,202 ****
--- 176,216 ----
                              }
                          }
                      }
                  }
              }
+             if (nonConstant instanceof AddNode) {
+                 AddNode addNode = (AddNode) nonConstant;
+                 if (addNode.getY().isJavaConstant()) {
+                     return new IntegerEqualsNode(addNode.getX(), ConstantNode.forIntegerStamp(nonConstantStamp, primitiveConstant.asLong() - addNode.getY().asJavaConstant().asLong()));
+                 }
+             }
              if (nonConstant instanceof AndNode) {
                  /*
                   * a & c == c is the same as a & c != 0, if c is a single bit.
                   */
                  AndNode andNode = (AndNode) nonConstant;
              if (constant instanceof PrimitiveConstant && Long.bitCount(((PrimitiveConstant) constant).asLong()) == 1 && andNode.getY().isConstant() &&
                              andNode.getY().asJavaConstant().equals(constant)) {
+                 if (Long.bitCount(((PrimitiveConstant) constant).asLong()) == 1 && andNode.getY().isConstant() && andNode.getY().asJavaConstant().equals(constant)) {
                      return new LogicNegationNode(new IntegerTestNode(andNode.getX(), andNode.getY()));
                  }
              }
+         }
          return super.canonicalizeSymmetricConstant(tool, constant, nonConstant, mirrored);
      }
  
      @Override
!     public Stamp getSucceedingStampForX(boolean negated, Stamp xStamp, Stamp yStamp) {
          if (!negated) {
!             return getX().stamp().join(getY().stamp());
!             return xStamp.join(yStamp);
          }
          return null;
      }
  
      @Override
!     public Stamp getSucceedingStampForY(boolean negated, Stamp xStamp, Stamp yStamp) {
          if (!negated) {
!             return getX().stamp().join(getY().stamp());
!             return xStamp.join(yStamp);
          }
          return null;
      }
  
      @Override