jdk-sandbox: comparison src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/calc/CompareNode.java

equal deleted inserted replaced

-:5bce1b7e7800
+:47f19ff9903c
 package org.graalvm.compiler.nodes.calc;
 import static org.graalvm.compiler.core.common.GraalOptions.GeneratePIC;
 import static org.graalvm.compiler.nodeinfo.NodeCycles.CYCLES_1;
-import jdk.vm.ci.meta.MetaAccessProvider;
+import org.graalvm.compiler.core.common.calc.CanonicalCondition;
 import org.graalvm.compiler.core.common.calc.Condition;
 import org.graalvm.compiler.core.common.type.AbstractObjectStamp;
 import org.graalvm.compiler.core.common.type.AbstractPointerStamp;
 import org.graalvm.compiler.core.common.type.IntegerStamp;
 import org.graalvm.compiler.debug.GraalError;
 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;
+import org.graalvm.compiler.options.OptionValues;
 import jdk.vm.ci.meta.Constant;
 import jdk.vm.ci.meta.ConstantReflectionProvider;
+import jdk.vm.ci.meta.MetaAccessProvider;
 import jdk.vm.ci.meta.PrimitiveConstant;
-import org.graalvm.compiler.options.OptionValues;
 @NodeInfo(cycles = CYCLES_1)
 public abstract class CompareNode extends BinaryOpLogicNode implements Canonicalizable.Binary<ValueNode> {
 public static final NodeClass<CompareNode> TYPE = NodeClass.create(CompareNode.class);
-protected final Condition condition;
+protected final CanonicalCondition condition;
 protected final boolean unorderedIsTrue;
 /**
 * Constructs a new Compare instruction.
 *
 * @param x the instruction producing the first input to the instruction
 * @param y the instruction that produces the second input to this instruction
 */
-protected CompareNode(NodeClass<? extends CompareNode> c, Condition condition, boolean unorderedIsTrue, ValueNode x, ValueNode y) {
+protected CompareNode(NodeClass<? extends CompareNode> c, CanonicalCondition condition, boolean unorderedIsTrue, ValueNode x, ValueNode y) {
 super(c, x, y);
 this.condition = condition;
 this.unorderedIsTrue = unorderedIsTrue;
 }
 /**
 * Gets the condition (comparison operation) for this instruction.
 *
 * @return the condition
 */
-public final Condition condition() {
+public final CanonicalCondition condition() {
 return condition;
 }
 /**
 * Checks whether unordered inputs mean true or false (only applies to float operations).
 */
 public final boolean unorderedIsTrue() {
 return this.unorderedIsTrue;
 }
-public static LogicNode tryConstantFold(Condition condition, ValueNode forX, ValueNode forY, ConstantReflectionProvider constantReflection, boolean unorderedIsTrue) {
+public static LogicNode tryConstantFold(CanonicalCondition condition, ValueNode forX, ValueNode forY, ConstantReflectionProvider constantReflection, boolean unorderedIsTrue) {
 if (forX.isConstant() && forY.isConstant() && (constantReflection != null || forX.asConstant() instanceof PrimitiveConstant)) {
 return LogicConstantNode.forBoolean(condition.foldCondition(forX.asConstant(), forY.asConstant(), constantReflection, unorderedIsTrue));
 }
 return null;
 }
 @SuppressWarnings("unused")
-public static LogicNode tryConstantFoldPrimitive(Condition condition, ValueNode forX, ValueNode forY, boolean unorderedIsTrue, NodeView view) {
+public static LogicNode tryConstantFoldPrimitive(CanonicalCondition 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));
 }
 return null;
 }
 * thing as y. This is generally true except for some floating point comparisons.
 *
 * @return true for identity comparisons
 */
 public boolean isIdentityComparison() {
-return condition == Condition.EQ;
+return condition == CanonicalCondition.EQ;
 }
 public abstract static class CompareOp {
-public LogicNode canonical(ConstantReflectionProvider constantReflection, MetaAccessProvider metaAccess, OptionValues options, Integer smallestCompareWidth, Condition condition,
+public LogicNode canonical(ConstantReflectionProvider constantReflection, MetaAccessProvider metaAccess, OptionValues options, Integer smallestCompareWidth, CanonicalCondition condition,
 boolean unorderedIsTrue, ValueNode forX, ValueNode forY, NodeView view) {
 LogicNode constantCondition = tryConstantFold(condition, forX, forY, constantReflection, unorderedIsTrue);
 if (constantCondition != null) {
 return constantCondition;
 }
 }
 return null;
 }
 protected LogicNode canonicalizeSymmetricConstant(ConstantReflectionProvider constantReflection, MetaAccessProvider metaAccess, OptionValues options, Integer smallestCompareWidth,
-Condition condition, Constant constant, ValueNode nonConstant, boolean mirrored, boolean unorderedIsTrue, NodeView view) {
+CanonicalCondition 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);
+Condition realCondition = condition.asCondition();
+if (mirrored) {
+realCondition = realCondition.mirror();
+}
+return optimizeConditional(constant, (ConditionalNode) nonConstant, constantReflection, realCondition, unorderedIsTrue);
 } else if (nonConstant instanceof NormalizeCompareNode) {
 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());
 }
 return null;
 }
-private static ConstantNode canonicalConvertConstant(ConstantReflectionProvider constantReflection, MetaAccessProvider metaAccess, OptionValues options, Condition condition,
+private static ConstantNode canonicalConvertConstant(ConstantReflectionProvider constantReflection, MetaAccessProvider metaAccess, OptionValues options, CanonicalCondition condition,
 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)) {
 if (GeneratePIC.getValue(options)) {
 }
 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, NodeView view) {
+public static LogicNode createCompareNode(StructuredGraph graph, CanonicalCondition 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, NodeView view) {
+public static LogicNode createCompareNode(CanonicalCondition 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 (condition == CanonicalCondition.EQ) {
 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, view);
 }
-} else if (condition == Condition.LT) {
+} else if (condition == CanonicalCondition.LT) {
 assert x.getStackKind().isNumericInteger();
 comparison = IntegerLessThanNode.create(x, y, view);
 } else {
-assert condition == Condition.BT;
+assert condition == CanonicalCondition.BT;
 assert x.getStackKind().isNumericInteger();
 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, NodeView view) {
+CanonicalCondition 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, NodeView view) {
+CanonicalCondition 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 (condition == CanonicalCondition.EQ) {
 if (x.stamp(view) instanceof AbstractObjectStamp) {
 assert smallestCompareWidth == null;
 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, view);
 }
-} else if (condition == Condition.LT) {
+} else if (condition == CanonicalCondition.LT) {
 assert x.getStackKind().isNumericInteger();
 comparison = IntegerLessThanNode.create(constantReflection, metaAccess, options, smallestCompareWidth, x, y, view);
 } else {
-assert condition == Condition.BT;
+assert condition == CanonicalCondition.BT;
 assert x.getStackKind().isNumericInteger();
 comparison = IntegerBelowNode.create(constantReflection, metaAccess, options, smallestCompareWidth, x, y, view);
 }
 return comparison;

changeset 48861	47f19ff9903c
parent 48190	25cfedf27edc
child 49451	e06f9607f370