src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.replacements/src/org/graalvm/compiler/replacements/nodes/arithmetic/IntegerMulExactNode.java

*** 1,7 ****
  /*
!  * Copyright (c) 2013, 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.
--- 1,7 ----
  /*
!  * Copyright (c) 2013, 2019, 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.
*** 30,67 ****
  import org.graalvm.compiler.core.common.type.IntegerStamp;
  import org.graalvm.compiler.graph.NodeClass;
  import org.graalvm.compiler.graph.spi.CanonicalizerTool;
  import org.graalvm.compiler.nodeinfo.InputType;
  import org.graalvm.compiler.nodeinfo.NodeInfo;
- import org.graalvm.compiler.nodes.AbstractBeginNode;
  import org.graalvm.compiler.nodes.ConstantNode;
  import org.graalvm.compiler.nodes.NodeView;
  import org.graalvm.compiler.nodes.ValueNode;
  import org.graalvm.compiler.nodes.calc.MulNode;
! import org.graalvm.compiler.nodes.extended.AnchoringNode;
! import org.graalvm.compiler.nodes.spi.LoweringTool;
  
  import jdk.vm.ci.meta.JavaConstant;
  import jdk.vm.ci.meta.JavaKind;
- import jdk.vm.ci.meta.SpeculationLog.SpeculationReason;
  
  /**
   * Node representing an exact integer multiplication that will throw an {@link ArithmeticException}
   * in case the addition would overflow the 32 bit range.
   */
  @NodeInfo(cycles = CYCLES_4, cyclesRationale = "mul+cmp", size = SIZE_2)
! public final class IntegerMulExactNode extends MulNode implements IntegerExactArithmeticNode {
      public static final NodeClass<IntegerMulExactNode> TYPE = NodeClass.create(IntegerMulExactNode.class);
  
!     @OptionalInput(InputType.Anchor) protected AnchoringNode anchor;
!     protected final SpeculationReason speculation;
  
!     public IntegerMulExactNode(ValueNode x, ValueNode y, SpeculationReason speculation) {
          super(TYPE, x, y);
          setStamp(x.stamp(NodeView.DEFAULT).unrestricted());
          assert x.stamp(NodeView.DEFAULT).isCompatible(y.stamp(NodeView.DEFAULT)) && x.stamp(NodeView.DEFAULT) instanceof IntegerStamp;
!         this.speculation = speculation;
      }
  
      @Override
      public boolean inferStamp() {
          /*
--- 30,64 ----
  import org.graalvm.compiler.core.common.type.IntegerStamp;
  import org.graalvm.compiler.graph.NodeClass;
  import org.graalvm.compiler.graph.spi.CanonicalizerTool;
  import org.graalvm.compiler.nodeinfo.InputType;
  import org.graalvm.compiler.nodeinfo.NodeInfo;
  import org.graalvm.compiler.nodes.ConstantNode;
  import org.graalvm.compiler.nodes.NodeView;
  import org.graalvm.compiler.nodes.ValueNode;
  import org.graalvm.compiler.nodes.calc.MulNode;
! import org.graalvm.compiler.nodes.extended.GuardedNode;
! import org.graalvm.compiler.nodes.extended.GuardingNode;
  
  import jdk.vm.ci.meta.JavaConstant;
  import jdk.vm.ci.meta.JavaKind;
  
  /**
   * Node representing an exact integer multiplication that will throw an {@link ArithmeticException}
   * in case the addition would overflow the 32 bit range.
   */
  @NodeInfo(cycles = CYCLES_4, cyclesRationale = "mul+cmp", size = SIZE_2)
! public final class IntegerMulExactNode extends MulNode implements GuardedNode, IntegerExactArithmeticNode {
      public static final NodeClass<IntegerMulExactNode> TYPE = NodeClass.create(IntegerMulExactNode.class);
  
!     @Input(InputType.Guard) protected GuardingNode guard;
  
!     public IntegerMulExactNode(ValueNode x, ValueNode y, GuardingNode guard) {
          super(TYPE, x, y);
          setStamp(x.stamp(NodeView.DEFAULT).unrestricted());
          assert x.stamp(NodeView.DEFAULT).isCompatible(y.stamp(NodeView.DEFAULT)) && x.stamp(NodeView.DEFAULT) instanceof IntegerStamp;
!         this.guard = guard;
      }
  
      @Override
      public boolean inferStamp() {
          /*
*** 74,87 ****
      }
  
      @Override
      public ValueNode canonical(CanonicalizerTool tool, ValueNode forX, ValueNode forY) {
          if (forX.isConstant() && !forY.isConstant()) {
!             return new IntegerMulExactNode(forY, forX, speculation).canonical(tool);
          }
!         if (forX.isConstant()) {
!             return canonicalXconstant(forX, forY);
          } else if (forY.isConstant()) {
              long c = forY.asJavaConstant().asLong();
              if (c == 1) {
                  return forX;
              }
--- 71,84 ----
      }
  
      @Override
      public ValueNode canonical(CanonicalizerTool tool, ValueNode forX, ValueNode forY) {
          if (forX.isConstant() && !forY.isConstant()) {
!             return new IntegerMulExactNode(forY, forX, guard).canonical(tool);
          }
!         if (forX.isConstant() && forY.isConstant()) {
!             return canonicalXYconstant(forX, forY);
          } else if (forY.isConstant()) {
              long c = forY.asJavaConstant().asLong();
              if (c == 1) {
                  return forX;
              }
*** 93,103 ****
              return new MulNode(x, y).canonical(tool);
          }
          return this;
      }
  
!     private ValueNode canonicalXconstant(ValueNode forX, ValueNode forY) {
          JavaConstant xConst = forX.asJavaConstant();
          JavaConstant yConst = forY.asJavaConstant();
          assert xConst.getJavaKind() == yConst.getJavaKind();
          try {
              if (xConst.getJavaKind() == JavaKind.Int) {
--- 90,100 ----
              return new MulNode(x, y).canonical(tool);
          }
          return this;
      }
  
!     private ValueNode canonicalXYconstant(ValueNode forX, ValueNode forY) {
          JavaConstant xConst = forX.asJavaConstant();
          JavaConstant yConst = forY.asJavaConstant();
          assert xConst.getJavaKind() == yConst.getJavaKind();
          try {
              if (xConst.getJavaKind() == JavaKind.Int) {
*** 111,140 ****
          }
          return this;
      }
  
      @Override
!     public IntegerExactArithmeticSplitNode createSplit(AbstractBeginNode next, AbstractBeginNode deopt) {
!         return graph().add(new IntegerMulExactSplitNode(stamp(NodeView.DEFAULT), getX(), getY(), next, deopt));
      }
  
      @Override
!     public SpeculationReason getSpeculation() {
!         return speculation;
!     }
! 
!     @Override
!     public AnchoringNode getAnchor() {
!         return anchor;
!     }
! 
!     @Override
!     public void setAnchor(AnchoringNode x) {
!         updateUsagesInterface(this.anchor, x);
!         this.anchor = x;
!     }
! 
!     @Override
!     public void lower(LoweringTool tool) {
!         IntegerExactArithmeticSplitNode.lower(tool, this);
      }
  }
--- 108,122 ----
          }
          return this;
      }
  
      @Override
!     public GuardingNode getGuard() {
!         return guard;
      }
  
      @Override
!     public void setGuard(GuardingNode guard) {
!         updateUsagesInterface(this.guard, guard);
!         this.guard = guard;
      }
  }