< prev index next >
src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.replacements/src/org/graalvm/compiler/replacements/nodes/arithmetic/IntegerMulExactNode.java
Print this page
@@ -1,7 +1,7 @@
/*
- * Copyright (c) 2013, 2018, Oracle and/or its affiliates. All rights reserved.
+ * 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,38 +30,35 @@
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 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;
-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 final class IntegerMulExactNode extends MulNode implements GuardedNode, IntegerExactArithmeticNode {
public static final NodeClass<IntegerMulExactNode> TYPE = NodeClass.create(IntegerMulExactNode.class);
- @OptionalInput(InputType.Anchor) protected AnchoringNode anchor;
- protected final SpeculationReason speculation;
+ @Input(InputType.Guard) protected GuardingNode guard;
- public IntegerMulExactNode(ValueNode x, ValueNode y, SpeculationReason speculation) {
+ 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.speculation = speculation;
+ this.guard = guard;
}
@Override
public boolean inferStamp() {
/*
@@ -74,14 +71,14 @@
}
@Override
public ValueNode canonical(CanonicalizerTool tool, ValueNode forX, ValueNode forY) {
if (forX.isConstant() && !forY.isConstant()) {
- return new IntegerMulExactNode(forY, forX, speculation).canonical(tool);
+ return new IntegerMulExactNode(forY, forX, guard).canonical(tool);
}
- if (forX.isConstant()) {
- return canonicalXconstant(forX, forY);
+ if (forX.isConstant() && forY.isConstant()) {
+ return canonicalXYconstant(forX, forY);
} else if (forY.isConstant()) {
long c = forY.asJavaConstant().asLong();
if (c == 1) {
return forX;
}
@@ -93,11 +90,11 @@
return new MulNode(x, y).canonical(tool);
}
return this;
}
- private ValueNode canonicalXconstant(ValueNode forX, ValueNode forY) {
+ 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,30 +108,15 @@
}
return this;
}
@Override
- public IntegerExactArithmeticSplitNode createSplit(AbstractBeginNode next, AbstractBeginNode deopt) {
- return graph().add(new IntegerMulExactSplitNode(stamp(NodeView.DEFAULT), getX(), getY(), next, deopt));
+ public GuardingNode getGuard() {
+ return guard;
}
@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);
+ public void setGuard(GuardingNode guard) {
+ updateUsagesInterface(this.guard, guard);
+ this.guard = guard;
}
}
< prev index next >