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

*** 23,33 ****
--- 23,32 ----
  package org.graalvm.compiler.nodes.calc;
  
  import org.graalvm.compiler.core.common.type.AbstractPointerStamp;
  import org.graalvm.compiler.core.common.type.ObjectStamp;
  import org.graalvm.compiler.core.common.type.Stamp;
  import org.graalvm.compiler.core.common.type.StampFactory;
  import org.graalvm.compiler.graph.NodeClass;
  import org.graalvm.compiler.graph.spi.CanonicalizerTool;
  import org.graalvm.compiler.nodeinfo.NodeCycles;
  import org.graalvm.compiler.nodeinfo.NodeInfo;
  import org.graalvm.compiler.nodes.LogicConstantNode;

*** 35,67 ****
--- 34,66 ----
  import org.graalvm.compiler.nodes.PiNode;
  import org.graalvm.compiler.nodes.UnaryOpLogicNode;
  import org.graalvm.compiler.nodes.ValueNode;
  import org.graalvm.compiler.nodes.spi.LIRLowerable;
  import org.graalvm.compiler.nodes.spi.NodeLIRBuilderTool;
  import org.graalvm.compiler.nodes.spi.PiPushable;
  import org.graalvm.compiler.nodes.spi.Virtualizable;
  import org.graalvm.compiler.nodes.spi.VirtualizerTool;
  import org.graalvm.compiler.nodes.type.StampTool;
+ import org.graalvm.compiler.nodes.util.GraphUtil;
  
  import jdk.vm.ci.meta.TriState;
  
  /**
   * An IsNullNode will be true if the supplied value is null, and false if it is non-null.
   */
  @NodeInfo(cycles = NodeCycles.CYCLES_2)
- public final class IsNullNode extends UnaryOpLogicNode implements LIRLowerable, Virtualizable, PiPushable {
  
      public static final NodeClass<IsNullNode> TYPE = NodeClass.create(IsNullNode.class);
  
      public IsNullNode(ValueNode object) {
          super(TYPE, object);
          assert object != null;
      }
  
      public static LogicNode create(ValueNode forValue) {
          LogicNode result = tryCanonicalize(forValue);
!         return result == null ? new IsNullNode(GraphUtil.skipPi(forValue)) : result;
      }
  
      public static LogicNode tryCanonicalize(ValueNode forValue) {
          if (StampTool.isPointerAlwaysNull(forValue)) {
              return LogicConstantNode.tautology();

*** 83,94 ****
--- 82,109 ----
          return super.verify();
      }
  
      @Override
      public ValueNode canonical(CanonicalizerTool tool, ValueNode forValue) {
+ 
          LogicNode result = tryCanonicalize(forValue);
          return result == null ? this : result;
+         if (result != null) {
+             return result;
+         }
+ 
+         if (forValue instanceof PiNode) {
+             return IsNullNode.create(GraphUtil.skipPi(forValue));
+         }
+ 
+         if (forValue instanceof ConvertNode) {
+             ConvertNode convertNode = (ConvertNode) forValue;
+             if (convertNode.mayNullCheckSkipConversion()) {
+                 return IsNullNode.create(convertNode.getValue());
+             }
+         }
+ 
+         return this;
      }
  
      @Override
      public void virtualize(VirtualizerTool tool) {
          ValueNode alias = tool.getAlias(getValue());

*** 97,124 ****
--- 112,124 ----
              tool.replaceWithValue(LogicConstantNode.forBoolean(fold.isTrue(), graph()));
          }
      }
  
      @Override
      public boolean push(PiNode parent) {
          if (parent.stamp() instanceof ObjectStamp && parent.object().stamp() instanceof ObjectStamp) {
              ObjectStamp piStamp = (ObjectStamp) parent.stamp();
              ObjectStamp piValueStamp = (ObjectStamp) parent.object().stamp();
              if (piStamp.nonNull() == piValueStamp.nonNull() && piStamp.alwaysNull() == piValueStamp.alwaysNull()) {
                  replaceFirstInput(parent, parent.object());
                  return true;
              }
          }
          return false;
      }
  
      @NodeIntrinsic
      public static native IsNullNode isNull(Object object);
  
      @Override
      public Stamp getSucceedingStampForValue(boolean negated) {
!         return negated ? getValue().stamp().join(StampFactory.objectNonNull()) : StampFactory.alwaysNull();
!         AbstractPointerStamp pointerStamp = (AbstractPointerStamp) getValue().stamp();
+         return negated ? pointerStamp.asNonNull() : pointerStamp.asAlwaysNull();
      }
  
      @Override
      public TriState tryFold(Stamp valueStamp) {
          if (valueStamp instanceof ObjectStamp) {