src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/calc/IntegerEqualsNode.java
changeset 48861 47f19ff9903c
parent 48190 25cfedf27edc
child 50858 2d3e99a72541
equal deleted inserted replaced
48860:5bce1b7e7800 48861:47f19ff9903c
    20  * or visit www.oracle.com if you need additional information or have any
    20  * or visit www.oracle.com if you need additional information or have any
    21  * questions.
    21  * questions.
    22  */
    22  */
    23 package org.graalvm.compiler.nodes.calc;
    23 package org.graalvm.compiler.nodes.calc;
    24 
    24 
    25 import jdk.vm.ci.meta.ConstantReflectionProvider;
    25 import org.graalvm.compiler.core.common.calc.CanonicalCondition;
    26 import jdk.vm.ci.meta.MetaAccessProvider;
       
    27 import org.graalvm.compiler.core.common.calc.Condition;
       
    28 import org.graalvm.compiler.core.common.type.AbstractPointerStamp;
    26 import org.graalvm.compiler.core.common.type.AbstractPointerStamp;
    29 import org.graalvm.compiler.core.common.type.FloatStamp;
    27 import org.graalvm.compiler.core.common.type.FloatStamp;
    30 import org.graalvm.compiler.core.common.type.IntegerStamp;
    28 import org.graalvm.compiler.core.common.type.IntegerStamp;
    31 import org.graalvm.compiler.core.common.type.Stamp;
    29 import org.graalvm.compiler.core.common.type.Stamp;
    32 import org.graalvm.compiler.debug.GraalError;
    30 import org.graalvm.compiler.debug.GraalError;
    40 import org.graalvm.compiler.nodes.LogicNegationNode;
    38 import org.graalvm.compiler.nodes.LogicNegationNode;
    41 import org.graalvm.compiler.nodes.LogicNode;
    39 import org.graalvm.compiler.nodes.LogicNode;
    42 import org.graalvm.compiler.nodes.NodeView;
    40 import org.graalvm.compiler.nodes.NodeView;
    43 import org.graalvm.compiler.nodes.ValueNode;
    41 import org.graalvm.compiler.nodes.ValueNode;
    44 import org.graalvm.compiler.nodes.util.GraphUtil;
    42 import org.graalvm.compiler.nodes.util.GraphUtil;
       
    43 import org.graalvm.compiler.options.OptionValues;
    45 
    44 
    46 import jdk.vm.ci.meta.Constant;
    45 import jdk.vm.ci.meta.Constant;
       
    46 import jdk.vm.ci.meta.ConstantReflectionProvider;
    47 import jdk.vm.ci.meta.JavaKind;
    47 import jdk.vm.ci.meta.JavaKind;
       
    48 import jdk.vm.ci.meta.MetaAccessProvider;
    48 import jdk.vm.ci.meta.PrimitiveConstant;
    49 import jdk.vm.ci.meta.PrimitiveConstant;
    49 import jdk.vm.ci.meta.TriState;
    50 import jdk.vm.ci.meta.TriState;
    50 import org.graalvm.compiler.options.OptionValues;
       
    51 
    51 
    52 @NodeInfo(shortName = "==")
    52 @NodeInfo(shortName = "==")
    53 public final class IntegerEqualsNode extends CompareNode implements BinaryCommutative<ValueNode> {
    53 public final class IntegerEqualsNode extends CompareNode implements BinaryCommutative<ValueNode> {
    54     public static final NodeClass<IntegerEqualsNode> TYPE = NodeClass.create(IntegerEqualsNode.class);
    54     public static final NodeClass<IntegerEqualsNode> TYPE = NodeClass.create(IntegerEqualsNode.class);
    55     private static final IntegerEqualsOp OP = new IntegerEqualsOp();
    55     private static final IntegerEqualsOp OP = new IntegerEqualsOp();
    56 
    56 
    57     public IntegerEqualsNode(ValueNode x, ValueNode y) {
    57     public IntegerEqualsNode(ValueNode x, ValueNode y) {
    58         super(TYPE, Condition.EQ, false, x, y);
    58         super(TYPE, CanonicalCondition.EQ, false, x, y);
    59         assert !x.getStackKind().isNumericFloat() && x.getStackKind() != JavaKind.Object;
    59         assert !x.getStackKind().isNumericFloat() && x.getStackKind() != JavaKind.Object;
    60         assert !y.getStackKind().isNumericFloat() && y.getStackKind() != JavaKind.Object;
    60         assert !y.getStackKind().isNumericFloat() && y.getStackKind() != JavaKind.Object;
    61     }
    61     }
    62 
    62 
    63     public static LogicNode create(ValueNode x, ValueNode y, NodeView view) {
    63     public static LogicNode create(ValueNode x, ValueNode y, NodeView view) {
    64         LogicNode result = CompareNode.tryConstantFoldPrimitive(Condition.EQ, x, y, false, view);
    64         LogicNode result = CompareNode.tryConstantFoldPrimitive(CanonicalCondition.EQ, x, y, false, view);
    65         if (result != null) {
    65         if (result != null) {
    66             return result;
    66             return result;
    67         }
    67         }
    68         if (x instanceof ConditionalNode) {
    68         if (x instanceof ConditionalNode) {
    69             ConditionalNode conditionalNode = (ConditionalNode) x;
    69             ConditionalNode conditionalNode = (ConditionalNode) x;
    85         return new IntegerEqualsNode(x, y).maybeCommuteInputs();
    85         return new IntegerEqualsNode(x, y).maybeCommuteInputs();
    86     }
    86     }
    87 
    87 
    88     public static LogicNode create(ConstantReflectionProvider constantReflection, MetaAccessProvider metaAccess, OptionValues options, Integer smallestCompareWidth, ValueNode x, ValueNode y,
    88     public static LogicNode create(ConstantReflectionProvider constantReflection, MetaAccessProvider metaAccess, OptionValues options, Integer smallestCompareWidth, ValueNode x, ValueNode y,
    89                     NodeView view) {
    89                     NodeView view) {
    90         LogicNode value = OP.canonical(constantReflection, metaAccess, options, smallestCompareWidth, Condition.EQ, false, x, y, view);
    90         LogicNode value = OP.canonical(constantReflection, metaAccess, options, smallestCompareWidth, CanonicalCondition.EQ, false, x, y, view);
    91         if (value != null) {
    91         if (value != null) {
    92             return value;
    92             return value;
    93         }
    93         }
    94         return create(x, y, view);
    94         return create(x, y, view);
    95     }
    95     }
    96 
    96 
    97     @Override
    97     @Override
    98     public Node canonical(CanonicalizerTool tool, ValueNode forX, ValueNode forY) {
    98     public Node canonical(CanonicalizerTool tool, ValueNode forX, ValueNode forY) {
    99         NodeView view = NodeView.from(tool);
    99         NodeView view = NodeView.from(tool);
   100         ValueNode value = OP.canonical(tool.getConstantReflection(), tool.getMetaAccess(), tool.getOptions(), tool.smallestCompareWidth(), Condition.EQ, false, forX, forY, view);
   100         ValueNode value = OP.canonical(tool.getConstantReflection(), tool.getMetaAccess(), tool.getOptions(), tool.smallestCompareWidth(), CanonicalCondition.EQ, false, forX, forY, view);
   101         if (value != null) {
   101         if (value != null) {
   102             return value;
   102             return value;
   103         }
   103         }
   104         return this;
   104         return this;
   105     }
   105     }
   147             }
   147             }
   148             throw GraalError.shouldNotReachHere();
   148             throw GraalError.shouldNotReachHere();
   149         }
   149         }
   150 
   150 
   151         @Override
   151         @Override
   152         public LogicNode canonical(ConstantReflectionProvider constantReflection, MetaAccessProvider metaAccess, OptionValues options, Integer smallestCompareWidth, Condition condition,
   152         public LogicNode canonical(ConstantReflectionProvider constantReflection, MetaAccessProvider metaAccess, OptionValues options, Integer smallestCompareWidth, CanonicalCondition condition,
   153                         boolean unorderedIsTrue, ValueNode forX, ValueNode forY, NodeView view) {
   153                         boolean unorderedIsTrue, ValueNode forX, ValueNode forY, NodeView view) {
   154             if (GraphUtil.unproxify(forX) == GraphUtil.unproxify(forY)) {
   154             if (GraphUtil.unproxify(forX) == GraphUtil.unproxify(forY)) {
   155                 return LogicConstantNode.tautology();
   155                 return LogicConstantNode.tautology();
   156             } else if (forX.stamp(view).alwaysDistinct(forY.stamp(view))) {
   156             } else if (forX.stamp(view).alwaysDistinct(forY.stamp(view))) {
   157                 return LogicConstantNode.contradiction();
   157                 return LogicConstantNode.contradiction();
   184             return super.canonical(constantReflection, metaAccess, options, smallestCompareWidth, condition, unorderedIsTrue, forX, forY, view);
   184             return super.canonical(constantReflection, metaAccess, options, smallestCompareWidth, condition, unorderedIsTrue, forX, forY, view);
   185         }
   185         }
   186 
   186 
   187         @Override
   187         @Override
   188         protected LogicNode canonicalizeSymmetricConstant(ConstantReflectionProvider constantReflection, MetaAccessProvider metaAccess, OptionValues options, Integer smallestCompareWidth,
   188         protected LogicNode canonicalizeSymmetricConstant(ConstantReflectionProvider constantReflection, MetaAccessProvider metaAccess, OptionValues options, Integer smallestCompareWidth,
   189                         Condition condition, Constant constant, ValueNode nonConstant, boolean mirrored, boolean unorderedIsTrue, NodeView view) {
   189                         CanonicalCondition condition, Constant constant, ValueNode nonConstant, boolean mirrored, boolean unorderedIsTrue, NodeView view) {
   190             if (constant instanceof PrimitiveConstant) {
   190             if (constant instanceof PrimitiveConstant) {
   191                 PrimitiveConstant primitiveConstant = (PrimitiveConstant) constant;
   191                 PrimitiveConstant primitiveConstant = (PrimitiveConstant) constant;
   192                 IntegerStamp nonConstantStamp = ((IntegerStamp) nonConstant.stamp(view));
   192                 IntegerStamp nonConstantStamp = ((IntegerStamp) nonConstant.stamp(view));
   193                 if ((primitiveConstant.asLong() == 1 && nonConstantStamp.upperBound() == 1 && nonConstantStamp.lowerBound() == 0) ||
   193                 if ((primitiveConstant.asLong() == 1 && nonConstantStamp.upperBound() == 1 && nonConstantStamp.lowerBound() == 0) ||
   194                                 (primitiveConstant.asLong() == -1 && nonConstantStamp.upperBound() == 0 && nonConstantStamp.lowerBound() == -1)) {
   194                                 (primitiveConstant.asLong() == -1 && nonConstantStamp.upperBound() == 0 && nonConstantStamp.lowerBound() == -1)) {