jdk-sandbox: comparison src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.phases.common/src/org/graalvm/compiler/phases/common/FloatingReadPhase.java

equal deleted inserted replaced

-:1a8d65e71a66
+:aec7bf35d6f5
 import org.graalvm.compiler.nodes.InvokeWithExceptionNode;
 import org.graalvm.compiler.nodes.LoopBeginNode;
 import org.graalvm.compiler.nodes.LoopEndNode;
 import org.graalvm.compiler.nodes.LoopExitNode;
 import org.graalvm.compiler.nodes.PhiNode;
+import org.graalvm.compiler.nodes.ProxyNode;
 import org.graalvm.compiler.nodes.ReturnNode;
 import org.graalvm.compiler.nodes.StartNode;
 import org.graalvm.compiler.nodes.StructuredGraph;
 import org.graalvm.compiler.nodes.ValueNodeUtil;
 import org.graalvm.compiler.nodes.calc.FloatingNode;
 return set;
 }
 protected void processNode(FixedNode node, EconomicSet<LocationIdentity> 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);
 }
 }
 }
 isPhi = true;
 }
 }
 mergedStatesCount++;
 }
-newState.lastMemorySnapshot.put(key, merged);
+newState.getMap().put(key, merged);
 }
 return newState;
 }
 this.createMemoryMapNodes = createMemoryMapNodes;
 }
 @Override
 protected MemoryMapImpl processNode(FixedNode node, MemoryMapImpl state) {
+if (node instanceof LoopExitNode) {
+final LoopExitNode loopExitNode = (LoopExitNode) node;
+final EconomicSet<LocationIdentity> modifiedInLoop = modifiedInLoops.get(loopExitNode.loopBegin());
+final boolean anyModified = modifiedInLoop.contains(LocationIdentity.any());
+state.getMap().replaceAll((locationIdentity, memoryNode) -> (anyModified || modifiedInLoop.contains(locationIdentity))
+? ProxyNode.forMemory(memoryNode, loopExitNode, locationIdentity)
+: memoryNode);
+}
 if (node instanceof MemoryAnchorNode) {
 processAnchor((MemoryAnchorNode) node, state);
 return state;
 }
 processAccess((MemoryAccess) node, 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);
 }
 assert MemoryCheckpoint.TypeAssertion.correctType(node) : node;
 if (createMemoryMapNodes && node instanceof ReturnNode) {
-((ReturnNode) node).setMemoryMap(node.graph().unique(new MemoryMapNode(state.lastMemorySnapshot)));
+((ReturnNode) node).setMemoryMap(node.graph().unique(new MemoryMapNode(state.getMap())));
 }
 return state;
 }
 /**
 access.setLastLocationAccess(lastLocationAccess);
 }
 }
 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);
 }
 }
 private static void processIdentity(LocationIdentity identity, MemoryCheckpoint checkpoint, MemoryMapImpl state) {
 if (identity.isAny()) {
-state.lastMemorySnapshot.clear();
+state.getMap().clear();
 }
 if (identity.isMutable()) {
-state.lastMemorySnapshot.put(identity, checkpoint);
+state.getMap().put(identity, checkpoint);
 }
 }
 @SuppressWarnings("try")
 private static void processFloatable(FloatableAccessNode accessNode, MemoryMapImpl state) {
 * schedule anything immediately after the invoke. It can only schedule in the
 * normal or exceptional successor - and we have to tell the scheduler here which
 * 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.getMap().put(invoke.getKilledLocationIdentity(), (MemoryCheckpoint) node);
 }
 return result;
 }
 @Override
 EconomicSet<LocationIdentity> modifiedLocations = modifiedInLoops.get(loop);
 EconomicMap<LocationIdentity, MemoryPhiNode> phis = EconomicMap.create(Equivalence.DEFAULT);
 if (modifiedLocations.contains(LocationIdentity.any())) {
 // create phis for all locations if ANY is modified in the loop
 modifiedLocations = EconomicSet.create(Equivalence.DEFAULT, modifiedLocations);
-modifiedLocations.addAll(initialState.lastMemorySnapshot.getKeys());
+modifiedLocations.addAll(initialState.getMap().getKeys());
 }
 for (LocationIdentity location : modifiedLocations) {
 createMemoryPhi(loop, initialState, phis, location);
 }
-initialState.lastMemorySnapshot.putAll(phis);
+initialState.getMap().putAll(phis);
 LoopInfo<MemoryMapImpl> loopInfo = ReentrantNodeIterator.processLoop(this, loop, initialState);
 UnmodifiableMapCursor<LoopEndNode, MemoryMapImpl> endStateCursor = loopInfo.endStates.getEntries();
 while (endStateCursor.advance()) {

changeset 58877	aec7bf35d6f5
parent 55509	d58442b8abc1