src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/calc/PointerEqualsNode.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.ObjectStamp;
    27 import org.graalvm.compiler.core.common.type.ObjectStamp;
    30 import org.graalvm.compiler.core.common.type.Stamp;
    28 import org.graalvm.compiler.core.common.type.Stamp;
    31 import org.graalvm.compiler.graph.Node;
    29 import org.graalvm.compiler.graph.Node;
    32 import org.graalvm.compiler.graph.NodeClass;
    30 import org.graalvm.compiler.graph.NodeClass;
    39 import org.graalvm.compiler.nodes.ValueNode;
    37 import org.graalvm.compiler.nodes.ValueNode;
    40 import org.graalvm.compiler.nodes.extended.LoadHubNode;
    38 import org.graalvm.compiler.nodes.extended.LoadHubNode;
    41 import org.graalvm.compiler.nodes.extended.LoadMethodNode;
    39 import org.graalvm.compiler.nodes.extended.LoadMethodNode;
    42 import org.graalvm.compiler.nodes.type.StampTool;
    40 import org.graalvm.compiler.nodes.type.StampTool;
    43 import org.graalvm.compiler.nodes.util.GraphUtil;
    41 import org.graalvm.compiler.nodes.util.GraphUtil;
       
    42 import org.graalvm.compiler.options.OptionValues;
    44 
    43 
       
    44 import jdk.vm.ci.meta.ConstantReflectionProvider;
       
    45 import jdk.vm.ci.meta.MetaAccessProvider;
    45 import jdk.vm.ci.meta.ResolvedJavaMethod;
    46 import jdk.vm.ci.meta.ResolvedJavaMethod;
    46 import jdk.vm.ci.meta.ResolvedJavaType;
    47 import jdk.vm.ci.meta.ResolvedJavaType;
    47 import jdk.vm.ci.meta.TriState;
    48 import jdk.vm.ci.meta.TriState;
    48 import org.graalvm.compiler.options.OptionValues;
       
    49 
    49 
    50 @NodeInfo(shortName = "==")
    50 @NodeInfo(shortName = "==")
    51 public class PointerEqualsNode extends CompareNode implements BinaryCommutative<ValueNode> {
    51 public class PointerEqualsNode extends CompareNode implements BinaryCommutative<ValueNode> {
    52 
    52 
    53     public static final NodeClass<PointerEqualsNode> TYPE = NodeClass.create(PointerEqualsNode.class);
    53     public static final NodeClass<PointerEqualsNode> TYPE = NodeClass.create(PointerEqualsNode.class);
    64         }
    64         }
    65         return new PointerEqualsNode(x, y);
    65         return new PointerEqualsNode(x, y);
    66     }
    66     }
    67 
    67 
    68     protected PointerEqualsNode(NodeClass<? extends PointerEqualsNode> c, ValueNode x, ValueNode y) {
    68     protected PointerEqualsNode(NodeClass<? extends PointerEqualsNode> c, ValueNode x, ValueNode y) {
    69         super(c, Condition.EQ, false, x, y);
    69         super(c, CanonicalCondition.EQ, false, x, y);
    70         assert x.stamp(NodeView.DEFAULT) instanceof AbstractPointerStamp;
    70         assert x.stamp(NodeView.DEFAULT) instanceof AbstractPointerStamp;
    71         assert y.stamp(NodeView.DEFAULT) instanceof AbstractPointerStamp;
    71         assert y.stamp(NodeView.DEFAULT) instanceof AbstractPointerStamp;
    72     }
    72     }
    73 
    73 
    74     @Override
    74     @Override
    75     public Node canonical(CanonicalizerTool tool, ValueNode forX, ValueNode forY) {
    75     public Node canonical(CanonicalizerTool tool, ValueNode forX, ValueNode forY) {
    76         NodeView view = NodeView.from(tool);
    76         NodeView view = NodeView.from(tool);
    77         ValueNode value = OP.canonical(tool.getConstantReflection(), tool.getMetaAccess(), tool.getOptions(), tool.smallestCompareWidth(), Condition.EQ, false, forX, forY, view);
    77         ValueNode value = OP.canonical(tool.getConstantReflection(), tool.getMetaAccess(), tool.getOptions(), tool.smallestCompareWidth(), CanonicalCondition.EQ, false, forX, forY, view);
    78         if (value != null) {
    78         if (value != null) {
    79             return value;
    79             return value;
    80         }
    80         }
    81         return this;
    81         return this;
    82     }
    82     }
    86         /**
    86         /**
    87          * Determines if this is a comparison used to determine whether dispatching on a receiver
    87          * Determines if this is a comparison used to determine whether dispatching on a receiver
    88          * could select a certain method and if so, returns {@code true} if the answer is guaranteed
    88          * could select a certain method and if so, returns {@code true} if the answer is guaranteed
    89          * to be false. Otherwise, returns {@code false}.
    89          * to be false. Otherwise, returns {@code false}.
    90          */
    90          */
    91         private static boolean isAlwaysFailingVirtualDispatchTest(Condition condition, ValueNode forX, ValueNode forY) {
    91         private static boolean isAlwaysFailingVirtualDispatchTest(CanonicalCondition condition, ValueNode forX, ValueNode forY) {
    92             if (forY.isConstant()) {
    92             if (forY.isConstant()) {
    93                 if (forX instanceof LoadMethodNode && condition == Condition.EQ) {
    93                 if (forX instanceof LoadMethodNode && condition == CanonicalCondition.EQ) {
    94                     LoadMethodNode lm = ((LoadMethodNode) forX);
    94                     LoadMethodNode lm = ((LoadMethodNode) forX);
    95                     if (lm.getMethod().getEncoding().equals(forY.asConstant())) {
    95                     if (lm.getMethod().getEncoding().equals(forY.asConstant())) {
    96                         if (lm.getHub() instanceof LoadHubNode) {
    96                         if (lm.getHub() instanceof LoadHubNode) {
    97                             ValueNode object = ((LoadHubNode) lm.getHub()).getValue();
    97                             ValueNode object = ((LoadHubNode) lm.getHub()).getValue();
    98                             ResolvedJavaType type = StampTool.typeOrNull(object);
    98                             ResolvedJavaType type = StampTool.typeOrNull(object);
   110             }
   110             }
   111             return false;
   111             return false;
   112         }
   112         }
   113 
   113 
   114         @Override
   114         @Override
   115         public LogicNode canonical(ConstantReflectionProvider constantReflection, MetaAccessProvider metaAccess, OptionValues options, Integer smallestCompareWidth, Condition condition,
   115         public LogicNode canonical(ConstantReflectionProvider constantReflection, MetaAccessProvider metaAccess, OptionValues options, Integer smallestCompareWidth, CanonicalCondition condition,
   116                         boolean unorderedIsTrue, ValueNode forX, ValueNode forY, NodeView view) {
   116                         boolean unorderedIsTrue, ValueNode forX, ValueNode forY, NodeView view) {
   117             LogicNode result = findSynonym(forX, forY, view);
   117             LogicNode result = findSynonym(forX, forY, view);
   118             if (result != null) {
   118             if (result != null) {
   119                 return result;
   119                 return result;
   120             }
   120             }