--- a/src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/calc/CompareNode.java Fri Dec 01 14:19:16 2017 -0500
+++ b/src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/calc/CompareNode.java Fri Dec 01 11:17:45 2017 -0800
@@ -39,6 +39,7 @@
import org.graalvm.compiler.nodes.LogicConstantNode;
import org.graalvm.compiler.nodes.LogicNegationNode;
import org.graalvm.compiler.nodes.LogicNode;
+import org.graalvm.compiler.nodes.NodeView;
import org.graalvm.compiler.nodes.StructuredGraph;
import org.graalvm.compiler.nodes.ValueNode;
@@ -91,7 +92,8 @@
return null;
}
- public static LogicNode tryConstantFoldPrimitive(Condition condition, ValueNode forX, ValueNode forY, boolean unorderedIsTrue) {
+ @SuppressWarnings("unused")
+ public static LogicNode tryConstantFoldPrimitive(Condition condition, ValueNode forX, ValueNode forY, boolean unorderedIsTrue, NodeView view) {
if (forX.asConstant() instanceof PrimitiveConstant && forY.asConstant() instanceof PrimitiveConstant) {
return LogicConstantNode.forBoolean(condition.foldCondition((PrimitiveConstant) forX.asConstant(), (PrimitiveConstant) forY.asConstant(), unorderedIsTrue));
}
@@ -110,27 +112,27 @@
public abstract static class CompareOp {
public LogicNode canonical(ConstantReflectionProvider constantReflection, MetaAccessProvider metaAccess, OptionValues options, Integer smallestCompareWidth, Condition condition,
- boolean unorderedIsTrue, ValueNode forX, ValueNode forY) {
+ boolean unorderedIsTrue, ValueNode forX, ValueNode forY, NodeView view) {
LogicNode constantCondition = tryConstantFold(condition, forX, forY, constantReflection, unorderedIsTrue);
if (constantCondition != null) {
return constantCondition;
}
LogicNode result;
if (forX.isConstant()) {
- if ((result = canonicalizeSymmetricConstant(constantReflection, metaAccess, options, smallestCompareWidth, condition, forX.asConstant(), forY, true, unorderedIsTrue)) != null) {
+ if ((result = canonicalizeSymmetricConstant(constantReflection, metaAccess, options, smallestCompareWidth, condition, forX.asConstant(), forY, true, unorderedIsTrue, view)) != null) {
return result;
}
} else if (forY.isConstant()) {
- if ((result = canonicalizeSymmetricConstant(constantReflection, metaAccess, options, smallestCompareWidth, condition, forY.asConstant(), forX, false, unorderedIsTrue)) != null) {
+ if ((result = canonicalizeSymmetricConstant(constantReflection, metaAccess, options, smallestCompareWidth, condition, forY.asConstant(), forX, false, unorderedIsTrue, view)) != null) {
return result;
}
} else if (forX instanceof ConvertNode && forY instanceof ConvertNode) {
ConvertNode convertX = (ConvertNode) forX;
ConvertNode convertY = (ConvertNode) forY;
- if (convertX.preservesOrder(condition) && convertY.preservesOrder(condition) && convertX.getValue().stamp().isCompatible(convertY.getValue().stamp())) {
+ if (convertX.preservesOrder(condition) && convertY.preservesOrder(condition) && convertX.getValue().stamp(view).isCompatible(convertY.getValue().stamp(view))) {
boolean supported = true;
- if (convertX.getValue().stamp() instanceof IntegerStamp) {
- IntegerStamp intStamp = (IntegerStamp) convertX.getValue().stamp();
+ if (convertX.getValue().stamp(view) instanceof IntegerStamp) {
+ IntegerStamp intStamp = (IntegerStamp) convertX.getValue().stamp(view);
supported = smallestCompareWidth != null && intStamp.getBits() >= smallestCompareWidth;
}
@@ -141,7 +143,7 @@
// of the value.
return null;
}
- return duplicateModified(convertX.getValue(), convertY.getValue(), unorderedIsTrue);
+ return duplicateModified(convertX.getValue(), convertY.getValue(), unorderedIsTrue, view);
}
}
}
@@ -149,11 +151,11 @@
}
protected LogicNode canonicalizeSymmetricConstant(ConstantReflectionProvider constantReflection, MetaAccessProvider metaAccess, OptionValues options, Integer smallestCompareWidth,
- Condition condition, Constant constant, ValueNode nonConstant, boolean mirrored, boolean unorderedIsTrue) {
+ Condition condition, Constant constant, ValueNode nonConstant, boolean mirrored, boolean unorderedIsTrue, NodeView view) {
if (nonConstant instanceof ConditionalNode) {
return optimizeConditional(constant, (ConditionalNode) nonConstant, constantReflection, mirrored ? condition.mirror() : condition, unorderedIsTrue);
} else if (nonConstant instanceof NormalizeCompareNode) {
- return optimizeNormalizeCompare(constantReflection, metaAccess, options, smallestCompareWidth, constant, (NormalizeCompareNode) nonConstant, mirrored);
+ return optimizeNormalizeCompare(constantReflection, metaAccess, options, smallestCompareWidth, constant, (NormalizeCompareNode) nonConstant, mirrored, view);
} else if (nonConstant instanceof ConvertNode) {
ConvertNode convert = (ConvertNode) nonConstant;
boolean multiUsage = (convert.asNode().hasMoreThanOneUsage() && convert.getValue().hasExactlyOneUsage());
@@ -164,18 +166,18 @@
}
boolean supported = true;
- if (convert.getValue().stamp() instanceof IntegerStamp) {
- IntegerStamp intStamp = (IntegerStamp) convert.getValue().stamp();
+ if (convert.getValue().stamp(view) instanceof IntegerStamp) {
+ IntegerStamp intStamp = (IntegerStamp) convert.getValue().stamp(view);
supported = smallestCompareWidth != null && intStamp.getBits() > smallestCompareWidth;
}
if (supported) {
- ConstantNode newConstant = canonicalConvertConstant(constantReflection, metaAccess, options, condition, convert, constant);
+ ConstantNode newConstant = canonicalConvertConstant(constantReflection, metaAccess, options, condition, convert, constant, view);
if (newConstant != null) {
if (mirrored) {
- return duplicateModified(newConstant, convert.getValue(), unorderedIsTrue);
+ return duplicateModified(newConstant, convert.getValue(), unorderedIsTrue, view);
} else {
- return duplicateModified(convert.getValue(), newConstant, unorderedIsTrue);
+ return duplicateModified(convert.getValue(), newConstant, unorderedIsTrue, view);
}
}
}
@@ -185,7 +187,7 @@
}
private static ConstantNode canonicalConvertConstant(ConstantReflectionProvider constantReflection, MetaAccessProvider metaAccess, OptionValues options, Condition condition,
- ConvertNode convert, Constant constant) {
+ ConvertNode convert, Constant constant, NodeView view) {
if (convert.preservesOrder(condition, constant, constantReflection)) {
Constant reverseConverted = convert.reverse(constant, constantReflection);
if (reverseConverted != null && convert.convert(reverseConverted, constantReflection).equals(constant)) {
@@ -193,7 +195,7 @@
// We always want uncompressed constants
return null;
}
- return ConstantNode.forConstant(convert.getValue().stamp(), reverseConverted, metaAccess);
+ return ConstantNode.forConstant(convert.getValue().stamp(view), reverseConverted, metaAccess);
}
}
return null;
@@ -201,7 +203,7 @@
@SuppressWarnings("unused")
protected LogicNode optimizeNormalizeCompare(ConstantReflectionProvider constantReflection, MetaAccessProvider metaAccess, OptionValues options, Integer smallestCompareWidth,
- Constant constant, NormalizeCompareNode normalizeNode, boolean mirrored) {
+ Constant constant, NormalizeCompareNode normalizeNode, boolean mirrored, NodeView view) {
throw new GraalError("NormalizeCompareNode connected to %s (%s %s %s)", this, constant, normalizeNode, mirrored);
}
@@ -230,71 +232,71 @@
return null;
}
- protected abstract LogicNode duplicateModified(ValueNode newW, ValueNode newY, boolean unorderedIsTrue);
+ protected abstract LogicNode duplicateModified(ValueNode newW, ValueNode newY, boolean unorderedIsTrue, NodeView view);
}
- public static LogicNode createCompareNode(StructuredGraph graph, Condition condition, ValueNode x, ValueNode y, ConstantReflectionProvider constantReflection) {
- LogicNode result = createCompareNode(condition, x, y, constantReflection);
+ public static LogicNode createCompareNode(StructuredGraph graph, Condition condition, ValueNode x, ValueNode y, ConstantReflectionProvider constantReflection, NodeView view) {
+ LogicNode result = createCompareNode(condition, x, y, constantReflection, view);
return (result.graph() == null ? graph.addOrUniqueWithInputs(result) : result);
}
- public static LogicNode createCompareNode(Condition condition, ValueNode x, ValueNode y, ConstantReflectionProvider constantReflection) {
+ public static LogicNode createCompareNode(Condition condition, ValueNode x, ValueNode y, ConstantReflectionProvider constantReflection, NodeView view) {
assert x.getStackKind() == y.getStackKind();
assert condition.isCanonical();
assert !x.getStackKind().isNumericFloat();
LogicNode comparison;
if (condition == Condition.EQ) {
- if (x.stamp() instanceof AbstractObjectStamp) {
- comparison = ObjectEqualsNode.create(x, y, constantReflection);
- } else if (x.stamp() instanceof AbstractPointerStamp) {
- comparison = PointerEqualsNode.create(x, y);
+ if (x.stamp(view) instanceof AbstractObjectStamp) {
+ comparison = ObjectEqualsNode.create(x, y, constantReflection, view);
+ } else if (x.stamp(view) instanceof AbstractPointerStamp) {
+ comparison = PointerEqualsNode.create(x, y, view);
} else {
assert x.getStackKind().isNumericInteger();
- comparison = IntegerEqualsNode.create(x, y);
+ comparison = IntegerEqualsNode.create(x, y, view);
}
} else if (condition == Condition.LT) {
assert x.getStackKind().isNumericInteger();
- comparison = IntegerLessThanNode.create(x, y);
+ comparison = IntegerLessThanNode.create(x, y, view);
} else {
assert condition == Condition.BT;
assert x.getStackKind().isNumericInteger();
- comparison = IntegerBelowNode.create(x, y);
+ comparison = IntegerBelowNode.create(x, y, view);
}
return comparison;
}
public static LogicNode createCompareNode(StructuredGraph graph, ConstantReflectionProvider constantReflection, MetaAccessProvider metaAccess, OptionValues options, Integer smallestCompareWidth,
- Condition condition, ValueNode x, ValueNode y) {
- LogicNode result = createCompareNode(constantReflection, metaAccess, options, smallestCompareWidth, condition, x, y);
+ Condition condition, ValueNode x, ValueNode y, NodeView view) {
+ LogicNode result = createCompareNode(constantReflection, metaAccess, options, smallestCompareWidth, condition, x, y, view);
return (result.graph() == null ? graph.addOrUniqueWithInputs(result) : result);
}
public static LogicNode createCompareNode(ConstantReflectionProvider constantReflection, MetaAccessProvider metaAccess, OptionValues options, Integer smallestCompareWidth,
- Condition condition, ValueNode x, ValueNode y) {
+ Condition condition, ValueNode x, ValueNode y, NodeView view) {
assert x.getStackKind() == y.getStackKind();
assert condition.isCanonical();
assert !x.getStackKind().isNumericFloat();
LogicNode comparison;
if (condition == Condition.EQ) {
- if (x.stamp() instanceof AbstractObjectStamp) {
+ if (x.stamp(view) instanceof AbstractObjectStamp) {
assert smallestCompareWidth == null;
- comparison = ObjectEqualsNode.create(constantReflection, metaAccess, options, x, y);
- } else if (x.stamp() instanceof AbstractPointerStamp) {
- comparison = PointerEqualsNode.create(x, y);
+ comparison = ObjectEqualsNode.create(constantReflection, metaAccess, options, x, y, view);
+ } else if (x.stamp(view) instanceof AbstractPointerStamp) {
+ comparison = PointerEqualsNode.create(x, y, view);
} else {
assert x.getStackKind().isNumericInteger();
- comparison = IntegerEqualsNode.create(constantReflection, metaAccess, options, smallestCompareWidth, x, y);
+ comparison = IntegerEqualsNode.create(constantReflection, metaAccess, options, smallestCompareWidth, x, y, view);
}
} else if (condition == Condition.LT) {
assert x.getStackKind().isNumericInteger();
- comparison = IntegerLessThanNode.create(constantReflection, metaAccess, options, smallestCompareWidth, x, y);
+ comparison = IntegerLessThanNode.create(constantReflection, metaAccess, options, smallestCompareWidth, x, y, view);
} else {
assert condition == Condition.BT;
assert x.getStackKind().isNumericInteger();
- comparison = IntegerBelowNode.create(constantReflection, metaAccess, options, smallestCompareWidth, x, y);
+ comparison = IntegerBelowNode.create(constantReflection, metaAccess, options, smallestCompareWidth, x, y, view);
}
return comparison;