31 import org.graalvm.compiler.graph.spi.Canonicalizable;
32 import org.graalvm.compiler.graph.spi.CanonicalizerTool;
33 import org.graalvm.compiler.nodeinfo.NodeInfo;
34 import org.graalvm.compiler.nodes.ConstantNode;
35 import org.graalvm.compiler.nodes.DeoptimizeNode;
36 import org.graalvm.compiler.nodes.PhiNode;
37 import org.graalvm.compiler.nodes.ValueNode;
38 import org.graalvm.compiler.nodes.ValuePhiNode;
39 import org.graalvm.compiler.nodes.spi.UncheckedInterfaceProvider;
40 import org.graalvm.compiler.nodes.spi.Virtualizable;
41 import org.graalvm.compiler.nodes.spi.VirtualizerTool;
42 import org.graalvm.compiler.nodes.type.StampTool;
43 import org.graalvm.compiler.nodes.util.ConstantFoldUtil;
44 import org.graalvm.compiler.nodes.virtual.VirtualInstanceNode;
45 import org.graalvm.compiler.nodes.virtual.VirtualObjectNode;
46
47 import jdk.vm.ci.meta.Assumptions;
48 import jdk.vm.ci.meta.DeoptimizationAction;
49 import jdk.vm.ci.meta.DeoptimizationReason;
50 import jdk.vm.ci.meta.JavaConstant;
51 import jdk.vm.ci.meta.MetaAccessProvider;
52 import jdk.vm.ci.meta.ResolvedJavaField;
53
54 /**
55 * The {@code LoadFieldNode} represents a read of a static or instance field.
56 */
57 @NodeInfo(nameTemplate = "LoadField#{p#field/s}")
58 public final class LoadFieldNode extends AccessFieldNode implements Canonicalizable.Unary<ValueNode>, Virtualizable, UncheckedInterfaceProvider {
59
60 public static final NodeClass<LoadFieldNode> TYPE = NodeClass.create(LoadFieldNode.class);
61
62 private final Stamp uncheckedStamp;
63
64 protected LoadFieldNode(StampPair stamp, ValueNode object, ResolvedJavaField field) {
65 super(TYPE, stamp.getTrustedStamp(), object, field);
66 this.uncheckedStamp = stamp.getUncheckedStamp();
67 }
68
69 public static LoadFieldNode create(Assumptions assumptions, ValueNode object, ResolvedJavaField field) {
70 return new LoadFieldNode(StampFactory.forDeclaredType(assumptions, field.getType(), false), object, field);
91 return constant;
92 }
93 if (tool.allUsagesAvailable()) {
94 PhiNode phi = asPhi(tool, forObject);
95 if (phi != null) {
96 return phi;
97 }
98 }
99 }
100 if (!isStatic() && forObject.isNullConstant()) {
101 return new DeoptimizeNode(DeoptimizationAction.InvalidateReprofile, DeoptimizationReason.NullCheckException);
102 }
103 return this;
104 }
105
106 /**
107 * Gets a constant value for this load if possible.
108 */
109 public ConstantNode asConstant(CanonicalizerTool tool, ValueNode forObject) {
110 if (isStatic()) {
111 return ConstantFoldUtil.tryConstantFold(tool.getConstantFieldProvider(), tool.getConstantReflection(), tool.getMetaAccess(), field(), null);
112 } else if (forObject.isConstant() && !forObject.isNullConstant()) {
113 return ConstantFoldUtil.tryConstantFold(tool.getConstantFieldProvider(), tool.getConstantReflection(), tool.getMetaAccess(), field(), forObject.asJavaConstant());
114 }
115 return null;
116 }
117
118 public ConstantNode asConstant(CanonicalizerTool tool, JavaConstant constant) {
119 return ConstantFoldUtil.tryConstantFold(tool.getConstantFieldProvider(), tool.getConstantReflection(), tool.getMetaAccess(), field(), constant);
120 }
121
122 private PhiNode asPhi(CanonicalizerTool tool, ValueNode forObject) {
123 if (!isStatic() && field.isFinal() && forObject instanceof ValuePhiNode && ((ValuePhiNode) forObject).values().filter(isNotA(ConstantNode.class)).isEmpty()) {
124 PhiNode phi = (PhiNode) forObject;
125 ConstantNode[] constantNodes = new ConstantNode[phi.valueCount()];
126 for (int i = 0; i < phi.valueCount(); i++) {
127 ConstantNode constant = ConstantFoldUtil.tryConstantFold(tool.getConstantFieldProvider(), tool.getConstantReflection(), tool.getMetaAccess(), field(), phi.valueAt(i).asJavaConstant());
128 if (constant == null) {
129 return null;
130 }
131 constantNodes[i] = constant;
132 }
133 return new ValuePhiNode(stamp(), phi.merge(), constantNodes);
134 }
135 return null;
136 }
137
138 @Override
139 public void virtualize(VirtualizerTool tool) {
140 ValueNode alias = tool.getAlias(object());
141 if (alias instanceof VirtualObjectNode) {
142 int fieldIndex = ((VirtualInstanceNode) alias).fieldIndex(field());
143 if (fieldIndex != -1) {
144 tool.replaceWith(tool.getEntry((VirtualObjectNode) alias, fieldIndex));
145 }
146 }
147 }
148
149 @Override
150 public Stamp uncheckedStamp() {
151 return uncheckedStamp;
152 }
153 }
|
31 import org.graalvm.compiler.graph.spi.Canonicalizable;
32 import org.graalvm.compiler.graph.spi.CanonicalizerTool;
33 import org.graalvm.compiler.nodeinfo.NodeInfo;
34 import org.graalvm.compiler.nodes.ConstantNode;
35 import org.graalvm.compiler.nodes.DeoptimizeNode;
36 import org.graalvm.compiler.nodes.PhiNode;
37 import org.graalvm.compiler.nodes.ValueNode;
38 import org.graalvm.compiler.nodes.ValuePhiNode;
39 import org.graalvm.compiler.nodes.spi.UncheckedInterfaceProvider;
40 import org.graalvm.compiler.nodes.spi.Virtualizable;
41 import org.graalvm.compiler.nodes.spi.VirtualizerTool;
42 import org.graalvm.compiler.nodes.type.StampTool;
43 import org.graalvm.compiler.nodes.util.ConstantFoldUtil;
44 import org.graalvm.compiler.nodes.virtual.VirtualInstanceNode;
45 import org.graalvm.compiler.nodes.virtual.VirtualObjectNode;
46
47 import jdk.vm.ci.meta.Assumptions;
48 import jdk.vm.ci.meta.DeoptimizationAction;
49 import jdk.vm.ci.meta.DeoptimizationReason;
50 import jdk.vm.ci.meta.JavaConstant;
51 import jdk.vm.ci.meta.JavaKind;
52 import jdk.vm.ci.meta.MetaAccessProvider;
53 import jdk.vm.ci.meta.ResolvedJavaField;
54
55 /**
56 * The {@code LoadFieldNode} represents a read of a static or instance field.
57 */
58 @NodeInfo(nameTemplate = "LoadField#{p#field/s}")
59 public final class LoadFieldNode extends AccessFieldNode implements Canonicalizable.Unary<ValueNode>, Virtualizable, UncheckedInterfaceProvider {
60
61 public static final NodeClass<LoadFieldNode> TYPE = NodeClass.create(LoadFieldNode.class);
62
63 private final Stamp uncheckedStamp;
64
65 protected LoadFieldNode(StampPair stamp, ValueNode object, ResolvedJavaField field) {
66 super(TYPE, stamp.getTrustedStamp(), object, field);
67 this.uncheckedStamp = stamp.getUncheckedStamp();
68 }
69
70 public static LoadFieldNode create(Assumptions assumptions, ValueNode object, ResolvedJavaField field) {
71 return new LoadFieldNode(StampFactory.forDeclaredType(assumptions, field.getType(), false), object, field);
92 return constant;
93 }
94 if (tool.allUsagesAvailable()) {
95 PhiNode phi = asPhi(tool, forObject);
96 if (phi != null) {
97 return phi;
98 }
99 }
100 }
101 if (!isStatic() && forObject.isNullConstant()) {
102 return new DeoptimizeNode(DeoptimizationAction.InvalidateReprofile, DeoptimizationReason.NullCheckException);
103 }
104 return this;
105 }
106
107 /**
108 * Gets a constant value for this load if possible.
109 */
110 public ConstantNode asConstant(CanonicalizerTool tool, ValueNode forObject) {
111 if (isStatic()) {
112 return ConstantFoldUtil.tryConstantFold(tool.getConstantFieldProvider(), tool.getConstantReflection(), tool.getMetaAccess(), field(), null, getOptions());
113 } else if (forObject.isConstant() && !forObject.isNullConstant()) {
114 return ConstantFoldUtil.tryConstantFold(tool.getConstantFieldProvider(), tool.getConstantReflection(), tool.getMetaAccess(), field(), forObject.asJavaConstant(), getOptions());
115 }
116 return null;
117 }
118
119 public ConstantNode asConstant(CanonicalizerTool tool, JavaConstant constant) {
120 return ConstantFoldUtil.tryConstantFold(tool.getConstantFieldProvider(), tool.getConstantReflection(), tool.getMetaAccess(), field(), constant, getOptions());
121 }
122
123 private PhiNode asPhi(CanonicalizerTool tool, ValueNode forObject) {
124 if (!isStatic() && field.isFinal() && forObject instanceof ValuePhiNode && ((ValuePhiNode) forObject).values().filter(isNotA(ConstantNode.class)).isEmpty()) {
125 PhiNode phi = (PhiNode) forObject;
126 ConstantNode[] constantNodes = new ConstantNode[phi.valueCount()];
127 for (int i = 0; i < phi.valueCount(); i++) {
128 ConstantNode constant = ConstantFoldUtil.tryConstantFold(tool.getConstantFieldProvider(), tool.getConstantReflection(), tool.getMetaAccess(), field(), phi.valueAt(i).asJavaConstant(),
129 getOptions());
130 if (constant == null) {
131 return null;
132 }
133 constantNodes[i] = constant;
134 }
135 return new ValuePhiNode(stamp(), phi.merge(), constantNodes);
136 }
137 return null;
138 }
139
140 @Override
141 public void virtualize(VirtualizerTool tool) {
142 ValueNode alias = tool.getAlias(object());
143 if (alias instanceof VirtualObjectNode) {
144 int fieldIndex = ((VirtualInstanceNode) alias).fieldIndex(field());
145 if (fieldIndex != -1) {
146 ValueNode entry = tool.getEntry((VirtualObjectNode) alias, fieldIndex);
147 if (stamp.isCompatible(entry.stamp())) {
148 tool.replaceWith(entry);
149 } else {
150 assert stamp().getStackKind() == JavaKind.Int && (entry.stamp().getStackKind() == JavaKind.Long || entry.getStackKind() == JavaKind.Double ||
151 entry.getStackKind() == JavaKind.Illegal) : "Can only allow different stack kind two slot marker writes on one stot fields.";
152 }
153 }
154 }
155 }
156
157 @Override
158 public Stamp uncheckedStamp() {
159 return uncheckedStamp;
160 }
161
162 public void setObject(ValueNode newObject) {
163 this.updateUsages(object, newObject);
164 this.object = newObject;
165 }
166 }
|