1 /*
2 * Copyright (c) 2011, 2018, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
26
27 import static jdk.vm.ci.code.MemoryBarriers.JMM_POST_VOLATILE_READ;
28 import static jdk.vm.ci.code.MemoryBarriers.JMM_POST_VOLATILE_WRITE;
29 import static jdk.vm.ci.code.MemoryBarriers.JMM_PRE_VOLATILE_READ;
30 import static jdk.vm.ci.code.MemoryBarriers.JMM_PRE_VOLATILE_WRITE;
31 import static jdk.vm.ci.meta.DeoptimizationAction.InvalidateReprofile;
32 import static jdk.vm.ci.meta.DeoptimizationReason.BoundsCheckException;
33 import static jdk.vm.ci.meta.DeoptimizationReason.NullCheckException;
34 import static org.graalvm.compiler.core.common.SpeculativeExecutionAttacksMitigations.Options.UseIndexMasking;
35 import static org.graalvm.compiler.nodes.NamedLocationIdentity.ARRAY_LENGTH_LOCATION;
36 import static org.graalvm.compiler.nodes.calc.BinaryArithmeticNode.branchlessMax;
37 import static org.graalvm.compiler.nodes.calc.BinaryArithmeticNode.branchlessMin;
38 import static org.graalvm.compiler.nodes.java.ArrayLengthNode.readArrayLength;
39 import static org.graalvm.compiler.nodes.util.GraphUtil.skipPiWhileNonNull;
40
41 import java.nio.ByteOrder;
42 import java.util.ArrayList;
43 import java.util.BitSet;
44 import java.util.List;
45
46 import org.graalvm.compiler.api.directives.GraalDirectives;
47 import org.graalvm.compiler.api.replacements.Snippet;
48 import org.graalvm.compiler.api.replacements.SnippetReflectionProvider;
49 import org.graalvm.compiler.core.common.LIRKind;
50 import org.graalvm.compiler.core.common.spi.ForeignCallsProvider;
51 import org.graalvm.compiler.core.common.type.IntegerStamp;
52 import org.graalvm.compiler.core.common.type.ObjectStamp;
53 import org.graalvm.compiler.core.common.type.Stamp;
54 import org.graalvm.compiler.core.common.type.StampFactory;
55 import org.graalvm.compiler.core.common.type.TypeReference;
56 import org.graalvm.compiler.debug.DebugCloseable;
57 import org.graalvm.compiler.debug.DebugHandlersFactory;
58 import org.graalvm.compiler.debug.GraalError;
59 import org.graalvm.compiler.graph.Node;
60 import org.graalvm.compiler.nodeinfo.InputType;
61 import org.graalvm.compiler.nodes.CompressionNode.CompressionOp;
62 import org.graalvm.compiler.nodes.ConstantNode;
63 import org.graalvm.compiler.nodes.FieldLocationIdentity;
64 import org.graalvm.compiler.nodes.FixedNode;
65 import org.graalvm.compiler.nodes.LogicNode;
66 import org.graalvm.compiler.nodes.NamedLocationIdentity;
67 import org.graalvm.compiler.nodes.NodeView;
68 import org.graalvm.compiler.nodes.PiNode;
69 import org.graalvm.compiler.nodes.StructuredGraph;
70 import org.graalvm.compiler.nodes.ValueNode;
71 import org.graalvm.compiler.nodes.calc.AddNode;
72 import org.graalvm.compiler.nodes.calc.ConditionalNode;
73 import org.graalvm.compiler.nodes.calc.IntegerBelowNode;
74 import org.graalvm.compiler.nodes.calc.IntegerConvertNode;
75 import org.graalvm.compiler.nodes.calc.IntegerEqualsNode;
76 import org.graalvm.compiler.nodes.calc.IsNullNode;
77 import org.graalvm.compiler.nodes.calc.LeftShiftNode;
78 import org.graalvm.compiler.nodes.calc.NarrowNode;
79 import org.graalvm.compiler.nodes.calc.RightShiftNode;
80 import org.graalvm.compiler.nodes.calc.SignExtendNode;
81 import org.graalvm.compiler.nodes.calc.SubNode;
82 import org.graalvm.compiler.nodes.calc.UnpackEndianHalfNode;
83 import org.graalvm.compiler.nodes.calc.ZeroExtendNode;
84 import org.graalvm.compiler.nodes.debug.VerifyHeapNode;
85 import org.graalvm.compiler.nodes.extended.BoxNode;
86 import org.graalvm.compiler.nodes.extended.FixedValueAnchorNode;
87 import org.graalvm.compiler.nodes.extended.ForeignCallNode;
88 import org.graalvm.compiler.nodes.extended.GuardedUnsafeLoadNode;
89 import org.graalvm.compiler.nodes.extended.GuardingNode;
90 import org.graalvm.compiler.nodes.extended.JavaReadNode;
91 import org.graalvm.compiler.nodes.extended.JavaWriteNode;
92 import org.graalvm.compiler.nodes.extended.LoadArrayComponentHubNode;
93 import org.graalvm.compiler.nodes.extended.LoadHubNode;
94 import org.graalvm.compiler.nodes.extended.MembarNode;
95 import org.graalvm.compiler.nodes.extended.RawLoadNode;
96 import org.graalvm.compiler.nodes.extended.RawStoreNode;
97 import org.graalvm.compiler.nodes.extended.UnboxNode;
98 import org.graalvm.compiler.nodes.extended.UnsafeMemoryLoadNode;
99 import org.graalvm.compiler.nodes.extended.UnsafeMemoryStoreNode;
100 import org.graalvm.compiler.nodes.java.AbstractNewObjectNode;
101 import org.graalvm.compiler.nodes.java.AccessIndexedNode;
102 import org.graalvm.compiler.nodes.java.ArrayLengthNode;
103 import org.graalvm.compiler.nodes.java.AtomicReadAndWriteNode;
104 import org.graalvm.compiler.nodes.java.FinalFieldBarrierNode;
105 import org.graalvm.compiler.nodes.java.InstanceOfDynamicNode;
106 import org.graalvm.compiler.nodes.java.InstanceOfNode;
107 import org.graalvm.compiler.nodes.java.LoadFieldNode;
108 import org.graalvm.compiler.nodes.java.LoadIndexedNode;
109 import org.graalvm.compiler.nodes.java.LogicCompareAndSwapNode;
110 import org.graalvm.compiler.nodes.java.LoweredAtomicReadAndWriteNode;
111 import org.graalvm.compiler.nodes.java.MonitorEnterNode;
112 import org.graalvm.compiler.nodes.java.MonitorIdNode;
113 import org.graalvm.compiler.nodes.java.NewArrayNode;
193 @Override
194 @SuppressWarnings("try")
195 public void lower(Node n, LoweringTool tool) {
196 assert n instanceof Lowerable;
197 StructuredGraph graph = (StructuredGraph) n.graph();
198 try (DebugCloseable context = n.withNodeSourcePosition()) {
199 if (n instanceof LoadFieldNode) {
200 lowerLoadFieldNode((LoadFieldNode) n, tool);
201 } else if (n instanceof StoreFieldNode) {
202 lowerStoreFieldNode((StoreFieldNode) n, tool);
203 } else if (n instanceof LoadIndexedNode) {
204 lowerLoadIndexedNode((LoadIndexedNode) n, tool);
205 } else if (n instanceof StoreIndexedNode) {
206 lowerStoreIndexedNode((StoreIndexedNode) n, tool);
207 } else if (n instanceof IndexAddressNode) {
208 lowerIndexAddressNode((IndexAddressNode) n);
209 } else if (n instanceof ArrayLengthNode) {
210 lowerArrayLengthNode((ArrayLengthNode) n, tool);
211 } else if (n instanceof LoadHubNode) {
212 lowerLoadHubNode((LoadHubNode) n, tool);
213 } else if (n instanceof LoadArrayComponentHubNode) {
214 lowerLoadArrayComponentHubNode((LoadArrayComponentHubNode) n);
215 } else if (n instanceof MonitorEnterNode) {
216 lowerMonitorEnterNode((MonitorEnterNode) n, tool, graph);
217 } else if (n instanceof UnsafeCompareAndSwapNode) {
218 lowerCompareAndSwapNode((UnsafeCompareAndSwapNode) n);
219 } else if (n instanceof UnsafeCompareAndExchangeNode) {
220 lowerCompareAndExchangeNode((UnsafeCompareAndExchangeNode) n);
221 } else if (n instanceof AtomicReadAndWriteNode) {
222 lowerAtomicReadAndWriteNode((AtomicReadAndWriteNode) n);
223 } else if (n instanceof RawLoadNode) {
224 lowerUnsafeLoadNode((RawLoadNode) n, tool);
225 } else if (n instanceof UnsafeMemoryLoadNode) {
226 lowerUnsafeMemoryLoadNode((UnsafeMemoryLoadNode) n);
227 } else if (n instanceof RawStoreNode) {
228 lowerUnsafeStoreNode((RawStoreNode) n);
229 } else if (n instanceof UnsafeMemoryStoreNode) {
230 lowerUnsafeMemoryStoreNode((UnsafeMemoryStoreNode) n);
231 } else if (n instanceof JavaReadNode) {
232 lowerJavaReadNode((JavaReadNode) n);
539 */
540 protected ReadNode createReadArrayLength(ValueNode array, FixedNode before, LoweringTool tool) {
541 StructuredGraph graph = array.graph();
542 ValueNode canonicalArray = this.createNullCheckedValue(skipPiWhileNonNull(array), before, tool);
543 AddressNode address = createOffsetAddress(graph, canonicalArray, arrayLengthOffset());
544 ReadNode readArrayLength = graph.add(new ReadNode(address, ARRAY_LENGTH_LOCATION, StampFactory.positiveInt(), BarrierType.NONE));
545 graph.addBeforeFixed(before, readArrayLength);
546 return readArrayLength;
547 }
548
549 protected void lowerLoadHubNode(LoadHubNode loadHub, LoweringTool tool) {
550 StructuredGraph graph = loadHub.graph();
551 if (tool.getLoweringStage() != LoweringTool.StandardLoweringStage.LOW_TIER) {
552 return;
553 }
554 if (graph.getGuardsStage().allowsFloatingGuards()) {
555 return;
556 }
557 ValueNode hub = createReadHub(graph, loadHub.getValue(), tool);
558 loadHub.replaceAtUsagesAndDelete(hub);
559 }
560
561 protected void lowerLoadArrayComponentHubNode(LoadArrayComponentHubNode loadHub) {
562 StructuredGraph graph = loadHub.graph();
563 ValueNode hub = createReadArrayComponentHub(graph, loadHub.getValue(), loadHub);
564 graph.replaceFixed(loadHub, hub);
565 }
566
567 protected void lowerMonitorEnterNode(MonitorEnterNode monitorEnter, LoweringTool tool, StructuredGraph graph) {
568 ValueNode object = createNullCheckedValue(monitorEnter.object(), monitorEnter, tool);
569 ValueNode hub = graph.addOrUnique(LoadHubNode.create(object, tool.getStampProvider(), tool.getMetaAccess(), tool.getConstantReflection()));
570 RawMonitorEnterNode rawMonitorEnter = graph.add(new RawMonitorEnterNode(object, hub, monitorEnter.getMonitorId()));
571 rawMonitorEnter.setStateBefore(monitorEnter.stateBefore());
572 rawMonitorEnter.setStateAfter(monitorEnter.stateAfter());
573 graph.replaceFixedWithFixed(monitorEnter, rawMonitorEnter);
574 }
575
576 protected void lowerCompareAndSwapNode(UnsafeCompareAndSwapNode cas) {
577 StructuredGraph graph = cas.graph();
578 JavaKind valueKind = cas.getValueKind();
|
1 /*
2 * Copyright (c) 2011, 2019, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
26
27 import static jdk.vm.ci.code.MemoryBarriers.JMM_POST_VOLATILE_READ;
28 import static jdk.vm.ci.code.MemoryBarriers.JMM_POST_VOLATILE_WRITE;
29 import static jdk.vm.ci.code.MemoryBarriers.JMM_PRE_VOLATILE_READ;
30 import static jdk.vm.ci.code.MemoryBarriers.JMM_PRE_VOLATILE_WRITE;
31 import static jdk.vm.ci.meta.DeoptimizationAction.InvalidateReprofile;
32 import static jdk.vm.ci.meta.DeoptimizationReason.BoundsCheckException;
33 import static jdk.vm.ci.meta.DeoptimizationReason.NullCheckException;
34 import static org.graalvm.compiler.core.common.SpeculativeExecutionAttacksMitigations.Options.UseIndexMasking;
35 import static org.graalvm.compiler.nodes.NamedLocationIdentity.ARRAY_LENGTH_LOCATION;
36 import static org.graalvm.compiler.nodes.calc.BinaryArithmeticNode.branchlessMax;
37 import static org.graalvm.compiler.nodes.calc.BinaryArithmeticNode.branchlessMin;
38 import static org.graalvm.compiler.nodes.java.ArrayLengthNode.readArrayLength;
39 import static org.graalvm.compiler.nodes.util.GraphUtil.skipPiWhileNonNull;
40
41 import java.nio.ByteOrder;
42 import java.util.ArrayList;
43 import java.util.BitSet;
44 import java.util.List;
45
46 import jdk.vm.ci.meta.JavaConstant;
47 import org.graalvm.compiler.api.directives.GraalDirectives;
48 import org.graalvm.compiler.api.replacements.Snippet;
49 import org.graalvm.compiler.api.replacements.SnippetReflectionProvider;
50 import org.graalvm.compiler.core.common.LIRKind;
51 import org.graalvm.compiler.core.common.spi.ForeignCallsProvider;
52 import org.graalvm.compiler.core.common.type.AbstractPointerStamp;
53 import org.graalvm.compiler.core.common.type.IntegerStamp;
54 import org.graalvm.compiler.core.common.type.ObjectStamp;
55 import org.graalvm.compiler.core.common.type.Stamp;
56 import org.graalvm.compiler.core.common.type.StampFactory;
57 import org.graalvm.compiler.core.common.type.TypeReference;
58 import org.graalvm.compiler.debug.DebugCloseable;
59 import org.graalvm.compiler.debug.DebugHandlersFactory;
60 import org.graalvm.compiler.debug.GraalError;
61 import org.graalvm.compiler.graph.Node;
62 import org.graalvm.compiler.nodeinfo.InputType;
63 import org.graalvm.compiler.nodes.CompressionNode.CompressionOp;
64 import org.graalvm.compiler.nodes.ConstantNode;
65 import org.graalvm.compiler.nodes.EndNode;
66 import org.graalvm.compiler.nodes.FieldLocationIdentity;
67 import org.graalvm.compiler.nodes.FixedNode;
68 import org.graalvm.compiler.nodes.FixedWithNextNode;
69 import org.graalvm.compiler.nodes.IfNode;
70 import org.graalvm.compiler.nodes.LogicNode;
71 import org.graalvm.compiler.nodes.MergeNode;
72 import org.graalvm.compiler.nodes.NamedLocationIdentity;
73 import org.graalvm.compiler.nodes.NodeView;
74 import org.graalvm.compiler.nodes.PhiNode;
75 import org.graalvm.compiler.nodes.PiNode;
76 import org.graalvm.compiler.nodes.StructuredGraph;
77 import org.graalvm.compiler.nodes.ValueNode;
78 import org.graalvm.compiler.nodes.ValuePhiNode;
79 import org.graalvm.compiler.nodes.calc.AddNode;
80 import org.graalvm.compiler.nodes.calc.ConditionalNode;
81 import org.graalvm.compiler.nodes.calc.IntegerBelowNode;
82 import org.graalvm.compiler.nodes.calc.IntegerConvertNode;
83 import org.graalvm.compiler.nodes.calc.IntegerEqualsNode;
84 import org.graalvm.compiler.nodes.calc.IsNullNode;
85 import org.graalvm.compiler.nodes.calc.LeftShiftNode;
86 import org.graalvm.compiler.nodes.calc.NarrowNode;
87 import org.graalvm.compiler.nodes.calc.RightShiftNode;
88 import org.graalvm.compiler.nodes.calc.SignExtendNode;
89 import org.graalvm.compiler.nodes.calc.SubNode;
90 import org.graalvm.compiler.nodes.calc.UnpackEndianHalfNode;
91 import org.graalvm.compiler.nodes.calc.ZeroExtendNode;
92 import org.graalvm.compiler.nodes.debug.VerifyHeapNode;
93 import org.graalvm.compiler.nodes.extended.BoxNode;
94 import org.graalvm.compiler.nodes.extended.FixedValueAnchorNode;
95 import org.graalvm.compiler.nodes.extended.ForeignCallNode;
96 import org.graalvm.compiler.nodes.extended.GuardedUnsafeLoadNode;
97 import org.graalvm.compiler.nodes.extended.GuardingNode;
98 import org.graalvm.compiler.nodes.extended.JavaReadNode;
99 import org.graalvm.compiler.nodes.extended.JavaWriteNode;
100 import org.graalvm.compiler.nodes.extended.LoadArrayComponentHubNode;
101 import org.graalvm.compiler.nodes.extended.LoadHubNode;
102 import org.graalvm.compiler.nodes.extended.LoadHubOrNullNode;
103 import org.graalvm.compiler.nodes.extended.MembarNode;
104 import org.graalvm.compiler.nodes.extended.RawLoadNode;
105 import org.graalvm.compiler.nodes.extended.RawStoreNode;
106 import org.graalvm.compiler.nodes.extended.UnboxNode;
107 import org.graalvm.compiler.nodes.extended.UnsafeMemoryLoadNode;
108 import org.graalvm.compiler.nodes.extended.UnsafeMemoryStoreNode;
109 import org.graalvm.compiler.nodes.java.AbstractNewObjectNode;
110 import org.graalvm.compiler.nodes.java.AccessIndexedNode;
111 import org.graalvm.compiler.nodes.java.ArrayLengthNode;
112 import org.graalvm.compiler.nodes.java.AtomicReadAndWriteNode;
113 import org.graalvm.compiler.nodes.java.FinalFieldBarrierNode;
114 import org.graalvm.compiler.nodes.java.InstanceOfDynamicNode;
115 import org.graalvm.compiler.nodes.java.InstanceOfNode;
116 import org.graalvm.compiler.nodes.java.LoadFieldNode;
117 import org.graalvm.compiler.nodes.java.LoadIndexedNode;
118 import org.graalvm.compiler.nodes.java.LogicCompareAndSwapNode;
119 import org.graalvm.compiler.nodes.java.LoweredAtomicReadAndWriteNode;
120 import org.graalvm.compiler.nodes.java.MonitorEnterNode;
121 import org.graalvm.compiler.nodes.java.MonitorIdNode;
122 import org.graalvm.compiler.nodes.java.NewArrayNode;
202 @Override
203 @SuppressWarnings("try")
204 public void lower(Node n, LoweringTool tool) {
205 assert n instanceof Lowerable;
206 StructuredGraph graph = (StructuredGraph) n.graph();
207 try (DebugCloseable context = n.withNodeSourcePosition()) {
208 if (n instanceof LoadFieldNode) {
209 lowerLoadFieldNode((LoadFieldNode) n, tool);
210 } else if (n instanceof StoreFieldNode) {
211 lowerStoreFieldNode((StoreFieldNode) n, tool);
212 } else if (n instanceof LoadIndexedNode) {
213 lowerLoadIndexedNode((LoadIndexedNode) n, tool);
214 } else if (n instanceof StoreIndexedNode) {
215 lowerStoreIndexedNode((StoreIndexedNode) n, tool);
216 } else if (n instanceof IndexAddressNode) {
217 lowerIndexAddressNode((IndexAddressNode) n);
218 } else if (n instanceof ArrayLengthNode) {
219 lowerArrayLengthNode((ArrayLengthNode) n, tool);
220 } else if (n instanceof LoadHubNode) {
221 lowerLoadHubNode((LoadHubNode) n, tool);
222 } else if (n instanceof LoadHubOrNullNode) {
223 lowerLoadHubOrNullNode((LoadHubOrNullNode) n, tool);
224 } else if (n instanceof LoadArrayComponentHubNode) {
225 lowerLoadArrayComponentHubNode((LoadArrayComponentHubNode) n);
226 } else if (n instanceof MonitorEnterNode) {
227 lowerMonitorEnterNode((MonitorEnterNode) n, tool, graph);
228 } else if (n instanceof UnsafeCompareAndSwapNode) {
229 lowerCompareAndSwapNode((UnsafeCompareAndSwapNode) n);
230 } else if (n instanceof UnsafeCompareAndExchangeNode) {
231 lowerCompareAndExchangeNode((UnsafeCompareAndExchangeNode) n);
232 } else if (n instanceof AtomicReadAndWriteNode) {
233 lowerAtomicReadAndWriteNode((AtomicReadAndWriteNode) n);
234 } else if (n instanceof RawLoadNode) {
235 lowerUnsafeLoadNode((RawLoadNode) n, tool);
236 } else if (n instanceof UnsafeMemoryLoadNode) {
237 lowerUnsafeMemoryLoadNode((UnsafeMemoryLoadNode) n);
238 } else if (n instanceof RawStoreNode) {
239 lowerUnsafeStoreNode((RawStoreNode) n);
240 } else if (n instanceof UnsafeMemoryStoreNode) {
241 lowerUnsafeMemoryStoreNode((UnsafeMemoryStoreNode) n);
242 } else if (n instanceof JavaReadNode) {
243 lowerJavaReadNode((JavaReadNode) n);
550 */
551 protected ReadNode createReadArrayLength(ValueNode array, FixedNode before, LoweringTool tool) {
552 StructuredGraph graph = array.graph();
553 ValueNode canonicalArray = this.createNullCheckedValue(skipPiWhileNonNull(array), before, tool);
554 AddressNode address = createOffsetAddress(graph, canonicalArray, arrayLengthOffset());
555 ReadNode readArrayLength = graph.add(new ReadNode(address, ARRAY_LENGTH_LOCATION, StampFactory.positiveInt(), BarrierType.NONE));
556 graph.addBeforeFixed(before, readArrayLength);
557 return readArrayLength;
558 }
559
560 protected void lowerLoadHubNode(LoadHubNode loadHub, LoweringTool tool) {
561 StructuredGraph graph = loadHub.graph();
562 if (tool.getLoweringStage() != LoweringTool.StandardLoweringStage.LOW_TIER) {
563 return;
564 }
565 if (graph.getGuardsStage().allowsFloatingGuards()) {
566 return;
567 }
568 ValueNode hub = createReadHub(graph, loadHub.getValue(), tool);
569 loadHub.replaceAtUsagesAndDelete(hub);
570 }
571
572 protected void lowerLoadHubOrNullNode(LoadHubOrNullNode loadHubOrNullNode, LoweringTool tool) {
573 StructuredGraph graph = loadHubOrNullNode.graph();
574 if (tool.getLoweringStage() != LoweringTool.StandardLoweringStage.LOW_TIER) {
575 return;
576 }
577 if (graph.getGuardsStage().allowsFloatingGuards()) {
578 return;
579 }
580 final FixedWithNextNode predecessor = tool.lastFixedNode();
581 final ValueNode value = loadHubOrNullNode.getValue();
582 AbstractPointerStamp stamp = (AbstractPointerStamp) value.stamp(NodeView.DEFAULT);
583 final LogicNode isNull = graph.addOrUniqueWithInputs(IsNullNode.create(value));
584 final EndNode trueEnd = graph.add(new EndNode());
585 final EndNode falseEnd = graph.add(new EndNode());
586 final IfNode ifNode = graph.add(new IfNode(isNull, trueEnd, falseEnd, 0.5));
587 final MergeNode merge = graph.add(new MergeNode());
588 merge.addForwardEnd(trueEnd);
589 merge.addForwardEnd(falseEnd);
590 final AbstractPointerStamp hubStamp = (AbstractPointerStamp) loadHubOrNullNode.stamp(NodeView.DEFAULT);
591 ValueNode nullHub = ConstantNode.forConstant(hubStamp.asAlwaysNull(), JavaConstant.NULL_POINTER, tool.getMetaAccess(), graph);
592 final ValueNode nonNullValue = graph.addOrUniqueWithInputs(PiNode.create(value, stamp.asNonNull(), ifNode.falseSuccessor()));
593 ValueNode hub = createReadHub(graph, nonNullValue, tool);
594 ValueNode[] values = new ValueNode[]{nullHub, hub};
595 final PhiNode hubPhi = graph.unique(new ValuePhiNode(hubStamp, merge, values));
596 final FixedNode oldNext = predecessor.next();
597 predecessor.setNext(ifNode);
598 merge.setNext(oldNext);
599 loadHubOrNullNode.replaceAtUsagesAndDelete(hubPhi);
600 }
601
602 protected void lowerLoadArrayComponentHubNode(LoadArrayComponentHubNode loadHub) {
603 StructuredGraph graph = loadHub.graph();
604 ValueNode hub = createReadArrayComponentHub(graph, loadHub.getValue(), loadHub);
605 graph.replaceFixed(loadHub, hub);
606 }
607
608 protected void lowerMonitorEnterNode(MonitorEnterNode monitorEnter, LoweringTool tool, StructuredGraph graph) {
609 ValueNode object = createNullCheckedValue(monitorEnter.object(), monitorEnter, tool);
610 ValueNode hub = graph.addOrUnique(LoadHubNode.create(object, tool.getStampProvider(), tool.getMetaAccess(), tool.getConstantReflection()));
611 RawMonitorEnterNode rawMonitorEnter = graph.add(new RawMonitorEnterNode(object, hub, monitorEnter.getMonitorId()));
612 rawMonitorEnter.setStateBefore(monitorEnter.stateBefore());
613 rawMonitorEnter.setStateAfter(monitorEnter.stateAfter());
614 graph.replaceFixedWithFixed(monitorEnter, rawMonitorEnter);
615 }
616
617 protected void lowerCompareAndSwapNode(UnsafeCompareAndSwapNode cas) {
618 StructuredGraph graph = cas.graph();
619 JavaKind valueKind = cas.getValueKind();
|