diff --git a/compiler/src/org.graalvm.compiler.core.amd64/src/org/graalvm/compiler/core/amd64/AMD64NodeMatchRules.java b/compiler/src/org.graalvm.compiler.core.amd64/src/org/graalvm/compiler/core/amd64/AMD64NodeMatchRules.java index f7d68038ef62..15111aa5e8ab 100644 --- a/compiler/src/org.graalvm.compiler.core.amd64/src/org/graalvm/compiler/core/amd64/AMD64NodeMatchRules.java +++ b/compiler/src/org.graalvm.compiler.core.amd64/src/org/graalvm/compiler/core/amd64/AMD64NodeMatchRules.java @@ -359,6 +359,7 @@ public ComplexMatchResult resetLowestSetBit(ValueNode a, ValueNode b) { @MatchRule("(If (IntegerTest Read=access value))") @MatchRule("(If (IntegerTest FloatingRead=access value))") + @MatchRule("(If (IntegerTest VolatileRead=access value))") public ComplexMatchResult integerTestBranchMemory(IfNode root, LIRLowerableAccess access, ValueNode value) { return emitIntegerTestBranchMemory(root, value, access); } @@ -369,14 +370,21 @@ public ComplexMatchResult integerTestBranchMemory(IfNode root, LIRLowerableAcces @MatchRule("(If (IntegerEquals=compare value FloatingRead=access))") @MatchRule("(If (IntegerLessThan=compare value FloatingRead=access))") @MatchRule("(If (IntegerBelow=compare value FloatingRead=access))") + @MatchRule("(If (IntegerEquals=compare value VolatileRead=access))") + @MatchRule("(If (IntegerLessThan=compare value VolatileRead=access))") + @MatchRule("(If (IntegerBelow=compare value VolatileRead=access))") @MatchRule("(If (FloatEquals=compare value Read=access))") @MatchRule("(If (FloatEquals=compare value FloatingRead=access))") + @MatchRule("(If (FloatEquals=compare value VolatileRead=access))") @MatchRule("(If (FloatLessThan=compare value Read=access))") @MatchRule("(If (FloatLessThan=compare value FloatingRead=access))") + @MatchRule("(If (FloatLessThan=compare value VolatileRead=access))") @MatchRule("(If (PointerEquals=compare value Read=access))") @MatchRule("(If (PointerEquals=compare value FloatingRead=access))") + @MatchRule("(If (PointerEquals=compare value VolatileRead=access))") @MatchRule("(If (ObjectEquals=compare value Read=access))") @MatchRule("(If (ObjectEquals=compare value FloatingRead=access))") + @MatchRule("(If (ObjectEquals=compare value VolatileRead=access))") public ComplexMatchResult ifCompareMemory(IfNode root, CompareNode compare, ValueNode value, LIRLowerableAccess access) { return emitCompareBranchMemory(root, compare, value, access); } @@ -478,6 +486,7 @@ private ComplexMatchResult binaryRead(AMD64Assembler.VexRVMOp op, OperandSize si @MatchRule("(Add value Read=access)") @MatchRule("(Add value FloatingRead=access)") + @MatchRule("(Add value VolatileRead=access)") public ComplexMatchResult addMemory(ValueNode value, LIRLowerableAccess access) { OperandSize size = getMemorySize(access); if (size.isXmmType()) { @@ -493,6 +502,7 @@ public ComplexMatchResult addMemory(ValueNode value, LIRLowerableAccess access) @MatchRule("(Sub value Read=access)") @MatchRule("(Sub value FloatingRead=access)") + @MatchRule("(Sub value VolatileRead=access)") public ComplexMatchResult subMemory(ValueNode value, LIRLowerableAccess access) { OperandSize size = getMemorySize(access); if (size.isXmmType()) { @@ -508,6 +518,7 @@ public ComplexMatchResult subMemory(ValueNode value, LIRLowerableAccess access) @MatchRule("(Mul value Read=access)") @MatchRule("(Mul value FloatingRead=access)") + @MatchRule("(Mul value VolatileRead=access)") public ComplexMatchResult mulMemory(ValueNode value, LIRLowerableAccess access) { OperandSize size = getMemorySize(access); if (size.isXmmType()) { @@ -523,6 +534,7 @@ public ComplexMatchResult mulMemory(ValueNode value, LIRLowerableAccess access) @MatchRule("(And value Read=access)") @MatchRule("(And value FloatingRead=access)") + @MatchRule("(And value VolatileRead=access)") public ComplexMatchResult andMemory(ValueNode value, LIRLowerableAccess access) { OperandSize size = getMemorySize(access); if (size.isXmmType()) { @@ -534,6 +546,7 @@ public ComplexMatchResult andMemory(ValueNode value, LIRLowerableAccess access) @MatchRule("(Or value Read=access)") @MatchRule("(Or value FloatingRead=access)") + @MatchRule("(Or value VolatileRead=access)") public ComplexMatchResult orMemory(ValueNode value, LIRLowerableAccess access) { OperandSize size = getMemorySize(access); if (size.isXmmType()) { @@ -545,6 +558,7 @@ public ComplexMatchResult orMemory(ValueNode value, LIRLowerableAccess access) { @MatchRule("(Xor value Read=access)") @MatchRule("(Xor value FloatingRead=access)") + @MatchRule("(Xor value VolatileRead=access)") public ComplexMatchResult xorMemory(ValueNode value, LIRLowerableAccess access) { OperandSize size = getMemorySize(access); if (size.isXmmType()) { @@ -565,12 +579,14 @@ public ComplexMatchResult writeNarrow(WriteNode root, NarrowNode narrow) { @MatchRule("(SignExtend Read=access)") @MatchRule("(SignExtend FloatingRead=access)") + @MatchRule("(SignExtend VolatileRead=access)") public ComplexMatchResult signExtend(SignExtendNode root, LIRLowerableAccess access) { return emitSignExtendMemory(access, root.getInputBits(), root.getResultBits(), null); } @MatchRule("(ZeroExtend Read=access)") @MatchRule("(ZeroExtend FloatingRead=access)") + @MatchRule("(ZeroExtend VolatileRead=access)") public ComplexMatchResult zeroExtend(ZeroExtendNode root, LIRLowerableAccess access) { AMD64Kind memoryKind = getMemoryKind(access); return builder -> getArithmeticLIRGenerator().emitZeroExtendMemory(memoryKind, root.getResultBits(), (AMD64AddressValue) operand(access.getAddress()), getState(access)); @@ -578,6 +594,7 @@ public ComplexMatchResult zeroExtend(ZeroExtendNode root, LIRLowerableAccess acc @MatchRule("(Narrow Read=access)") @MatchRule("(Narrow FloatingRead=access)") + @MatchRule("(Narrow VolatileRead=access)") public ComplexMatchResult narrowRead(NarrowNode root, LIRLowerableAccess access) { return new ComplexMatchResult() { @Override @@ -595,6 +612,7 @@ public Value evaluate(NodeLIRBuilder builder) { @MatchRule("(SignExtend (Narrow=narrow Read=access))") @MatchRule("(SignExtend (Narrow=narrow FloatingRead=access))") + @MatchRule("(SignExtend (Narrow=narrow VolatileRead=access))") public ComplexMatchResult signExtendNarrowRead(SignExtendNode root, NarrowNode narrow, LIRLowerableAccess access) { LIRKind kind = getLIRGeneratorTool().getLIRKind(narrow.stamp(NodeView.DEFAULT)); return emitSignExtendMemory(access, narrow.getResultBits(), root.getResultBits(), kind); @@ -602,6 +620,7 @@ public ComplexMatchResult signExtendNarrowRead(SignExtendNode root, NarrowNode n @MatchRule("(FloatConvert Read=access)") @MatchRule("(FloatConvert FloatingRead=access)") + @MatchRule("(FloatConvert VolatileRead=access)") public ComplexMatchResult floatConvert(FloatConvertNode root, LIRLowerableAccess access) { switch (root.getFloatConvert()) { case D2F: @@ -631,6 +650,7 @@ public ComplexMatchResult floatConvert(FloatConvertNode root, LIRLowerableAccess @MatchRule("(Reinterpret Read=access)") @MatchRule("(Reinterpret FloatingRead=access)") + @MatchRule("(Reinterpret VolatileRead=access)") public ComplexMatchResult reinterpret(ReinterpretNode root, LIRLowerableAccess access) { return builder -> { LIRKind kind = getLIRGeneratorTool().getLIRKind(root.stamp(NodeView.DEFAULT)); diff --git a/compiler/src/org.graalvm.compiler.core.common/src/org/graalvm/compiler/core/common/GraalOptions.java b/compiler/src/org.graalvm.compiler.core.common/src/org/graalvm/compiler/core/common/GraalOptions.java index db25bf18cc08..5958742802de 100644 --- a/compiler/src/org.graalvm.compiler.core.common/src/org/graalvm/compiler/core/common/GraalOptions.java +++ b/compiler/src/org.graalvm.compiler.core.common/src/org/graalvm/compiler/core/common/GraalOptions.java @@ -291,4 +291,7 @@ public final class GraalOptions { @Option(help = "Alignment in bytes for loop header blocks.", type = OptionType.Expert) public static final OptionKey LoopHeaderAlignment = new OptionKey<>(16); + + @Option(help = "Do not include membars for volatile accesses until the end of optimizations.", type = OptionType.Expert) + public static final OptionKey LateMembars = new OptionKey<>(true); } diff --git a/compiler/src/org.graalvm.compiler.core.sparc/src/org/graalvm/compiler/core/sparc/SPARCNodeMatchRules.java b/compiler/src/org.graalvm.compiler.core.sparc/src/org/graalvm/compiler/core/sparc/SPARCNodeMatchRules.java index 580e387a65ff..2ba68eec0808 100644 --- a/compiler/src/org.graalvm.compiler.core.sparc/src/org/graalvm/compiler/core/sparc/SPARCNodeMatchRules.java +++ b/compiler/src/org.graalvm.compiler.core.sparc/src/org/graalvm/compiler/core/sparc/SPARCNodeMatchRules.java @@ -134,12 +134,14 @@ private ComplexMatchResult emitZeroExtendMemory(Access access, int fromBits, int @MatchRule("(SignExtend Read=access)") @MatchRule("(SignExtend FloatingRead=access)") + @MatchRule("(SignExtend VolatileRead=access)") public ComplexMatchResult signExtend(SignExtendNode root, Access access) { return emitSignExtendMemory(access, root.getInputBits(), root.getResultBits()); } @MatchRule("(ZeroExtend Read=access)") @MatchRule("(ZeroExtend FloatingRead=access)") + @MatchRule("(ZeroExtend VolatileRead=access)") public ComplexMatchResult zeroExtend(ZeroExtendNode root, Access access) { return emitZeroExtendMemory(access, root.getInputBits(), root.getResultBits()); } diff --git a/compiler/src/org.graalvm.compiler.core.test/src/org/graalvm/compiler/core/test/GraalCompilerTest.java b/compiler/src/org.graalvm.compiler.core.test/src/org/graalvm/compiler/core/test/GraalCompilerTest.java index 784a4023f111..449e6d27b619 100644 --- a/compiler/src/org.graalvm.compiler.core.test/src/org/graalvm/compiler/core/test/GraalCompilerTest.java +++ b/compiler/src/org.graalvm.compiler.core.test/src/org/graalvm/compiler/core/test/GraalCompilerTest.java @@ -1119,6 +1119,12 @@ protected StructuredGraph getFinalGraph(ResolvedJavaMethod method) { return graph; } + protected StructuredGraph getFinalGraph(ResolvedJavaMethod method, OptionValues options) { + StructuredGraph graph = parseForCompile(method, options); + applyFrontEnd(graph); + return graph; + } + @SuppressWarnings("try") protected void applyFrontEnd(StructuredGraph graph) { DebugContext debug = graph.getDebug(); diff --git a/compiler/src/org.graalvm.compiler.core/src/org/graalvm/compiler/core/gen/NodeMatchRules.java b/compiler/src/org.graalvm.compiler.core/src/org/graalvm/compiler/core/gen/NodeMatchRules.java index 7a2eb2070863..762ca2e60c4d 100644 --- a/compiler/src/org.graalvm.compiler.core/src/org/graalvm/compiler/core/gen/NodeMatchRules.java +++ b/compiler/src/org.graalvm.compiler.core/src/org/graalvm/compiler/core/gen/NodeMatchRules.java @@ -63,6 +63,7 @@ import org.graalvm.compiler.nodes.java.ValueCompareAndSwapNode; import org.graalvm.compiler.nodes.memory.FloatingReadNode; import org.graalvm.compiler.nodes.memory.ReadNode; +import org.graalvm.compiler.nodes.memory.VolatileReadNode; import org.graalvm.compiler.nodes.memory.WriteNode; import jdk.vm.ci.meta.Value; @@ -75,6 +76,7 @@ @MatchableNode(nodeClass = LeftShiftNode.class, inputs = {"x", "y"}, ignoresSideEffects = true) @MatchableNode(nodeClass = NarrowNode.class, inputs = {"value"}, ignoresSideEffects = true) @MatchableNode(nodeClass = ReadNode.class, inputs = {"address"}) +@MatchableNode(nodeClass = VolatileReadNode.class, inputs = {"address"}) @MatchableNode(nodeClass = ReinterpretNode.class, inputs = {"value"}, ignoresSideEffects = true) @MatchableNode(nodeClass = SignExtendNode.class, inputs = {"value"}, ignoresSideEffects = true) @MatchableNode(nodeClass = UnsignedRightShiftNode.class, inputs = {"x", "y"}, ignoresSideEffects = true) diff --git a/compiler/src/org.graalvm.compiler.core/src/org/graalvm/compiler/core/phases/LowTier.java b/compiler/src/org.graalvm.compiler.core/src/org/graalvm/compiler/core/phases/LowTier.java index 5e5d4c65ca28..f9abe0109f8c 100644 --- a/compiler/src/org.graalvm.compiler.core/src/org/graalvm/compiler/core/phases/LowTier.java +++ b/compiler/src/org.graalvm.compiler.core/src/org/graalvm/compiler/core/phases/LowTier.java @@ -24,6 +24,7 @@ */ package org.graalvm.compiler.core.phases; +import static org.graalvm.compiler.core.common.GraalOptions.LateMembars; import static org.graalvm.compiler.phases.common.DeadCodeEliminationPhase.Optionality.Required; import org.graalvm.compiler.core.common.GraalOptions; @@ -36,6 +37,7 @@ import org.graalvm.compiler.phases.common.DeadCodeEliminationPhase; import org.graalvm.compiler.phases.common.ExpandLogicPhase; import org.graalvm.compiler.phases.common.FixReadsPhase; +import org.graalvm.compiler.phases.common.InsertMembarsPhase; import org.graalvm.compiler.phases.common.LoweringPhase; import org.graalvm.compiler.phases.common.ProfileCompiledMethodsPhase; import org.graalvm.compiler.phases.common.PropagateDeoptimizeProbabilityPhase; @@ -78,6 +80,9 @@ public LowTier(OptionValues options) { appendPhase(new PropagateDeoptimizeProbabilityPhase()); + if (LateMembars.getValue(options)) { + appendPhase(new InsertMembarsPhase()); + } appendPhase(new SchedulePhase(SchedulePhase.SchedulingStrategy.LATEST_OUT_OF_LOOPS)); } } diff --git a/compiler/src/org.graalvm.compiler.hotspot.test/src/org/graalvm/compiler/hotspot/test/LateMembarInsertionTest.java b/compiler/src/org.graalvm.compiler.hotspot.test/src/org/graalvm/compiler/hotspot/test/LateMembarInsertionTest.java new file mode 100644 index 000000000000..92c334695fc3 --- /dev/null +++ b/compiler/src/org.graalvm.compiler.hotspot.test/src/org/graalvm/compiler/hotspot/test/LateMembarInsertionTest.java @@ -0,0 +1,235 @@ +/* + * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2019, Red Hat Inc. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +package org.graalvm.compiler.hotspot.test; + +import jdk.vm.ci.hotspot.HotSpotJVMCIRuntime; +import jdk.vm.ci.meta.ConstantReflectionProvider; +import jdk.vm.ci.meta.MetaAccessProvider; +import jdk.vm.ci.meta.ResolvedJavaType; +import jdk.vm.ci.runtime.JVMCI; +import jdk.vm.ci.runtime.JVMCIBackend; +import org.graalvm.collections.EconomicMap; +import org.graalvm.compiler.core.common.type.Stamp; +import org.graalvm.compiler.core.test.GraalCompilerTest; +import org.graalvm.compiler.nodes.ConstantNode; +import org.graalvm.compiler.nodes.NodeView; +import org.graalvm.compiler.nodes.StructuredGraph; +import org.graalvm.compiler.nodes.ValueNode; +import org.graalvm.compiler.nodes.cfg.Block; +import org.graalvm.compiler.nodes.cfg.ControlFlowGraph; +import org.graalvm.compiler.nodes.memory.FixedAccessNode; +import org.graalvm.compiler.nodes.memory.MemoryAccess; +import org.graalvm.compiler.nodes.memory.ReadNode; +import org.graalvm.compiler.nodes.memory.address.AddressNode; +import org.graalvm.compiler.options.OptionKey; +import org.graalvm.compiler.options.OptionValues; +import org.junit.Assert; +import org.junit.Test; + +import java.util.Arrays; +import java.util.List; +import java.util.stream.Collectors; + +import static org.graalvm.compiler.core.common.GraalOptions.StressTestEarlyReads; + +public class LateMembarInsertionTest extends GraalCompilerTest { + static class VolatileAccess { + static volatile int field; + } + + static class VolatileAccess2 { + static volatile int field; + } + + static class RegularAccess { + static int field; + } + + public static int volatileFieldLoadFieldLoad() { + int v1 = VolatileAccess.field; + int v2 = RegularAccess.field; + return v1 + v2; + } + + @Test + public void test01() { + List accesses = compile("volatileFieldLoadFieldLoad", stressTestEarlyReads()); + + Assert.assertEquals(accesses.size(), 2); + Assert.assertEquals(accesses.get(0).getType(), VolatileAccess.class); + Assert.assertEquals(accesses.get(1).getType(), RegularAccess.class); + Assert.assertTrue(accesses.get(0).isRead()); + Assert.assertTrue(accesses.get(1).isRead()); + } + + public static int volatileFieldLoadVolatileFieldLoad() { + int v1 = VolatileAccess.field; + int v2 = VolatileAccess2.field; + return v1 + v2; + } + + @Test + public void test02() { + List accesses = compile("volatileFieldLoadVolatileFieldLoad", stressTestEarlyReads()); + + Assert.assertEquals(accesses.size(), 2); + Assert.assertEquals(accesses.get(0).getType(), VolatileAccess.class); + Assert.assertEquals(accesses.get(1).getType(), VolatileAccess2.class); + Assert.assertTrue(accesses.get(0).isRead()); + Assert.assertTrue(accesses.get(1).isRead()); + } + + public static int volatileFieldLoadVolatileFieldStore(int v2) { + int v1 = VolatileAccess.field; + VolatileAccess2.field = v2; + return v1; + } + + @Test + public void test03() { + List accesses = compile("volatileFieldLoadVolatileFieldStore"); + + Assert.assertEquals(accesses.size(), 2); + Assert.assertEquals(accesses.get(0).getType(), VolatileAccess.class); + Assert.assertEquals(accesses.get(1).getType(), VolatileAccess2.class); + Assert.assertTrue(accesses.get(0).isRead()); + Assert.assertTrue(accesses.get(1).isWrite()); + } + + public static int volatileFieldStoreVolatileFieldLoad(int v2) { + VolatileAccess.field = v2; + return VolatileAccess2.field; + } + + @Test + public void test04() { + List accesses = compile("volatileFieldStoreVolatileFieldLoad", stressTestEarlyReads()); + + Assert.assertEquals(accesses.size(), 2); + Assert.assertEquals(accesses.get(0).getType(), VolatileAccess.class); + Assert.assertEquals(accesses.get(1).getType(), VolatileAccess2.class); + Assert.assertTrue(accesses.get(0).isWrite()); + Assert.assertTrue(accesses.get(1).isRead()); + } + + public static int fieldLoadVolatileFieldStore(int v2) { + int v1 = RegularAccess.field; + VolatileAccess2.field = v2; + return v1; + } + + @Test + public void test05() { + List accesses = compile("fieldLoadVolatileFieldStore"); + + Assert.assertEquals(accesses.size(), 2); + Assert.assertEquals(accesses.get(0).getType(), RegularAccess.class); + Assert.assertEquals(accesses.get(1).getType(), VolatileAccess2.class); + Assert.assertTrue(accesses.get(0).isRead()); + Assert.assertTrue(accesses.get(1).isWrite()); + } + + public static void volatileFieldStoreVolatileFieldStore(int v1, int v2) { + VolatileAccess.field = v1; + VolatileAccess2.field = v2; + } + + @Test + public void test06() { + List accesses = compile("volatileFieldStoreVolatileFieldStore"); + + Assert.assertEquals(accesses.size(), 2); + Assert.assertEquals(accesses.get(0).getType(), VolatileAccess.class); + Assert.assertEquals(accesses.get(1).getType(), VolatileAccess2.class); + Assert.assertTrue(accesses.get(0).isWrite()); + Assert.assertTrue(accesses.get(1).isWrite()); + } + + private static OptionValues stressTestEarlyReads() { + EconomicMap, Object> overrides = OptionValues.newOptionMap(); + overrides.put(StressTestEarlyReads, true); + return new OptionValues(getInitialOptions(), overrides); + } + + static class TypePair { + private boolean isRead; + private Class type; + + TypePair(boolean isRead, Class type) { + this.isRead = isRead; + this.type = type; + } + + public boolean isRead() { + return isRead; + } + + public boolean isWrite() { + return !isRead; + } + + public Class getType() { + return type; + } + } + + private List compile(String test, OptionValues options) { + StructuredGraph graph = getFinalGraph(getResolvedJavaMethod(test), options); + return getAccesses(graph); + } + + private static List getAccesses(StructuredGraph graph) { + StructuredGraph.ScheduleResult schedule = graph.getLastSchedule(); + ControlFlowGraph cfg = schedule.getCFG(); + Block[] blocks = cfg.getBlocks(); + + return Arrays.stream(blocks).flatMap(b -> schedule.nodesFor(b).stream()).filter(n -> n instanceof MemoryAccess).map( + n -> new TypePair(n instanceof ReadNode, classForAccess((FixedAccessNode) n))).collect(Collectors.toList()); + } + + private List compile(String test) { + StructuredGraph graph = getFinalGraph(getResolvedJavaMethod(test)); + return getAccesses(graph); + } + + private static Class classForAccess(FixedAccessNode n) { + AddressNode address = n.getAddress(); + ValueNode base = address.getBase(); + Stamp stamp = base.stamp(NodeView.DEFAULT); + JVMCIBackend providers = JVMCI.getRuntime().getHostJVMCIBackend(); + MetaAccessProvider metaAccess = providers.getMetaAccess(); + ResolvedJavaType javaType = stamp.javaType(metaAccess); + Class mirror = ((HotSpotJVMCIRuntime) JVMCI.getRuntime()).getMirror(javaType); + if (mirror == Class.class && base instanceof ConstantNode) { + ConstantReflectionProvider constantReflection = providers.getConstantReflection(); + javaType = constantReflection.asJavaType(base.asConstant()); + mirror = ((HotSpotJVMCIRuntime) JVMCI.getRuntime()).getMirror(javaType); + } + return mirror; + } + +} diff --git a/compiler/src/org.graalvm.compiler.hotspot/src/org/graalvm/compiler/hotspot/meta/DefaultHotSpotLoweringProvider.java b/compiler/src/org.graalvm.compiler.hotspot/src/org/graalvm/compiler/hotspot/meta/DefaultHotSpotLoweringProvider.java index 2578ed9aebde..83fc91189931 100644 --- a/compiler/src/org.graalvm.compiler.hotspot/src/org/graalvm/compiler/hotspot/meta/DefaultHotSpotLoweringProvider.java +++ b/compiler/src/org.graalvm.compiler.hotspot/src/org/graalvm/compiler/hotspot/meta/DefaultHotSpotLoweringProvider.java @@ -646,7 +646,7 @@ private void lowerOSRStartNode(OSRStartNode osrStart) { // write the displaced mark to the correct stack slot AddressNode addressDisplacedMark = createOffsetAddress(graph, beginLockScope, runtime.getVMConfig().basicLockDisplacedHeaderOffset); - WriteNode writeStackSlot = graph.add(new WriteNode(addressDisplacedMark, DISPLACED_MARK_WORD_LOCATION, loadDisplacedHeader, BarrierType.NONE)); + WriteNode writeStackSlot = graph.add(new WriteNode(addressDisplacedMark, DISPLACED_MARK_WORD_LOCATION, loadDisplacedHeader, BarrierType.NONE, false)); graph.addBeforeFixed(migrationEnd, writeStackSlot); // load the lock object from the osr buffer @@ -776,7 +776,7 @@ private WriteNode createWriteHub(StructuredGraph graph, ValueNode object, ValueN } AddressNode address = createOffsetAddress(graph, object, runtime.getVMConfig().hubOffset); - return graph.add(new WriteNode(address, HUB_WRITE_LOCATION, writeValue, BarrierType.NONE)); + return graph.add(new WriteNode(address, HUB_WRITE_LOCATION, writeValue, BarrierType.NONE, false)); } @Override diff --git a/compiler/src/org.graalvm.compiler.hotspot/src/org/graalvm/compiler/hotspot/nodes/BeginLockScopeNode.java b/compiler/src/org.graalvm.compiler.hotspot/src/org/graalvm/compiler/hotspot/nodes/BeginLockScopeNode.java index 31660f8270ec..908dd8ab7ca8 100644 --- a/compiler/src/org.graalvm.compiler.hotspot/src/org/graalvm/compiler/hotspot/nodes/BeginLockScopeNode.java +++ b/compiler/src/org.graalvm.compiler.hotspot/src/org/graalvm/compiler/hotspot/nodes/BeginLockScopeNode.java @@ -73,7 +73,7 @@ public boolean hasSideEffect() { } @Override - public LocationIdentity getLocationIdentity() { + public LocationIdentity getKilledLocationIdentity() { return LocationIdentity.any(); } diff --git a/compiler/src/org.graalvm.compiler.hotspot/src/org/graalvm/compiler/hotspot/nodes/EndLockScopeNode.java b/compiler/src/org.graalvm.compiler.hotspot/src/org/graalvm/compiler/hotspot/nodes/EndLockScopeNode.java index b29a5442d39b..e1bc1fc94cb9 100644 --- a/compiler/src/org.graalvm.compiler.hotspot/src/org/graalvm/compiler/hotspot/nodes/EndLockScopeNode.java +++ b/compiler/src/org.graalvm.compiler.hotspot/src/org/graalvm/compiler/hotspot/nodes/EndLockScopeNode.java @@ -56,7 +56,7 @@ public boolean hasSideEffect() { } @Override - public LocationIdentity getLocationIdentity() { + public LocationIdentity getKilledLocationIdentity() { return LocationIdentity.any(); } diff --git a/compiler/src/org.graalvm.compiler.hotspot/src/org/graalvm/compiler/hotspot/nodes/StubForeignCallNode.java b/compiler/src/org.graalvm.compiler.hotspot/src/org/graalvm/compiler/hotspot/nodes/StubForeignCallNode.java index 25d10e92c632..5c0754def430 100644 --- a/compiler/src/org.graalvm.compiler.hotspot/src/org/graalvm/compiler/hotspot/nodes/StubForeignCallNode.java +++ b/compiler/src/org.graalvm.compiler.hotspot/src/org/graalvm/compiler/hotspot/nodes/StubForeignCallNode.java @@ -72,7 +72,7 @@ public ForeignCallDescriptor getDescriptor() { } @Override - public LocationIdentity[] getLocationIdentities() { + public LocationIdentity[] getKilledLocationIdentities() { LocationIdentity[] killedLocations = foreignCalls.getKilledLocations(descriptor); killedLocations = Arrays.copyOf(killedLocations, killedLocations.length + 1); killedLocations[killedLocations.length - 1] = HotSpotReplacementsUtil.PENDING_EXCEPTION_LOCATION; diff --git a/compiler/src/org.graalvm.compiler.hotspot/src/org/graalvm/compiler/hotspot/nodes/aot/InitializeKlassNode.java b/compiler/src/org.graalvm.compiler.hotspot/src/org/graalvm/compiler/hotspot/nodes/aot/InitializeKlassNode.java index 0cf5cea37112..814d4cd659a4 100644 --- a/compiler/src/org.graalvm.compiler.hotspot/src/org/graalvm/compiler/hotspot/nodes/aot/InitializeKlassNode.java +++ b/compiler/src/org.graalvm.compiler.hotspot/src/org/graalvm/compiler/hotspot/nodes/aot/InitializeKlassNode.java @@ -64,7 +64,7 @@ public boolean canDeoptimize() { } @Override - public LocationIdentity getLocationIdentity() { + public LocationIdentity getKilledLocationIdentity() { return LocationIdentity.any(); } } diff --git a/compiler/src/org.graalvm.compiler.hotspot/src/org/graalvm/compiler/hotspot/nodes/aot/InitializeKlassStubCall.java b/compiler/src/org.graalvm.compiler.hotspot/src/org/graalvm/compiler/hotspot/nodes/aot/InitializeKlassStubCall.java index f43da61d5c3c..4720b76e03b1 100644 --- a/compiler/src/org.graalvm.compiler.hotspot/src/org/graalvm/compiler/hotspot/nodes/aot/InitializeKlassStubCall.java +++ b/compiler/src/org.graalvm.compiler.hotspot/src/org/graalvm/compiler/hotspot/nodes/aot/InitializeKlassStubCall.java @@ -98,7 +98,7 @@ public boolean canDeoptimize() { } @Override - public LocationIdentity getLocationIdentity() { + public LocationIdentity getKilledLocationIdentity() { return LocationIdentity.any(); } diff --git a/compiler/src/org.graalvm.compiler.hotspot/src/org/graalvm/compiler/hotspot/nodes/aot/ResolveDynamicConstantNode.java b/compiler/src/org.graalvm.compiler.hotspot/src/org/graalvm/compiler/hotspot/nodes/aot/ResolveDynamicConstantNode.java index 0460c3709b42..0bed13c3154c 100644 --- a/compiler/src/org.graalvm.compiler.hotspot/src/org/graalvm/compiler/hotspot/nodes/aot/ResolveDynamicConstantNode.java +++ b/compiler/src/org.graalvm.compiler.hotspot/src/org/graalvm/compiler/hotspot/nodes/aot/ResolveDynamicConstantNode.java @@ -64,7 +64,7 @@ public boolean canDeoptimize() { } @Override - public LocationIdentity getLocationIdentity() { + public LocationIdentity getKilledLocationIdentity() { return LocationIdentity.any(); } diff --git a/compiler/src/org.graalvm.compiler.hotspot/src/org/graalvm/compiler/hotspot/nodes/aot/ResolveDynamicStubCall.java b/compiler/src/org.graalvm.compiler.hotspot/src/org/graalvm/compiler/hotspot/nodes/aot/ResolveDynamicStubCall.java index 3269912af728..7e59174ef1a4 100644 --- a/compiler/src/org.graalvm.compiler.hotspot/src/org/graalvm/compiler/hotspot/nodes/aot/ResolveDynamicStubCall.java +++ b/compiler/src/org.graalvm.compiler.hotspot/src/org/graalvm/compiler/hotspot/nodes/aot/ResolveDynamicStubCall.java @@ -93,7 +93,7 @@ public boolean canDeoptimize() { } @Override - public LocationIdentity getLocationIdentity() { + public LocationIdentity getKilledLocationIdentity() { return LocationIdentity.any(); } diff --git a/compiler/src/org.graalvm.compiler.hotspot/src/org/graalvm/compiler/hotspot/replacements/IdentityHashCodeNode.java b/compiler/src/org.graalvm.compiler.hotspot/src/org/graalvm/compiler/hotspot/replacements/IdentityHashCodeNode.java index 37bb631d6be3..235fa2f9293c 100644 --- a/compiler/src/org.graalvm.compiler.hotspot/src/org/graalvm/compiler/hotspot/replacements/IdentityHashCodeNode.java +++ b/compiler/src/org.graalvm.compiler.hotspot/src/org/graalvm/compiler/hotspot/replacements/IdentityHashCodeNode.java @@ -61,7 +61,7 @@ public IdentityHashCodeNode(ValueNode object) { } @Override - public LocationIdentity getLocationIdentity() { + public LocationIdentity getKilledLocationIdentity() { return HotSpotReplacementsUtil.MARK_WORD_LOCATION; } diff --git a/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/InvokeNode.java b/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/InvokeNode.java index ec36cd3426d6..d711fb71c46e 100644 --- a/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/InvokeNode.java +++ b/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/InvokeNode.java @@ -109,7 +109,7 @@ public InvokeNode(InvokeWithExceptionNode invoke) { this.bci = invoke.bci; this.polymorphic = invoke.polymorphic; this.useForInlining = invoke.useForInlining; - this.identity = invoke.getLocationIdentity(); + this.identity = invoke.getKilledLocationIdentity(); } @Override @@ -181,7 +181,7 @@ public Map getDebugProperties(Map map) { } @Override - public LocationIdentity getLocationIdentity() { + public LocationIdentity getKilledLocationIdentity() { return identity; } diff --git a/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/InvokeWithExceptionNode.java b/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/InvokeWithExceptionNode.java index 07f097746347..9c49f10cd57c 100644 --- a/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/InvokeWithExceptionNode.java +++ b/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/InvokeWithExceptionNode.java @@ -159,7 +159,7 @@ public int bci() { @Override public void setNext(FixedNode x) { if (x != null) { - this.setNext(KillingBeginNode.begin(x, getLocationIdentity())); + this.setNext(KillingBeginNode.begin(x, this.getKilledLocationIdentity())); } else { this.setNext(null); } @@ -192,7 +192,7 @@ public boolean hasSideEffect() { } @Override - public LocationIdentity getLocationIdentity() { + public LocationIdentity getKilledLocationIdentity() { return LocationIdentity.any(); } @@ -290,7 +290,7 @@ public int getSuccessorCount() { * code. */ public InvokeNode replaceWithInvoke() { - InvokeNode newInvoke = graph().add(new InvokeNode(callTarget, bci, stamp, getLocationIdentity())); + InvokeNode newInvoke = graph().add(new InvokeNode(callTarget, bci, stamp, this.getKilledLocationIdentity())); newInvoke.setStateAfter(stateAfter); newInvoke.setStateDuring(stateDuring); AbstractBeginNode oldException = this.exceptionEdge; diff --git a/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/KillingBeginNode.java b/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/KillingBeginNode.java index 586ae3d613b5..29ceb59d7576 100644 --- a/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/KillingBeginNode.java +++ b/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/KillingBeginNode.java @@ -58,7 +58,7 @@ public static AbstractBeginNode create(LocationIdentity locationIdentity) { } @Override - public LocationIdentity getLocationIdentity() { + public LocationIdentity getKilledLocationIdentity() { return locationIdentity; } } diff --git a/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/StartNode.java b/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/StartNode.java index 4775c606d1ed..475402d7b34a 100644 --- a/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/StartNode.java +++ b/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/StartNode.java @@ -49,7 +49,7 @@ public StartNode() { } @Override - public LocationIdentity getLocationIdentity() { + public LocationIdentity getKilledLocationIdentity() { return LocationIdentity.any(); } } diff --git a/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/calc/CompareNode.java b/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/calc/CompareNode.java index 847011ee82d2..fb66adb0ad9f 100644 --- a/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/calc/CompareNode.java +++ b/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/calc/CompareNode.java @@ -33,8 +33,11 @@ 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.graph.Node; import org.graalvm.compiler.graph.NodeClass; +import org.graalvm.compiler.graph.Position; import org.graalvm.compiler.graph.spi.Canonicalizable; +import org.graalvm.compiler.nodeinfo.InputType; import org.graalvm.compiler.nodeinfo.NodeInfo; import org.graalvm.compiler.nodes.BinaryOpLogicNode; import org.graalvm.compiler.nodes.ConstantNode; @@ -44,6 +47,7 @@ import org.graalvm.compiler.nodes.NodeView; import org.graalvm.compiler.nodes.StructuredGraph; import org.graalvm.compiler.nodes.ValueNode; +import org.graalvm.compiler.nodes.memory.VolatileReadNode; import org.graalvm.compiler.options.OptionValues; import jdk.vm.ci.meta.Constant; @@ -189,6 +193,19 @@ protected LogicNode canonicalizeSymmetricConstant(ConstantReflectionProvider con } else if (nonConstant instanceof ConvertNode) { ConvertNode convert = (ConvertNode) nonConstant; boolean multiUsage = (convert.asNode().hasMoreThanOneUsage() && convert.getValue().hasExactlyOneUsage()); + if (!multiUsage && convert.asNode().hasMoreThanOneUsage() && convert.getValue() instanceof VolatileReadNode) { + // Only account for data usages + VolatileReadNode read = (VolatileReadNode) convert.getValue(); + int nonMemoryEdges = 0; + for (Node u : read.usages()) { + for (Position pos : u.inputPositions()) { + if (pos.get(u) == read && pos.getInputType() != InputType.Memory) { + nonMemoryEdges++; + } + } + } + multiUsage = nonMemoryEdges == 1; + } if (convert instanceof IntegerConvertNode && multiUsage) { // Do not perform for integer convers if it could introduce // new live values. diff --git a/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/cfg/Block.java b/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/cfg/Block.java index 728da800ed47..bdece2167eec 100644 --- a/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/cfg/Block.java +++ b/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/cfg/Block.java @@ -260,10 +260,10 @@ private LocationSet calcKillLocations() { LocationSet result = new LocationSet(); for (FixedNode node : this.getNodes()) { if (node instanceof MemoryCheckpoint.Single) { - LocationIdentity identity = ((MemoryCheckpoint.Single) node).getLocationIdentity(); + LocationIdentity identity = ((MemoryCheckpoint.Single) node).getKilledLocationIdentity(); result.add(identity); } else if (node instanceof MemoryCheckpoint.Multi) { - for (LocationIdentity identity : ((MemoryCheckpoint.Multi) node).getLocationIdentities()) { + for (LocationIdentity identity : ((MemoryCheckpoint.Multi) node).getKilledLocationIdentities()) { result.add(identity); } } diff --git a/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/debug/StringToBytesNode.java b/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/debug/StringToBytesNode.java index 6661d135377d..afb92f7acd4b 100644 --- a/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/debug/StringToBytesNode.java +++ b/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/debug/StringToBytesNode.java @@ -66,7 +66,7 @@ public void lower(LoweringTool tool) { } @Override - public LocationIdentity getLocationIdentity() { + public LocationIdentity getKilledLocationIdentity() { return NamedLocationIdentity.getArrayLocation(JavaKind.Byte); } } diff --git a/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/extended/BytecodeExceptionNode.java b/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/extended/BytecodeExceptionNode.java index 88ac870bbaf5..a9583df9036b 100644 --- a/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/extended/BytecodeExceptionNode.java +++ b/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/extended/BytecodeExceptionNode.java @@ -100,7 +100,7 @@ public String toString(Verbosity verbosity) { } @Override - public LocationIdentity getLocationIdentity() { + public LocationIdentity getKilledLocationIdentity() { return LocationIdentity.any(); } diff --git a/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/extended/ForeignCallNode.java b/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/extended/ForeignCallNode.java index 24ddb3dc5f45..de4a66cb6ede 100644 --- a/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/extended/ForeignCallNode.java +++ b/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/extended/ForeignCallNode.java @@ -159,7 +159,7 @@ public ForeignCallDescriptor getDescriptor() { } @Override - public LocationIdentity[] getLocationIdentities() { + public LocationIdentity[] getKilledLocationIdentities() { return foreignCalls.getKilledLocations(descriptor); } diff --git a/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/extended/JavaWriteNode.java b/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/extended/JavaWriteNode.java index ae240af050d7..80a33b420129 100644 --- a/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/extended/JavaWriteNode.java +++ b/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/extended/JavaWriteNode.java @@ -79,4 +79,9 @@ public boolean isCompressible() { public Stamp getAccessStamp() { return StampFactory.forKind(writeKind); } + + @Override + public LocationIdentity getKilledLocationIdentity() { + return getLocationIdentity(); + } } diff --git a/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/extended/MembarNode.java b/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/extended/MembarNode.java index 35b73e3a2add..eadb0529f372 100644 --- a/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/extended/MembarNode.java +++ b/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/extended/MembarNode.java @@ -58,7 +58,7 @@ public MembarNode(int barriers, LocationIdentity location) { } @Override - public LocationIdentity getLocationIdentity() { + public LocationIdentity getKilledLocationIdentity() { return location; } diff --git a/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/extended/RawStoreNode.java b/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/extended/RawStoreNode.java index 1c2b454b6962..9efa6d5cbf34 100644 --- a/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/extended/RawStoreNode.java +++ b/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/extended/RawStoreNode.java @@ -145,4 +145,9 @@ protected ValueNode cloneAsArrayAccess(ValueNode location, LocationIdentity iden public FrameState getState() { return stateAfter; } + + @Override + public LocationIdentity getKilledLocationIdentity() { + return getLocationIdentity(); + } } diff --git a/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/extended/UnsafeMemoryStoreNode.java b/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/extended/UnsafeMemoryStoreNode.java index abc2ca5ffc0f..996f35af3347 100644 --- a/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/extended/UnsafeMemoryStoreNode.java +++ b/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/extended/UnsafeMemoryStoreNode.java @@ -77,7 +77,7 @@ public void lower(LoweringTool tool) { } @Override - public LocationIdentity getLocationIdentity() { + public LocationIdentity getKilledLocationIdentity() { return locationIdentity; } } diff --git a/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/java/AbstractCompareAndSwapNode.java b/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/java/AbstractCompareAndSwapNode.java index 1db5ab02e2f5..3e9314c1c774 100644 --- a/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/java/AbstractCompareAndSwapNode.java +++ b/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/java/AbstractCompareAndSwapNode.java @@ -93,4 +93,9 @@ public boolean canNullCheck() { public Stamp getAccessStamp() { return expectedValue.stamp(NodeView.DEFAULT).meet(newValue.stamp(NodeView.DEFAULT)).unrestricted(); } + + @Override + public LocationIdentity getKilledLocationIdentity() { + return getLocationIdentity(); + } } diff --git a/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/java/AbstractUnsafeCompareAndSwapNode.java b/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/java/AbstractUnsafeCompareAndSwapNode.java index 1e41e4570bac..e7f90db04896 100644 --- a/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/java/AbstractUnsafeCompareAndSwapNode.java +++ b/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/java/AbstractUnsafeCompareAndSwapNode.java @@ -97,7 +97,7 @@ public JavaKind getValueKind() { } @Override - public LocationIdentity getLocationIdentity() { + public LocationIdentity getKilledLocationIdentity() { return locationIdentity; } diff --git a/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/java/AtomicReadAndAddNode.java b/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/java/AtomicReadAndAddNode.java index c0f761de0b0a..1bd6e85fb17e 100644 --- a/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/java/AtomicReadAndAddNode.java +++ b/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/java/AtomicReadAndAddNode.java @@ -74,7 +74,7 @@ public ValueNode delta() { } @Override - public LocationIdentity getLocationIdentity() { + public LocationIdentity getKilledLocationIdentity() { return locationIdentity; } diff --git a/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/java/AtomicReadAndWriteNode.java b/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/java/AtomicReadAndWriteNode.java index 19e314a3646f..04b7ef25e3b4 100644 --- a/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/java/AtomicReadAndWriteNode.java +++ b/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/java/AtomicReadAndWriteNode.java @@ -80,7 +80,7 @@ public JavaKind getValueKind() { } @Override - public LocationIdentity getLocationIdentity() { + public LocationIdentity getKilledLocationIdentity() { return locationIdentity; } diff --git a/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/java/ExceptionObjectNode.java b/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/java/ExceptionObjectNode.java index e52fd3c2fb98..36c7251269a6 100644 --- a/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/java/ExceptionObjectNode.java +++ b/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/java/ExceptionObjectNode.java @@ -60,7 +60,7 @@ public ExceptionObjectNode(MetaAccessProvider metaAccess) { } @Override - public LocationIdentity getLocationIdentity() { + public LocationIdentity getKilledLocationIdentity() { return LocationIdentity.any(); } @@ -80,7 +80,7 @@ public void lower(LoweringTool tool) { * Now the lowering to BeginNode+LoadExceptionNode can be performed, since no more * deopts can float in between the begin node and the load exception node. */ - LocationIdentity locationsKilledByInvoke = ((InvokeWithExceptionNode) predecessor()).getLocationIdentity(); + LocationIdentity locationsKilledByInvoke = ((InvokeWithExceptionNode) predecessor()).getKilledLocationIdentity(); AbstractBeginNode entry = graph().add(KillingBeginNode.create(locationsKilledByInvoke)); LoadExceptionObjectNode loadException = graph().add(new LoadExceptionObjectNode(stamp(NodeView.DEFAULT))); diff --git a/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/java/LoweredAtomicReadAndWriteNode.java b/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/java/LoweredAtomicReadAndWriteNode.java index 428b0fbe45d3..4c94726fc2aa 100644 --- a/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/java/LoweredAtomicReadAndWriteNode.java +++ b/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/java/LoweredAtomicReadAndWriteNode.java @@ -103,4 +103,9 @@ public ValueNode getNewValue() { public Stamp getAccessStamp() { return stamp(NodeView.DEFAULT); } + + @Override + public LocationIdentity getKilledLocationIdentity() { + return getLocationIdentity(); + } } diff --git a/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/java/MonitorEnterNode.java b/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/java/MonitorEnterNode.java index 0ab5b694af7a..f894a2b06775 100644 --- a/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/java/MonitorEnterNode.java +++ b/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/java/MonitorEnterNode.java @@ -57,7 +57,7 @@ public MonitorEnterNode(NodeClass c, ValueNode objec } @Override - public LocationIdentity getLocationIdentity() { + public LocationIdentity getKilledLocationIdentity() { return LocationIdentity.any(); } diff --git a/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/java/MonitorExitNode.java b/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/java/MonitorExitNode.java index a2f383987c2b..4a1f694e1a57 100644 --- a/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/java/MonitorExitNode.java +++ b/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/java/MonitorExitNode.java @@ -70,7 +70,7 @@ public void clearEscapedValue() { } @Override - public LocationIdentity getLocationIdentity() { + public LocationIdentity getKilledLocationIdentity() { return LocationIdentity.any(); } diff --git a/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/java/RawMonitorEnterNode.java b/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/java/RawMonitorEnterNode.java index d533dae22dce..ec290f308aa5 100644 --- a/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/java/RawMonitorEnterNode.java +++ b/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/java/RawMonitorEnterNode.java @@ -64,7 +64,7 @@ public RawMonitorEnterNode(ValueNode object, ValueNode hub, MonitorIdNode monito } @Override - public LocationIdentity getLocationIdentity() { + public LocationIdentity getKilledLocationIdentity() { return LocationIdentity.any(); } diff --git a/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/memory/FixedAccessNode.java b/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/memory/FixedAccessNode.java index 70421d5acd49..dd50a7ae4ece 100644 --- a/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/memory/FixedAccessNode.java +++ b/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/memory/FixedAccessNode.java @@ -25,6 +25,7 @@ package org.graalvm.compiler.nodes.memory; import org.graalvm.compiler.core.common.type.Stamp; +import org.graalvm.compiler.graph.IterableNodeType; import org.graalvm.compiler.graph.NodeClass; import org.graalvm.compiler.nodeinfo.InputType; import org.graalvm.compiler.nodeinfo.NodeInfo; @@ -39,7 +40,7 @@ * does not include a null check on the object. */ @NodeInfo -public abstract class FixedAccessNode extends DeoptimizingFixedWithNextNode implements Access { +public abstract class FixedAccessNode extends DeoptimizingFixedWithNextNode implements Access, IterableNodeType { public static final NodeClass TYPE = NodeClass.create(FixedAccessNode.class); @OptionalInput(InputType.Guard) protected GuardingNode guard; diff --git a/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/memory/MemoryCheckpoint.java b/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/memory/MemoryCheckpoint.java index 3e701b82d6c7..5a0b452bf555 100644 --- a/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/memory/MemoryCheckpoint.java +++ b/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/memory/MemoryCheckpoint.java @@ -44,8 +44,7 @@ interface Single extends MemoryCheckpoint { * * @return the identity of the location killed by this node. */ - LocationIdentity getLocationIdentity(); - + LocationIdentity getKilledLocationIdentity(); } interface Multi extends MemoryCheckpoint { @@ -57,7 +56,7 @@ interface Multi extends MemoryCheckpoint { * * @return the identities of all locations killed by this node. */ - LocationIdentity[] getLocationIdentities(); + LocationIdentity[] getKilledLocationIdentities(); } diff --git a/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/memory/VolatileReadNode.java b/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/memory/VolatileReadNode.java new file mode 100644 index 000000000000..b0123fcead8e --- /dev/null +++ b/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/memory/VolatileReadNode.java @@ -0,0 +1,70 @@ +/* + * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2019, Red Hat Inc. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +package org.graalvm.compiler.nodes.memory; + +import org.graalvm.compiler.core.common.GraalOptions; +import org.graalvm.compiler.core.common.type.Stamp; +import org.graalvm.compiler.graph.NodeClass; +import org.graalvm.compiler.nodeinfo.NodeInfo; +import org.graalvm.compiler.nodes.memory.address.AddressNode; +import org.graalvm.word.LocationIdentity; + +import static org.graalvm.compiler.nodeinfo.InputType.Memory; +import static org.graalvm.compiler.nodeinfo.NodeCycles.CYCLES_2; +import static org.graalvm.compiler.nodeinfo.NodeSize.SIZE_1; + +@NodeInfo(nameTemplate = "Read#{p#location/s}", allowedUsageTypes = Memory, cycles = CYCLES_2, size = SIZE_1) +public class VolatileReadNode extends ReadNode implements MemoryCheckpoint.Single { + public static final NodeClass TYPE = NodeClass.create(VolatileReadNode.class); + + public VolatileReadNode(AddressNode address, LocationIdentity location, Stamp stamp, BarrierType barrierType) { + super(TYPE, address, location, stamp, null, barrierType, false, null); + assert GraalOptions.LateMembars.getValue(address.getOptions()); + } + + @SuppressWarnings("try") + @Override + public FloatingAccessNode asFloatingNode() { + throw new RuntimeException(); + } + + @Override + public boolean canFloat() { + return false; + } + + @Override + public LocationIdentity getKilledLocationIdentity() { + return LocationIdentity.any(); + } + + @Override + public boolean canNullCheck() { + return false; + } + +} diff --git a/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/memory/WriteNode.java b/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/memory/WriteNode.java index 1c2a6a853161..ce7b3e6a1ea7 100644 --- a/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/memory/WriteNode.java +++ b/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/memory/WriteNode.java @@ -44,13 +44,16 @@ public class WriteNode extends AbstractWriteNode implements LIRLowerableAccess, Canonicalizable { public static final NodeClass TYPE = NodeClass.create(WriteNode.class); + private final boolean volatileAccess; - public WriteNode(AddressNode address, LocationIdentity location, ValueNode value, BarrierType barrierType) { + public WriteNode(AddressNode address, LocationIdentity location, ValueNode value, BarrierType barrierType, boolean volatileAccess) { super(TYPE, address, location, value, barrierType); + this.volatileAccess = volatileAccess; } protected WriteNode(NodeClass c, AddressNode address, LocationIdentity location, ValueNode value, BarrierType barrierType) { super(c, address, location, value, barrierType); + this.volatileAccess = false; } @Override @@ -61,7 +64,7 @@ public void generate(NodeLIRBuilderTool gen) { @Override public boolean canNullCheck() { - return true; + return !isVolatile(); } @Override @@ -73,11 +76,23 @@ public Stamp getAccessStamp() { public Node canonical(CanonicalizerTool tool) { if (tool.canonicalizeReads() && hasExactlyOneUsage() && next() instanceof WriteNode) { WriteNode write = (WriteNode) next(); - if (write.lastLocationAccess == this && write.getAddress() == getAddress() && getAccessStamp().isCompatible(write.getAccessStamp())) { + if (write.lastLocationAccess == this && write.getAddress() == getAddress() && getAccessStamp().isCompatible(write.getAccessStamp()) && !isVolatile()) { write.setLastLocationAccess(getLastLocationAccess()); return write; } } return this; } + + @Override + public LocationIdentity getKilledLocationIdentity() { + if (isVolatile()) { + return LocationIdentity.any(); + } + return getLocationIdentity(); + } + + public boolean isVolatile() { + return volatileAccess; + } } diff --git a/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/virtual/CommitAllocationNode.java b/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/virtual/CommitAllocationNode.java index c4c49581c4b9..c806768f85ab 100644 --- a/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/virtual/CommitAllocationNode.java +++ b/compiler/src/org.graalvm.compiler.nodes/src/org/graalvm/compiler/nodes/virtual/CommitAllocationNode.java @@ -121,7 +121,7 @@ public void lower(LoweringTool tool) { } @Override - public LocationIdentity getLocationIdentity() { + public LocationIdentity getKilledLocationIdentity() { return locks.isEmpty() ? LocationIdentity.init() : LocationIdentity.any(); } diff --git a/compiler/src/org.graalvm.compiler.phases.common/src/org/graalvm/compiler/phases/common/FloatingReadPhase.java b/compiler/src/org.graalvm.compiler.phases.common/src/org/graalvm/compiler/phases/common/FloatingReadPhase.java index d49d52d5150a..352e6baa0e12 100644 --- a/compiler/src/org.graalvm.compiler.phases.common/src/org/graalvm/compiler/phases/common/FloatingReadPhase.java +++ b/compiler/src/org.graalvm.compiler.phases.common/src/org/graalvm/compiler/phases/common/FloatingReadPhase.java @@ -166,9 +166,9 @@ private static EconomicSet removeExternallyUsedNodes(EconomicSet set protected void processNode(FixedNode node, EconomicSet currentState) { if (node instanceof MemoryCheckpoint.Single) { - processIdentity(currentState, ((MemoryCheckpoint.Single) node).getLocationIdentity()); + processIdentity(currentState, ((MemoryCheckpoint.Single) node).getKilledLocationIdentity()); } else if (node instanceof MemoryCheckpoint.Multi) { - for (LocationIdentity identity : ((MemoryCheckpoint.Multi) node).getLocationIdentities()) { + for (LocationIdentity identity : ((MemoryCheckpoint.Multi) node).getKilledLocationIdentities()) { processIdentity(currentState, identity); } } @@ -312,7 +312,8 @@ protected MemoryMapImpl processNode(FixedNode node, MemoryMapImpl state) { if (createFloatingReads && node instanceof FloatableAccessNode) { processFloatable((FloatableAccessNode) node, state); - } else if (node instanceof MemoryCheckpoint.Single) { + } + if (node instanceof MemoryCheckpoint.Single) { processCheckpoint((MemoryCheckpoint.Single) node, state); } else if (node instanceof MemoryCheckpoint.Multi) { processCheckpoint((MemoryCheckpoint.Multi) node, state); @@ -355,11 +356,11 @@ private static void processAccess(MemoryAccess access, MemoryMapImpl state) { } private static void processCheckpoint(MemoryCheckpoint.Single checkpoint, MemoryMapImpl state) { - processIdentity(checkpoint.getLocationIdentity(), checkpoint, state); + processIdentity(checkpoint.getKilledLocationIdentity(), checkpoint, state); } private static void processCheckpoint(MemoryCheckpoint.Multi checkpoint, MemoryMapImpl state) { - for (LocationIdentity identity : checkpoint.getLocationIdentities()) { + for (LocationIdentity identity : checkpoint.getKilledLocationIdentities()) { processIdentity(identity, checkpoint, state); } } @@ -405,7 +406,7 @@ protected MemoryMapImpl afterSplit(AbstractBeginNode node, MemoryMapImpl oldStat * side it needs to choose by putting in the location identity on both successors. */ InvokeWithExceptionNode invoke = (InvokeWithExceptionNode) node.predecessor(); - result.lastMemorySnapshot.put(invoke.getLocationIdentity(), (MemoryCheckpoint) node); + result.lastMemorySnapshot.put(invoke.getKilledLocationIdentity(), (MemoryCheckpoint) node); } return result; } diff --git a/compiler/src/org.graalvm.compiler.phases.common/src/org/graalvm/compiler/phases/common/InsertMembarsPhase.java b/compiler/src/org.graalvm.compiler.phases.common/src/org/graalvm/compiler/phases/common/InsertMembarsPhase.java new file mode 100644 index 000000000000..a44bc857964b --- /dev/null +++ b/compiler/src/org.graalvm.compiler.phases.common/src/org/graalvm/compiler/phases/common/InsertMembarsPhase.java @@ -0,0 +1,66 @@ +/* + * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2019, Red Hat Inc. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +package org.graalvm.compiler.phases.common; + +import org.graalvm.compiler.nodes.StructuredGraph; +import org.graalvm.compiler.nodes.extended.MembarNode; +import org.graalvm.compiler.nodes.memory.FixedAccessNode; +import org.graalvm.compiler.nodes.memory.ReadNode; +import org.graalvm.compiler.nodes.memory.VolatileReadNode; +import org.graalvm.compiler.nodes.memory.WriteNode; +import org.graalvm.compiler.phases.Phase; + +import static jdk.vm.ci.code.MemoryBarriers.JMM_POST_VOLATILE_READ; +import static jdk.vm.ci.code.MemoryBarriers.JMM_POST_VOLATILE_WRITE; +import static jdk.vm.ci.code.MemoryBarriers.JMM_PRE_VOLATILE_READ; +import static jdk.vm.ci.code.MemoryBarriers.JMM_PRE_VOLATILE_WRITE; + +public class InsertMembarsPhase extends Phase { + @Override + protected void run(StructuredGraph graph) { + for (FixedAccessNode access : graph.getNodes(FixedAccessNode.TYPE)) { + if (access instanceof VolatileReadNode) { + ReadNode read = (ReadNode) access; + MembarNode preMembar = graph.add(new MembarNode(JMM_PRE_VOLATILE_READ)); + graph.addBeforeFixed(read, preMembar); + MembarNode postMembar = graph.add(new MembarNode(JMM_POST_VOLATILE_READ)); + graph.addAfterFixed(read, postMembar); + } else if (access instanceof WriteNode && ((WriteNode) access).isVolatile()) { + WriteNode write = (WriteNode) access; + MembarNode preMembar = graph.add(new MembarNode(JMM_PRE_VOLATILE_WRITE)); + graph.addBeforeFixed(write, preMembar); + MembarNode postMembar = graph.add(new MembarNode(JMM_POST_VOLATILE_WRITE)); + graph.addAfterFixed(write, postMembar); + } + } + } + + @Override + public float codeSizeIncrease() { + return 2f; + } +} diff --git a/compiler/src/org.graalvm.compiler.phases.common/src/org/graalvm/compiler/phases/common/LoweringPhase.java b/compiler/src/org.graalvm.compiler.phases.common/src/org/graalvm/compiler/phases/common/LoweringPhase.java index 00e30909227c..17f45fe55810 100644 --- a/compiler/src/org.graalvm.compiler.phases.common/src/org/graalvm/compiler/phases/common/LoweringPhase.java +++ b/compiler/src/org.graalvm.compiler.phases.common/src/org/graalvm/compiler/phases/common/LoweringPhase.java @@ -310,9 +310,9 @@ private static boolean checkPostNodeLowering(Node node, LoweringToolImpl lowerin */ boolean isAny = false; if (n instanceof MemoryCheckpoint.Single) { - isAny = ((MemoryCheckpoint.Single) n).getLocationIdentity().isAny(); + isAny = ((MemoryCheckpoint.Single) n).getKilledLocationIdentity().isAny(); } else { - for (LocationIdentity ident : ((MemoryCheckpoint.Multi) n).getLocationIdentities()) { + for (LocationIdentity ident : ((MemoryCheckpoint.Multi) n).getKilledLocationIdentities()) { if (ident.isAny()) { isAny = true; } diff --git a/compiler/src/org.graalvm.compiler.phases/src/org/graalvm/compiler/phases/schedule/MemoryScheduleVerification.java b/compiler/src/org.graalvm.compiler.phases/src/org/graalvm/compiler/phases/schedule/MemoryScheduleVerification.java index a8e8f7a8089a..0a2d712ffafd 100644 --- a/compiler/src/org.graalvm.compiler.phases/src/org/graalvm/compiler/phases/schedule/MemoryScheduleVerification.java +++ b/compiler/src/org.graalvm.compiler.phases/src/org/graalvm/compiler/phases/schedule/MemoryScheduleVerification.java @@ -80,10 +80,10 @@ protected EconomicSet processBlock(Block block, EconomicSet subList) { for (Node n : subList) { // Check if this node kills a node in the watch list. if (n instanceof MemoryCheckpoint.Single) { - LocationIdentity identity = ((MemoryCheckpoint.Single) n).getLocationIdentity(); + LocationIdentity identity = ((MemoryCheckpoint.Single) n).getKilledLocationIdentity(); killed.add(identity); if (killed.isAny()) { return; } } else if (n instanceof MemoryCheckpoint.Multi) { - for (LocationIdentity identity : ((MemoryCheckpoint.Multi) n).getLocationIdentities()) { + for (LocationIdentity identity : ((MemoryCheckpoint.Multi) n).getKilledLocationIdentities()) { killed.add(identity); if (killed.isAny()) { return; @@ -471,10 +471,10 @@ private static void checkWatchList(Block b, NodeMap nodeMap, NodeBitMap u if (watchList != null && !watchList.isEmpty()) { // Check if this node kills a node in the watch list. if (n instanceof MemoryCheckpoint.Single) { - LocationIdentity identity = ((MemoryCheckpoint.Single) n).getLocationIdentity(); + LocationIdentity identity = ((MemoryCheckpoint.Single) n).getKilledLocationIdentity(); checkWatchList(watchList, identity, b, result, nodeMap, unprocessed); } else if (n instanceof MemoryCheckpoint.Multi) { - for (LocationIdentity identity : ((MemoryCheckpoint.Multi) n).getLocationIdentities()) { + for (LocationIdentity identity : ((MemoryCheckpoint.Multi) n).getKilledLocationIdentities()) { checkWatchList(watchList, identity, b, result, nodeMap, unprocessed); } } @@ -1183,10 +1183,10 @@ private static void printNode(Node n) { Formatter buf = new Formatter(); buf.format("%s", n); if (n instanceof MemoryCheckpoint.Single) { - buf.format(" // kills %s", ((MemoryCheckpoint.Single) n).getLocationIdentity()); + buf.format(" // kills %s", ((MemoryCheckpoint.Single) n).getKilledLocationIdentity()); } else if (n instanceof MemoryCheckpoint.Multi) { buf.format(" // kills "); - for (LocationIdentity locid : ((MemoryCheckpoint.Multi) n).getLocationIdentities()) { + for (LocationIdentity locid : ((MemoryCheckpoint.Multi) n).getKilledLocationIdentities()) { buf.format("%s, ", locid); } } else if (n instanceof FloatingReadNode) { diff --git a/compiler/src/org.graalvm.compiler.replacements.amd64/src/org/graalvm/compiler/replacements/amd64/AMD64StringLatin1InflateNode.java b/compiler/src/org.graalvm.compiler.replacements.amd64/src/org/graalvm/compiler/replacements/amd64/AMD64StringLatin1InflateNode.java index a7803be37457..1509eaa71cff 100644 --- a/compiler/src/org.graalvm.compiler.replacements.amd64/src/org/graalvm/compiler/replacements/amd64/AMD64StringLatin1InflateNode.java +++ b/compiler/src/org.graalvm.compiler.replacements.amd64/src/org/graalvm/compiler/replacements/amd64/AMD64StringLatin1InflateNode.java @@ -82,7 +82,7 @@ public LocationIdentity getLocationIdentity() { } @Override - public LocationIdentity[] getLocationIdentities() { + public LocationIdentity[] getKilledLocationIdentities() { // Model write access via 'dst' using: return new LocationIdentity[]{NamedLocationIdentity.getArrayLocation(writeKind)}; } diff --git a/compiler/src/org.graalvm.compiler.replacements.amd64/src/org/graalvm/compiler/replacements/amd64/AMD64StringUTF16CompressNode.java b/compiler/src/org.graalvm.compiler.replacements.amd64/src/org/graalvm/compiler/replacements/amd64/AMD64StringUTF16CompressNode.java index de7c2d2a1635..a2904ffd77a2 100644 --- a/compiler/src/org.graalvm.compiler.replacements.amd64/src/org/graalvm/compiler/replacements/amd64/AMD64StringUTF16CompressNode.java +++ b/compiler/src/org.graalvm.compiler.replacements.amd64/src/org/graalvm/compiler/replacements/amd64/AMD64StringUTF16CompressNode.java @@ -82,7 +82,7 @@ public LocationIdentity getLocationIdentity() { } @Override - public LocationIdentity[] getLocationIdentities() { + public LocationIdentity[] getKilledLocationIdentities() { // Model write access via 'dst' using: return new LocationIdentity[]{NamedLocationIdentity.getArrayLocation(JavaKind.Byte)}; } diff --git a/compiler/src/org.graalvm.compiler.replacements.jdk9.test/src/org/graalvm/compiler/replacements/jdk9/test/VarHandleTest.java b/compiler/src/org.graalvm.compiler.replacements.jdk9.test/src/org/graalvm/compiler/replacements/jdk9/test/VarHandleTest.java index 9b719d48facb..9bf2c68585d8 100644 --- a/compiler/src/org.graalvm.compiler.replacements.jdk9.test/src/org/graalvm/compiler/replacements/jdk9/test/VarHandleTest.java +++ b/compiler/src/org.graalvm.compiler.replacements.jdk9.test/src/org/graalvm/compiler/replacements/jdk9/test/VarHandleTest.java @@ -162,12 +162,12 @@ private static int countAnyKill(StructuredGraph graph) { startNodes++; } else if (n instanceof MemoryCheckpoint.Single) { MemoryCheckpoint.Single single = (MemoryCheckpoint.Single) n; - if (single.getLocationIdentity().isAny()) { + if (single.getKilledLocationIdentity().isAny()) { anyKillCount++; } } else if (n instanceof MemoryCheckpoint.Multi) { MemoryCheckpoint.Multi multi = (MemoryCheckpoint.Multi) n; - for (LocationIdentity loc : multi.getLocationIdentities()) { + for (LocationIdentity loc : multi.getKilledLocationIdentities()) { if (loc.isAny()) { anyKillCount++; break; diff --git a/compiler/src/org.graalvm.compiler.replacements.test/src/org/graalvm/compiler/replacements/test/ObjectAccessTest.java b/compiler/src/org.graalvm.compiler.replacements.test/src/org/graalvm/compiler/replacements/test/ObjectAccessTest.java index 6dcd0d90b0cf..404e8112fa91 100644 --- a/compiler/src/org.graalvm.compiler.replacements.test/src/org/graalvm/compiler/replacements/test/ObjectAccessTest.java +++ b/compiler/src/org.graalvm.compiler.replacements.test/src/org/graalvm/compiler/replacements/test/ObjectAccessTest.java @@ -130,7 +130,7 @@ private static void assertWrite(StructuredGraph graph, JavaKind kind, boolean in Assert.assertEquals(graph.getParameter(0), address.getBase()); Assert.assertEquals(BytecodeFrame.AFTER_BCI, write.stateAfter().bci); - Assert.assertEquals(locationIdentity, write.getLocationIdentity()); + Assert.assertEquals(locationIdentity, write.getKilledLocationIdentity()); if (indexConvert) { SignExtendNode convert = (SignExtendNode) address.getOffset(); diff --git a/compiler/src/org.graalvm.compiler.replacements.test/src/org/graalvm/compiler/replacements/test/PointerTest.java b/compiler/src/org.graalvm.compiler.replacements.test/src/org/graalvm/compiler/replacements/test/PointerTest.java index fd7b44df515c..1cdd368aa735 100644 --- a/compiler/src/org.graalvm.compiler.replacements.test/src/org/graalvm/compiler/replacements/test/PointerTest.java +++ b/compiler/src/org.graalvm.compiler.replacements.test/src/org/graalvm/compiler/replacements/test/PointerTest.java @@ -149,7 +149,7 @@ private void assertWrite(StructuredGraph graph, JavaKind kind, boolean indexConv Assert.assertEquals(graph.getParameter(0), cast.getInput()); Assert.assertEquals(target.wordJavaKind, cast.stamp(NodeView.DEFAULT).getStackKind()); - Assert.assertEquals(locationIdentity, write.getLocationIdentity()); + Assert.assertEquals(locationIdentity, write.getKilledLocationIdentity()); if (indexConvert) { SignExtendNode convert = (SignExtendNode) address.getOffset(); diff --git a/compiler/src/org.graalvm.compiler.replacements/src/org/graalvm/compiler/replacements/DefaultJavaLoweringProvider.java b/compiler/src/org.graalvm.compiler.replacements/src/org/graalvm/compiler/replacements/DefaultJavaLoweringProvider.java index 36892cedc9e8..debfa5773ad3 100644 --- a/compiler/src/org.graalvm.compiler.replacements/src/org/graalvm/compiler/replacements/DefaultJavaLoweringProvider.java +++ b/compiler/src/org.graalvm.compiler.replacements/src/org/graalvm/compiler/replacements/DefaultJavaLoweringProvider.java @@ -47,6 +47,7 @@ import org.graalvm.compiler.api.directives.GraalDirectives; import org.graalvm.compiler.api.replacements.Snippet; import org.graalvm.compiler.api.replacements.SnippetReflectionProvider; +import org.graalvm.compiler.core.common.GraalOptions; import org.graalvm.compiler.core.common.LIRKind; import org.graalvm.compiler.core.common.spi.ForeignCallsProvider; import org.graalvm.compiler.core.common.type.AbstractPointerStamp; @@ -129,6 +130,7 @@ import org.graalvm.compiler.nodes.java.ValueCompareAndSwapNode; import org.graalvm.compiler.nodes.memory.HeapAccess.BarrierType; import org.graalvm.compiler.nodes.memory.ReadNode; +import org.graalvm.compiler.nodes.memory.VolatileReadNode; import org.graalvm.compiler.nodes.memory.WriteNode; import org.graalvm.compiler.nodes.memory.address.AddressNode; import org.graalvm.compiler.nodes.memory.address.IndexAddressNode; @@ -397,12 +399,17 @@ protected void lowerLoadFieldNode(LoadFieldNode loadField, LoweringTool tool) { AddressNode address = createFieldAddress(graph, object, field); assert address != null : "Field that is loaded must not be eliminated: " + field.getDeclaringClass().toJavaName(true) + "." + field.getName(); - ReadNode memoryRead = graph.add(new ReadNode(address, fieldLocationIdentity(field), loadStamp, fieldLoadBarrierType(field))); + ReadNode memoryRead = null; + if (loadField.isVolatile() && GraalOptions.LateMembars.getValue(graph.getOptions())) { + memoryRead = graph.add(new VolatileReadNode(address, fieldLocationIdentity(field), loadStamp, fieldLoadBarrierType(field))); + } else { + memoryRead = graph.add(new ReadNode(address, fieldLocationIdentity(field), loadStamp, fieldLoadBarrierType(field))); + } ValueNode readValue = implicitLoadConvert(graph, getStorageKind(field), memoryRead); loadField.replaceAtUsages(readValue); graph.replaceFixed(loadField, memoryRead); - if (loadField.isVolatile()) { + if (loadField.isVolatile() && !GraalOptions.LateMembars.getValue(graph.getOptions())) { MembarNode preMembar = graph.add(new MembarNode(JMM_PRE_VOLATILE_READ)); graph.addBeforeFixed(memoryRead, preMembar); MembarNode postMembar = graph.add(new MembarNode(JMM_POST_VOLATILE_READ)); @@ -419,11 +426,11 @@ protected void lowerStoreFieldNode(StoreFieldNode storeField, LoweringTool tool) AddressNode address = createFieldAddress(graph, object, field); assert address != null; - WriteNode memoryWrite = graph.add(new WriteNode(address, fieldLocationIdentity(field), value, fieldStoreBarrierType(storeField.field()))); + WriteNode memoryWrite = graph.add(new WriteNode(address, fieldLocationIdentity(field), value, fieldStoreBarrierType(storeField.field()), storeField.isVolatile())); memoryWrite.setStateAfter(storeField.stateAfter()); graph.replaceFixedWithFixed(storeField, memoryWrite); - if (storeField.isVolatile()) { + if (storeField.isVolatile() && !GraalOptions.LateMembars.getValue(graph.getOptions())) { MembarNode preMembar = graph.add(new MembarNode(JMM_PRE_VOLATILE_WRITE)); graph.addBeforeFixed(memoryWrite, preMembar); MembarNode postMembar = graph.add(new MembarNode(JMM_POST_VOLATILE_WRITE)); @@ -528,7 +535,7 @@ protected void lowerStoreIndexedNode(StoreIndexedNode storeIndexed, LoweringTool AddressNode address = createArrayIndexAddress(graph, array, elementKind, storeIndexed.index(), boundsCheck); WriteNode memoryWrite = graph.add(new WriteNode(address, NamedLocationIdentity.getArrayLocation(elementKind), implicitStoreConvert(graph, elementKind, value), - arrayStoreBarrierType(storeIndexed.elementKind()))); + arrayStoreBarrierType(storeIndexed.elementKind()), false)); memoryWrite.setGuard(boundsCheck); if (condition != null) { tool.createGuard(storeIndexed, condition, DeoptimizationReason.ArrayStoreException, DeoptimizationAction.InvalidateReprofile); @@ -623,7 +630,7 @@ protected void lowerCompareAndSwapNode(UnsafeCompareAndSwapNode cas) { AddressNode address = graph.unique(new OffsetAddressNode(cas.object(), cas.offset())); BarrierType barrierType = guessStoreBarrierType(cas.object(), expectedValue); - LogicCompareAndSwapNode atomicNode = graph.add(new LogicCompareAndSwapNode(address, cas.getLocationIdentity(), expectedValue, newValue, barrierType)); + LogicCompareAndSwapNode atomicNode = graph.add(new LogicCompareAndSwapNode(address, cas.getKilledLocationIdentity(), expectedValue, newValue, barrierType)); atomicNode.setStateAfter(cas.stateAfter()); graph.replaceFixedWithFixed(cas, atomicNode); } @@ -637,7 +644,7 @@ protected void lowerCompareAndExchangeNode(UnsafeCompareAndExchangeNode cas) { AddressNode address = graph.unique(new OffsetAddressNode(cas.object(), cas.offset())); BarrierType barrierType = guessStoreBarrierType(cas.object(), expectedValue); - ValueCompareAndSwapNode atomicNode = graph.add(new ValueCompareAndSwapNode(address, expectedValue, newValue, cas.getLocationIdentity(), barrierType)); + ValueCompareAndSwapNode atomicNode = graph.add(new ValueCompareAndSwapNode(address, expectedValue, newValue, cas.getKilledLocationIdentity(), barrierType)); ValueNode coercedNode = implicitLoadConvert(graph, valueKind, atomicNode, true); atomicNode.setStateAfter(cas.stateAfter()); cas.replaceAtUsages(coercedNode); @@ -653,7 +660,7 @@ protected void lowerAtomicReadAndWriteNode(AtomicReadAndWriteNode n) { AddressNode address = graph.unique(new OffsetAddressNode(n.object(), n.offset())); BarrierType barrierType = guessStoreBarrierType(n.object(), n.newValue()); LIRKind lirAccessKind = LIRKind.fromJavaKind(target.arch, valueKind); - LoweredAtomicReadAndWriteNode memoryRead = graph.add(new LoweredAtomicReadAndWriteNode(address, n.getLocationIdentity(), newValue, lirAccessKind, barrierType)); + LoweredAtomicReadAndWriteNode memoryRead = graph.add(new LoweredAtomicReadAndWriteNode(address, n.getKilledLocationIdentity(), newValue, lirAccessKind, barrierType)); memoryRead.setStateAfter(n.stateAfter()); ValueNode readValue = implicitLoadConvert(graph, valueKind, memoryRead); @@ -744,7 +751,7 @@ protected void lowerUnsafeStoreNode(RawStoreNode store) { JavaKind valueKind = store.accessKind(); ValueNode value = implicitStoreConvert(graph, valueKind, store.value(), compressible); AddressNode address = createUnsafeAddress(graph, store.object(), store.offset()); - WriteNode write = graph.add(new WriteNode(address, store.getLocationIdentity(), value, unsafeStoreBarrierType(store))); + WriteNode write = graph.add(new WriteNode(address, store.getKilledLocationIdentity(), value, unsafeStoreBarrierType(store), false)); write.setStateAfter(store.stateAfter()); graph.replaceFixedWithFixed(store, write); } @@ -755,7 +762,7 @@ protected void lowerUnsafeMemoryStoreNode(UnsafeMemoryStoreNode store) { JavaKind valueKind = store.getKind(); ValueNode value = implicitStoreConvert(graph, valueKind, store.getValue(), false); AddressNode address = graph.addOrUniqueWithInputs(OffsetAddressNode.create(store.getAddress())); - WriteNode write = graph.add(new WriteNode(address, store.getLocationIdentity(), value, BarrierType.NONE)); + WriteNode write = graph.add(new WriteNode(address, store.getKilledLocationIdentity(), value, BarrierType.NONE, false)); write.setStateAfter(store.stateAfter()); graph.replaceFixedWithFixed(store, write); } @@ -782,7 +789,7 @@ protected void lowerJavaReadNode(JavaReadNode read) { protected void lowerJavaWriteNode(JavaWriteNode write) { StructuredGraph graph = write.graph(); ValueNode value = implicitStoreConvert(graph, write.getWriteKind(), write.value(), write.isCompressible()); - WriteNode memoryWrite = graph.add(new WriteNode(write.getAddress(), write.getLocationIdentity(), value, write.getBarrierType())); + WriteNode memoryWrite = graph.add(new WriteNode(write.getAddress(), write.getKilledLocationIdentity(), value, write.getBarrierType(), false)); memoryWrite.setStateAfter(write.stateAfter()); graph.replaceFixedWithFixed(write, memoryWrite); memoryWrite.setGuard(write.getGuard()); @@ -842,7 +849,7 @@ protected void lowerCommitAllocationNode(CommitAllocationNode commit, LoweringTo barrierType = arrayInitializationBarrier(entryKind); } if (address != null) { - WriteNode write = new WriteNode(address, LocationIdentity.init(), implicitStoreConvert(graph, entryKind, value), barrierType); + WriteNode write = new WriteNode(address, LocationIdentity.init(), implicitStoreConvert(graph, entryKind, value), barrierType, false); graph.addAfterFixed(newObject, graph.add(write)); } } @@ -875,7 +882,7 @@ protected void lowerCommitAllocationNode(CommitAllocationNode commit, LoweringTo barrierType = arrayStoreBarrierType(virtual.entryKind(i)); } if (address != null) { - WriteNode write = new WriteNode(address, LocationIdentity.init(), implicitStoreConvert(graph, JavaKind.Object, allocValue), barrierType); + WriteNode write = new WriteNode(address, LocationIdentity.init(), implicitStoreConvert(graph, JavaKind.Object, allocValue), barrierType, false); graph.addBeforeFixed(commit, graph.add(write)); } } diff --git a/compiler/src/org.graalvm.compiler.replacements/src/org/graalvm/compiler/replacements/SnippetTemplate.java b/compiler/src/org.graalvm.compiler.replacements/src/org/graalvm/compiler/replacements/SnippetTemplate.java index 132bdd934775..f39d6c90479c 100644 --- a/compiler/src/org.graalvm.compiler.replacements/src/org/graalvm/compiler/replacements/SnippetTemplate.java +++ b/compiler/src/org.graalvm.compiler.replacements/src/org/graalvm/compiler/replacements/SnippetTemplate.java @@ -1284,7 +1284,7 @@ private boolean assertSnippetKills(ValueNode replacee) { if (replacee instanceof MemoryCheckpoint.Single) { // check if some node in snippet graph also kills the same location - LocationIdentity locationIdentity = ((MemoryCheckpoint.Single) replacee).getLocationIdentity(); + LocationIdentity locationIdentity = ((MemoryCheckpoint.Single) replacee).getKilledLocationIdentity(); if (locationIdentity.isAny()) { assert !(memoryMap.getLastLocationAccess(any()) instanceof MemoryAnchorNode) : replacee + " kills ANY_LOCATION, but snippet does not"; // if the replacee kills ANY_LOCATION, the snippet can kill arbitrary locations diff --git a/compiler/src/org.graalvm.compiler.replacements/src/org/graalvm/compiler/replacements/arraycopy/ArrayCopyCallNode.java b/compiler/src/org.graalvm.compiler.replacements/src/org/graalvm/compiler/replacements/arraycopy/ArrayCopyCallNode.java index e42de8d0c1f2..c77d298c9677 100644 --- a/compiler/src/org.graalvm.compiler.replacements/src/org/graalvm/compiler/replacements/arraycopy/ArrayCopyCallNode.java +++ b/compiler/src/org.graalvm.compiler.replacements/src/org/graalvm/compiler/replacements/arraycopy/ArrayCopyCallNode.java @@ -188,6 +188,11 @@ public LocationIdentity getLocationIdentity() { return locationIdentity; } + @Override + public LocationIdentity getKilledLocationIdentity() { + return getLocationIdentity(); + } + @NodeIntrinsic(hasSideEffect = true) private static native void arraycopy(Object src, int srcPos, Object dest, int destPos, int length, @ConstantNodeParameter JavaKind elementKind, @ConstantNodeParameter boolean aligned, @ConstantNodeParameter boolean disjoint, @ConstantNodeParameter boolean uninitialized, @ConstantNodeParameter int heapWordSize); diff --git a/compiler/src/org.graalvm.compiler.replacements/src/org/graalvm/compiler/replacements/arraycopy/ArrayCopyNode.java b/compiler/src/org.graalvm.compiler.replacements/src/org/graalvm/compiler/replacements/arraycopy/ArrayCopyNode.java index c3a3cdaef282..07a816cf0532 100644 --- a/compiler/src/org.graalvm.compiler.replacements/src/org/graalvm/compiler/replacements/arraycopy/ArrayCopyNode.java +++ b/compiler/src/org.graalvm.compiler.replacements/src/org/graalvm/compiler/replacements/arraycopy/ArrayCopyNode.java @@ -57,7 +57,7 @@ public ArrayCopyNode(int bci, ValueNode src, ValueNode srcPos, ValueNode dst, Va } @Override - public LocationIdentity getLocationIdentity() { + public LocationIdentity getKilledLocationIdentity() { if (!forceAnyLocation && elementKind == null) { elementKind = ArrayCopySnippets.Templates.selectComponentKind(this); } diff --git a/compiler/src/org.graalvm.compiler.replacements/src/org/graalvm/compiler/replacements/arraycopy/CheckcastArrayCopyCallNode.java b/compiler/src/org.graalvm.compiler.replacements/src/org/graalvm/compiler/replacements/arraycopy/CheckcastArrayCopyCallNode.java index 260de3d6987d..52e1a56f993e 100644 --- a/compiler/src/org.graalvm.compiler.replacements/src/org/graalvm/compiler/replacements/arraycopy/CheckcastArrayCopyCallNode.java +++ b/compiler/src/org.graalvm.compiler.replacements/src/org/graalvm/compiler/replacements/arraycopy/CheckcastArrayCopyCallNode.java @@ -146,7 +146,7 @@ public void lower(LoweringTool tool) { } @Override - public LocationIdentity getLocationIdentity() { + public LocationIdentity getKilledLocationIdentity() { /* * Because of restrictions that the memory graph of snippets matches the original node, * pretend that we kill any. diff --git a/compiler/src/org.graalvm.compiler.replacements/src/org/graalvm/compiler/replacements/arraycopy/GenericArrayCopyCallNode.java b/compiler/src/org.graalvm.compiler.replacements/src/org/graalvm/compiler/replacements/arraycopy/GenericArrayCopyCallNode.java index 2af89517f5e8..47dee771288f 100644 --- a/compiler/src/org.graalvm.compiler.replacements/src/org/graalvm/compiler/replacements/arraycopy/GenericArrayCopyCallNode.java +++ b/compiler/src/org.graalvm.compiler.replacements/src/org/graalvm/compiler/replacements/arraycopy/GenericArrayCopyCallNode.java @@ -102,7 +102,7 @@ private ValueNode objectAddress(ValueNode obj) { } @Override - public LocationIdentity getLocationIdentity() { + public LocationIdentity getKilledLocationIdentity() { return LocationIdentity.any(); } diff --git a/compiler/src/org.graalvm.compiler.replacements/src/org/graalvm/compiler/replacements/nodes/BasicArrayCopyNode.java b/compiler/src/org.graalvm.compiler.replacements/src/org/graalvm/compiler/replacements/nodes/BasicArrayCopyNode.java index aab3a582e841..3c7024e72324 100644 --- a/compiler/src/org.graalvm.compiler.replacements/src/org/graalvm/compiler/replacements/nodes/BasicArrayCopyNode.java +++ b/compiler/src/org.graalvm.compiler.replacements/src/org/graalvm/compiler/replacements/nodes/BasicArrayCopyNode.java @@ -127,6 +127,11 @@ public LocationIdentity getLocationIdentity() { return any(); } + @Override + public LocationIdentity getKilledLocationIdentity() { + return getLocationIdentity(); + } + @Override public MemoryNode getLastLocationAccess() { return lastLocationAccess; diff --git a/compiler/src/org.graalvm.compiler.replacements/src/org/graalvm/compiler/replacements/nodes/MacroStateSplitNode.java b/compiler/src/org.graalvm.compiler.replacements/src/org/graalvm/compiler/replacements/nodes/MacroStateSplitNode.java index 61c582d761f9..525b516075f4 100644 --- a/compiler/src/org.graalvm.compiler.replacements/src/org/graalvm/compiler/replacements/nodes/MacroStateSplitNode.java +++ b/compiler/src/org.graalvm.compiler.replacements/src/org/graalvm/compiler/replacements/nodes/MacroStateSplitNode.java @@ -75,7 +75,7 @@ public boolean hasSideEffect() { } @Override - public LocationIdentity getLocationIdentity() { + public LocationIdentity getKilledLocationIdentity() { return LocationIdentity.any(); } @@ -87,7 +87,7 @@ protected void replaceSnippetInvokes(StructuredGraph snippetGraph) { } assert invoke.stateAfter().bci == BytecodeFrame.AFTER_BCI; // Here we need to fix the bci of the invoke - InvokeNode newInvoke = snippetGraph.add(new InvokeNode(invoke.callTarget(), bci(), invoke.getLocationIdentity())); + InvokeNode newInvoke = snippetGraph.add(new InvokeNode(invoke.callTarget(), bci(), invoke.getKilledLocationIdentity())); newInvoke.setStateAfter(invoke.stateAfter()); snippetGraph.replaceFixedWithFixed((InvokeNode) invoke.asNode(), newInvoke); } diff --git a/compiler/src/org.graalvm.compiler.virtual/src/org/graalvm/compiler/virtual/phases/ea/PEReadEliminationClosure.java b/compiler/src/org.graalvm.compiler.virtual/src/org/graalvm/compiler/virtual/phases/ea/PEReadEliminationClosure.java index a264f8f8620e..3f4efa76b834 100644 --- a/compiler/src/org.graalvm.compiler.virtual/src/org/graalvm/compiler/virtual/phases/ea/PEReadEliminationClosure.java +++ b/compiler/src/org.graalvm.compiler.virtual/src/org/graalvm/compiler/virtual/phases/ea/PEReadEliminationClosure.java @@ -121,11 +121,11 @@ protected boolean processNode(Node node, PEReadEliminationBlockState state, Grap return processUnsafeStore((RawStoreNode) node, state, effects); } else if (node instanceof MemoryCheckpoint.Single) { COUNTER_MEMORYCHECKPOINT.increment(node.getDebug()); - LocationIdentity identity = ((MemoryCheckpoint.Single) node).getLocationIdentity(); + LocationIdentity identity = ((MemoryCheckpoint.Single) node).getKilledLocationIdentity(); processIdentity(state, identity); } else if (node instanceof MemoryCheckpoint.Multi) { COUNTER_MEMORYCHECKPOINT.increment(node.getDebug()); - for (LocationIdentity identity : ((MemoryCheckpoint.Multi) node).getLocationIdentities()) { + for (LocationIdentity identity : ((MemoryCheckpoint.Multi) node).getKilledLocationIdentities()) { processIdentity(state, identity); } } diff --git a/compiler/src/org.graalvm.compiler.virtual/src/org/graalvm/compiler/virtual/phases/ea/ReadEliminationClosure.java b/compiler/src/org.graalvm.compiler.virtual/src/org/graalvm/compiler/virtual/phases/ea/ReadEliminationClosure.java index 0d79bd563807..6b18337b1c77 100644 --- a/compiler/src/org.graalvm.compiler.virtual/src/org/graalvm/compiler/virtual/phases/ea/ReadEliminationClosure.java +++ b/compiler/src/org.graalvm.compiler.virtual/src/org/graalvm/compiler/virtual/phases/ea/ReadEliminationClosure.java @@ -135,9 +135,9 @@ protected boolean processNode(Node node, ReadEliminationBlockState state, GraphE } } else if (node instanceof WriteNode) { WriteNode write = (WriteNode) node; - if (write.getLocationIdentity().isSingle()) { + if (write.getKilledLocationIdentity().isSingle()) { ValueNode object = GraphUtil.unproxify(write.getAddress()); - LoadCacheEntry identifier = new LoadCacheEntry(object, write.getLocationIdentity()); + LoadCacheEntry identifier = new LoadCacheEntry(object, write.getKilledLocationIdentity()); ValueNode cachedValue = state.getCacheEntry(identifier); ValueNode value = getScalarAlias(write.value()); @@ -145,10 +145,10 @@ protected boolean processNode(Node node, ReadEliminationBlockState state, GraphE effects.deleteNode(write); deleted = true; } - processIdentity(state, write.getLocationIdentity()); + processIdentity(state, write.getKilledLocationIdentity()); state.addCacheEntry(identifier, value); } else { - processIdentity(state, write.getLocationIdentity()); + processIdentity(state, write.getKilledLocationIdentity()); } } else if (node instanceof UnsafeAccessNode) { ResolvedJavaType type = StampTool.typeOrNull(((UnsafeAccessNode) node).object()); @@ -170,9 +170,9 @@ protected boolean processNode(Node node, ReadEliminationBlockState state, GraphE } else { assert node instanceof RawStoreNode; RawStoreNode write = (RawStoreNode) node; - if (write.getLocationIdentity().isSingle()) { + if (write.getKilledLocationIdentity().isSingle()) { ValueNode object = GraphUtil.unproxify(write.object()); - UnsafeLoadCacheEntry identifier = new UnsafeLoadCacheEntry(object, write.offset(), write.getLocationIdentity()); + UnsafeLoadCacheEntry identifier = new UnsafeLoadCacheEntry(object, write.offset(), write.getKilledLocationIdentity()); ValueNode cachedValue = state.getCacheEntry(identifier); ValueNode value = getScalarAlias(write.value()); @@ -180,18 +180,18 @@ protected boolean processNode(Node node, ReadEliminationBlockState state, GraphE effects.deleteNode(write); deleted = true; } - processIdentity(state, write.getLocationIdentity()); + processIdentity(state, write.getKilledLocationIdentity()); state.addCacheEntry(identifier, value); } else { - processIdentity(state, write.getLocationIdentity()); + processIdentity(state, write.getKilledLocationIdentity()); } } } } else if (node instanceof MemoryCheckpoint.Single) { - LocationIdentity identity = ((MemoryCheckpoint.Single) node).getLocationIdentity(); + LocationIdentity identity = ((MemoryCheckpoint.Single) node).getKilledLocationIdentity(); processIdentity(state, identity); } else if (node instanceof MemoryCheckpoint.Multi) { - for (LocationIdentity identity : ((MemoryCheckpoint.Multi) node).getLocationIdentities()) { + for (LocationIdentity identity : ((MemoryCheckpoint.Multi) node).getKilledLocationIdentities()) { processIdentity(state, identity); } } diff --git a/substratevm/src/com.oracle.svm.core.graal/src/com/oracle/svm/core/graal/nodes/CEntryPointEnterNode.java b/substratevm/src/com.oracle.svm.core.graal/src/com/oracle/svm/core/graal/nodes/CEntryPointEnterNode.java index 367c96ddd0db..6d65dadf2d60 100644 --- a/substratevm/src/com.oracle.svm.core.graal/src/com/oracle/svm/core/graal/nodes/CEntryPointEnterNode.java +++ b/substratevm/src/com.oracle.svm.core.graal/src/com/oracle/svm/core/graal/nodes/CEntryPointEnterNode.java @@ -100,7 +100,7 @@ public void lower(LoweringTool tool) { } @Override - public LocationIdentity getLocationIdentity() { + public LocationIdentity getKilledLocationIdentity() { return LocationIdentity.any(); } } diff --git a/substratevm/src/com.oracle.svm.core.graal/src/com/oracle/svm/core/graal/nodes/CEntryPointLeaveNode.java b/substratevm/src/com.oracle.svm.core.graal/src/com/oracle/svm/core/graal/nodes/CEntryPointLeaveNode.java index 4493f40ab7ed..351399ce27d7 100644 --- a/substratevm/src/com.oracle.svm.core.graal/src/com/oracle/svm/core/graal/nodes/CEntryPointLeaveNode.java +++ b/substratevm/src/com.oracle.svm.core.graal/src/com/oracle/svm/core/graal/nodes/CEntryPointLeaveNode.java @@ -82,7 +82,7 @@ public void lower(LoweringTool tool) { } @Override - public LocationIdentity getLocationIdentity() { + public LocationIdentity getKilledLocationIdentity() { return LocationIdentity.any(); } } diff --git a/substratevm/src/com.oracle.svm.core.graal/src/com/oracle/svm/core/graal/nodes/DeoptEntryNode.java b/substratevm/src/com.oracle.svm.core.graal/src/com/oracle/svm/core/graal/nodes/DeoptEntryNode.java index 94dcde1d0948..1db4e013b78a 100644 --- a/substratevm/src/com.oracle.svm.core.graal/src/com/oracle/svm/core/graal/nodes/DeoptEntryNode.java +++ b/substratevm/src/com.oracle.svm.core.graal/src/com/oracle/svm/core/graal/nodes/DeoptEntryNode.java @@ -60,7 +60,7 @@ public boolean canDeoptimize() { } @Override - public LocationIdentity getLocationIdentity() { + public LocationIdentity getKilledLocationIdentity() { return LocationIdentity.any(); } } diff --git a/substratevm/src/com.oracle.svm.core.graal/src/com/oracle/svm/core/graal/nodes/DeoptTestNode.java b/substratevm/src/com.oracle.svm.core.graal/src/com/oracle/svm/core/graal/nodes/DeoptTestNode.java index 699582b1976d..56a8dd2c0ad4 100644 --- a/substratevm/src/com.oracle.svm.core.graal/src/com/oracle/svm/core/graal/nodes/DeoptTestNode.java +++ b/substratevm/src/com.oracle.svm.core.graal/src/com/oracle/svm/core/graal/nodes/DeoptTestNode.java @@ -81,7 +81,7 @@ public void lower(LoweringTool tool) { } @Override - public LocationIdentity getLocationIdentity() { + public LocationIdentity getKilledLocationIdentity() { return LocationIdentity.any(); } } diff --git a/substratevm/src/com.oracle.svm.core.graal/src/com/oracle/svm/core/graal/nodes/KillMemoryNode.java b/substratevm/src/com.oracle.svm.core.graal/src/com/oracle/svm/core/graal/nodes/KillMemoryNode.java index 4ce918fff400..a3ad4cbc02c7 100644 --- a/substratevm/src/com.oracle.svm.core.graal/src/com/oracle/svm/core/graal/nodes/KillMemoryNode.java +++ b/substratevm/src/com.oracle.svm.core.graal/src/com/oracle/svm/core/graal/nodes/KillMemoryNode.java @@ -48,7 +48,7 @@ protected KillMemoryNode(LocationIdentity killedIdentity) { } @Override - public LocationIdentity getLocationIdentity() { + public LocationIdentity getKilledLocationIdentity() { return killedIdentity; } diff --git a/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/nodes/CFunctionEpilogueNode.java b/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/nodes/CFunctionEpilogueNode.java index 6511d8cf55c0..dde0f42d5c61 100644 --- a/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/nodes/CFunctionEpilogueNode.java +++ b/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/nodes/CFunctionEpilogueNode.java @@ -69,7 +69,7 @@ public void lower(LoweringTool tool) { } @Override - public LocationIdentity getLocationIdentity() { + public LocationIdentity getKilledLocationIdentity() { return LocationIdentity.any(); } diff --git a/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/nodes/CFunctionPrologueNode.java b/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/nodes/CFunctionPrologueNode.java index db45ff263ce4..4f0e72d5c0a3 100644 --- a/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/nodes/CFunctionPrologueNode.java +++ b/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/nodes/CFunctionPrologueNode.java @@ -91,7 +91,7 @@ public void lower(LoweringTool tool) { } @Override - public LocationIdentity getLocationIdentity() { + public LocationIdentity getKilledLocationIdentity() { return LocationIdentity.any(); }