# HG changeset patch
# User Lukas Stadler <lukas.stadler@jku.at>
# Date 1368802033 -7200
# Node ID a8a5d5832deffcb87666f104c6abe10bcdaab7c6
# Parent  12fdb8fe0a35d9a902e28d27197b739f1175f7bb
first step towards extensibility of the escape analysis phase

diff -r 12fdb8fe0a35 -r a8a5d5832def graal/com.oracle.graal.phases/src/com/oracle/graal/phases/graph/ReentrantBlockIterator.java
--- a/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/graph/ReentrantBlockIterator.java	Fri May 17 15:41:39 2013 +0200
+++ b/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/graph/ReentrantBlockIterator.java	Fri May 17 16:47:13 2013 +0200
@@ -37,6 +37,8 @@
 
     public abstract static class BlockIteratorClosure<StateT> {
 
+        protected abstract StateT getInitialState();
+
         protected abstract StateT processBlock(Block block, StateT currentState);
 
         protected abstract StateT merge(Block merge, List<StateT> states);
@@ -70,7 +72,11 @@
         return info;
     }
 
-    public static <StateT> IdentityHashMap<FixedNode, StateT> apply(BlockIteratorClosure<StateT> closure, Block start, StateT initialState, Set<Block> boundary) {
+    public static <StateT> void apply(BlockIteratorClosure<StateT> closure, Block start) {
+        apply(closure, start, closure.getInitialState(), null);
+    }
+
+    private static <StateT> IdentityHashMap<FixedNode, StateT> apply(BlockIteratorClosure<StateT> closure, Block start, StateT initialState, Set<Block> boundary) {
         Deque<Block> blockQueue = new ArrayDeque<>();
         /*
          * States are stored on EndNodes before merges, and on BeginNodes after ControlSplitNodes.
diff -r 12fdb8fe0a35 -r a8a5d5832def graal/com.oracle.graal.phases/src/com/oracle/graal/phases/schedule/SchedulePhase.java
--- a/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/schedule/SchedulePhase.java	Fri May 17 15:41:39 2013 +0200
+++ b/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/schedule/SchedulePhase.java	Fri May 17 16:47:13 2013 +0200
@@ -84,6 +84,11 @@
     private class MemoryScheduleClosure extends BlockIteratorClosure<HashSet<FloatingReadNode>> {
 
         @Override
+        protected HashSet<FloatingReadNode> getInitialState() {
+            return new HashSet<>();
+        }
+
+        @Override
         protected HashSet<FloatingReadNode> processBlock(Block block, HashSet<FloatingReadNode> currentState) {
             for (Node node : getBlockToNodesMap().get(block)) {
                 if (node instanceof FloatingReadNode) {
@@ -184,7 +189,7 @@
             sortNodesWithinBlocks(graph, SchedulingStrategy.EARLIEST);
 
             MemoryScheduleClosure closure = new MemoryScheduleClosure();
-            ReentrantBlockIterator.apply(closure, getCFG().getStartBlock(), new HashSet<FloatingReadNode>(), null);
+            ReentrantBlockIterator.apply(closure, getCFG().getStartBlock());
 
             cfg.clearNodeToBlock();
             blockToNodesMap = new BlockMap<>(cfg);
diff -r 12fdb8fe0a35 -r a8a5d5832def graal/com.oracle.graal.virtual/src/com/oracle/graal/virtual/phases/ea/BlockState.java
--- a/graal/com.oracle.graal.virtual/src/com/oracle/graal/virtual/phases/ea/BlockState.java	Fri May 17 15:41:39 2013 +0200
+++ b/graal/com.oracle.graal.virtual/src/com/oracle/graal/virtual/phases/ea/BlockState.java	Fri May 17 16:47:13 2013 +0200
@@ -22,8 +22,6 @@
  */
 package com.oracle.graal.virtual.phases.ea;
 
-import static com.oracle.graal.virtual.phases.ea.PartialEscapeAnalysisPhase.*;
-
 import java.util.*;
 
 import com.oracle.graal.api.meta.*;
@@ -159,7 +157,7 @@
 
     private void materializeWithCommit(FixedNode fixed, VirtualObjectNode virtual, List<AllocatedObjectNode> objects, List<int[]> locks, List<ValueNode> values, List<ValueNode> otherAllocations,
                     EscapeState state) {
-        trace("materializing %s", virtual);
+        VirtualUtil.trace("materializing %s", virtual);
         ObjectState obj = getObjectState(virtual);
 
         ValueNode[] entries = obj.getEntries();
@@ -241,29 +239,34 @@
         return objectStates + " " + readCache;
     }
 
-    public static BlockState meetAliases(List<BlockState> states) {
+    public BlockState meetAliases(List<? extends BlockState> states) {
         BlockState newState = new BlockState();
 
-        newState.objectAliases.putAll(states.get(0).objectAliases);
+        BlockState firstState = states.get(0);
+        newState.objectAliases.putAll(firstState.objectAliases);
         for (int i = 1; i < states.size(); i++) {
             BlockState state = states.get(i);
-            for (Map.Entry<ValueNode, VirtualObjectNode> entry : states.get(0).objectAliases.entrySet()) {
+            Iterator<Map.Entry<ValueNode, VirtualObjectNode>> iter = newState.objectAliases.entrySet().iterator();
+            while (iter.hasNext()) {
+                Map.Entry<ValueNode, VirtualObjectNode> entry = iter.next();
                 if (state.objectAliases.containsKey(entry.getKey())) {
                     assert state.objectAliases.get(entry.getKey()) == entry.getValue();
                 } else {
-                    newState.objectAliases.remove(entry.getKey());
+                    iter.remove();
                 }
             }
         }
 
-        newState.scalarAliases.putAll(states.get(0).scalarAliases);
+        newState.scalarAliases.putAll(firstState.scalarAliases);
         for (int i = 1; i < states.size(); i++) {
             BlockState state = states.get(i);
-            for (Map.Entry<ValueNode, ValueNode> entry : states.get(0).scalarAliases.entrySet()) {
+            Iterator<Map.Entry<ValueNode, ValueNode>> iter = newState.scalarAliases.entrySet().iterator();
+            while (iter.hasNext()) {
+                Map.Entry<ValueNode, ValueNode> entry = iter.next();
                 if (state.scalarAliases.containsKey(entry.getKey())) {
                     assert state.scalarAliases.get(entry.getKey()) == entry.getValue();
                 } else {
-                    newState.scalarAliases.remove(entry.getKey());
+                    iter.remove();
                 }
             }
         }
diff -r 12fdb8fe0a35 -r a8a5d5832def graal/com.oracle.graal.virtual/src/com/oracle/graal/virtual/phases/ea/GraphEffectList.java
--- a/graal/com.oracle.graal.virtual/src/com/oracle/graal/virtual/phases/ea/GraphEffectList.java	Fri May 17 15:41:39 2013 +0200
+++ b/graal/com.oracle.graal.virtual/src/com/oracle/graal/virtual/phases/ea/GraphEffectList.java	Fri May 17 16:47:13 2013 +0200
@@ -215,7 +215,7 @@
                 FixedNode next = node.next();
                 node.setNext(null);
                 node.replaceAtPredecessor(next);
-                obsoleteNodes.add(node);
+                assert obsoleteNodes.add(node);
             }
         });
     }
@@ -250,7 +250,7 @@
                     FixedNode next = ((FixedWithNextNode) node).next();
                     ((FixedWithNextNode) node).setNext(null);
                     node.replaceAtPredecessor(next);
-                    obsoleteNodes.add(node);
+                    assert obsoleteNodes.add(node);
                 }
             }
         });
diff -r 12fdb8fe0a35 -r a8a5d5832def graal/com.oracle.graal.virtual/src/com/oracle/graal/virtual/phases/ea/PartialEscapeAnalysisPhase.java
--- a/graal/com.oracle.graal.virtual/src/com/oracle/graal/virtual/phases/ea/PartialEscapeAnalysisPhase.java	Fri May 17 15:41:39 2013 +0200
+++ b/graal/com.oracle.graal.virtual/src/com/oracle/graal/virtual/phases/ea/PartialEscapeAnalysisPhase.java	Fri May 17 16:47:13 2013 +0200
@@ -25,7 +25,6 @@
 import java.util.*;
 import java.util.concurrent.*;
 
-import com.oracle.graal.api.meta.*;
 import com.oracle.graal.debug.*;
 import com.oracle.graal.graph.*;
 import com.oracle.graal.nodes.*;
@@ -42,6 +41,13 @@
 
 public class PartialEscapeAnalysisPhase extends BasePhase<HighTierContext> {
 
+    public abstract static class Closure<T> extends ReentrantBlockIterator.BlockIteratorClosure<T> {
+
+        public abstract boolean hasChanged();
+
+        public abstract void applyEffects();
+    }
+
     private final CustomCanonicalizer customCanonicalizer;
     private final boolean iterative;
     private final boolean readElimination;
@@ -56,26 +62,20 @@
         this.readElimination = readElimination;
     }
 
-    public static final void trace(String format, Object... obj) {
-        if (GraalOptions.TraceEscapeAnalysis) {
-            Debug.log(format, obj);
-        }
-    }
-
     @Override
     protected void run(StructuredGraph graph, HighTierContext context) {
         runAnalysis(graph, context);
     }
 
     public boolean runAnalysis(final StructuredGraph graph, final HighTierContext context) {
-        if (!matches(graph, GraalOptions.EscapeAnalyzeOnly)) {
+        if (!VirtualUtil.matches(graph, GraalOptions.EscapeAnalyzeOnly)) {
             return false;
         }
 
         if (!readElimination) {
             boolean analyzableNodes = false;
             for (Node node : graph.getNodes()) {
-                if (node instanceof VirtualizableRoot) {
+                if (node instanceof VirtualizableAllocation) {
                     analyzableNodes = true;
                     break;
                 }
@@ -95,18 +95,17 @@
 
                     SchedulePhase schedule = new SchedulePhase();
                     schedule.apply(graph, false);
-                    PartialEscapeClosure closure = new PartialEscapeClosure(graph.createNodeBitMap(), schedule, context.getRuntime(), context.getAssumptions());
-                    ReentrantBlockIterator.apply(closure, schedule.getCFG().getStartBlock(), new BlockState(), null);
+                    Closure<?> closure = createAnalysisClosure(context, schedule);
+                    ReentrantBlockIterator.apply(closure, schedule.getCFG().getStartBlock());
 
                     if (!closure.hasChanged()) {
                         return false;
                     }
 
                     // apply the effects collected during the escape analysis iteration
-                    List<Node> obsoleteNodes = closure.applyEffects(graph);
+                    closure.applyEffects();
 
                     Debug.dump(graph, "after PartialEscapeAnalysis iteration");
-                    assert noObsoleteNodes(graph, obsoleteNodes);
 
                     new DeadCodeEliminationPhase().apply(graph);
 
@@ -124,85 +123,8 @@
         return changed;
     }
 
-    private static boolean matches(StructuredGraph graph, String filter) {
-        if (filter != null) {
-            if (filter.startsWith("~")) {
-                ResolvedJavaMethod method = graph.method();
-                return method == null || !MetaUtil.format("%H.%n", method).contains(filter.substring(1));
-            } else {
-                ResolvedJavaMethod method = graph.method();
-                return method != null && MetaUtil.format("%H.%n", method).contains(filter);
-            }
-        }
-        return true;
-    }
-
-    static boolean noObsoleteNodes(StructuredGraph graph, List<Node> obsoleteNodes) {
-        // helper code that determines the paths that keep obsolete nodes alive:
-
-        NodeFlood flood = graph.createNodeFlood();
-        IdentityHashMap<Node, Node> path = new IdentityHashMap<>();
-        flood.add(graph.start());
-        for (Node current : flood) {
-            if (current instanceof AbstractEndNode) {
-                AbstractEndNode end = (AbstractEndNode) current;
-                flood.add(end.merge());
-                if (!path.containsKey(end.merge())) {
-                    path.put(end.merge(), end);
-                }
-            } else {
-                for (Node successor : current.successors()) {
-                    flood.add(successor);
-                    if (!path.containsKey(successor)) {
-                        path.put(successor, current);
-                    }
-                }
-            }
-        }
-
-        for (Node node : obsoleteNodes) {
-            if (node instanceof FixedNode) {
-                assert !flood.isMarked(node) : node;
-            }
-        }
-
-        for (Node node : graph.getNodes()) {
-            if (node instanceof LocalNode) {
-                flood.add(node);
-            }
-            if (flood.isMarked(node)) {
-                for (Node input : node.inputs()) {
-                    flood.add(input);
-                    if (!path.containsKey(input)) {
-                        path.put(input, node);
-                    }
-                }
-            }
-        }
-        for (Node current : flood) {
-            for (Node input : current.inputs()) {
-                flood.add(input);
-                if (!path.containsKey(input)) {
-                    path.put(input, current);
-                }
-            }
-        }
-        boolean success = true;
-        for (Node node : obsoleteNodes) {
-            if (flood.isMarked(node)) {
-                TTY.print("offending node path:");
-                Node current = node;
-                while (current != null) {
-                    TTY.println(current.toString());
-                    current = path.get(current);
-                    if (current != null && current instanceof FixedNode && !obsoleteNodes.contains(current)) {
-                        break;
-                    }
-                }
-                success = false;
-            }
-        }
-        return success;
+    protected Closure<?> createAnalysisClosure(final HighTierContext context, SchedulePhase schedule) {
+        return new PartialEscapeClosure<>(schedule, context.getRuntime(), context.getAssumptions());
     }
 
     public static Map<Invoke, Double> getHints(StructuredGraph graph) {
diff -r 12fdb8fe0a35 -r a8a5d5832def graal/com.oracle.graal.virtual/src/com/oracle/graal/virtual/phases/ea/PartialEscapeClosure.java
--- a/graal/com.oracle.graal.virtual/src/com/oracle/graal/virtual/phases/ea/PartialEscapeClosure.java	Fri May 17 15:41:39 2013 +0200
+++ b/graal/com.oracle.graal.virtual/src/com/oracle/graal/virtual/phases/ea/PartialEscapeClosure.java	Fri May 17 16:47:13 2013 +0200
@@ -22,8 +22,6 @@
  */
 package com.oracle.graal.virtual.phases.ea;
 
-import static com.oracle.graal.virtual.phases.ea.PartialEscapeAnalysisPhase.*;
-
 import java.util.*;
 
 import com.oracle.graal.api.code.*;
@@ -34,8 +32,8 @@
 import com.oracle.graal.nodes.PhiNode.PhiType;
 import com.oracle.graal.nodes.VirtualState.NodeClosure;
 import com.oracle.graal.nodes.cfg.*;
+import com.oracle.graal.nodes.extended.*;
 import com.oracle.graal.nodes.extended.LocationNode.LocationIdentity;
-import com.oracle.graal.nodes.extended.*;
 import com.oracle.graal.nodes.java.*;
 import com.oracle.graal.nodes.spi.*;
 import com.oracle.graal.nodes.spi.Virtualizable.EscapeState;
@@ -49,7 +47,7 @@
 import com.oracle.graal.virtual.phases.ea.BlockState.ReadCacheEntry;
 import com.oracle.graal.virtual.phases.ea.EffectList.Effect;
 
-class PartialEscapeClosure extends BlockIteratorClosure<BlockState> {
+class PartialEscapeClosure<BlockT extends BlockState> extends PartialEscapeAnalysisPhase.Closure<BlockT> {
 
     public static final DebugMetric METRIC_MATERIALIZATIONS = Debug.metric("Materializations");
     public static final DebugMetric METRIC_MATERIALIZATIONS_PHI = Debug.metric("MaterializationsPhi");
@@ -73,8 +71,8 @@
 
     private boolean changed;
 
-    public PartialEscapeClosure(NodeBitMap usages, SchedulePhase schedule, MetaAccessProvider metaAccess, Assumptions assumptions) {
-        this.usages = usages;
+    public PartialEscapeClosure(SchedulePhase schedule, MetaAccessProvider metaAccess, Assumptions assumptions) {
+        this.usages = schedule.getCFG().graph.createNodeBitMap();
         this.schedule = schedule;
         this.tool = new VirtualizerToolImpl(usages, metaAccess, assumptions);
         this.blockEffects = new BlockMap<>(schedule.getCFG());
@@ -83,14 +81,28 @@
         }
     }
 
+    @SuppressWarnings("unchecked")
+    @Override
+    protected BlockT getInitialState() {
+        return (BlockT) new BlockState();
+    }
+
+    @Override
     public boolean hasChanged() {
         return changed;
     }
 
-    public List<Node> applyEffects(final StructuredGraph graph) {
-        final ArrayList<Node> obsoleteNodes = new ArrayList<>();
+    @Override
+    public void applyEffects() {
+        final StructuredGraph graph = schedule.getCFG().graph;
+        final ArrayList<Node> obsoleteNodes = new ArrayList<>(0);
         BlockIteratorClosure<Void> closure = new BlockIteratorClosure<Void>() {
 
+            @Override
+            protected Void getInitialState() {
+                return null;
+            }
+
             private void apply(GraphEffectList effects, Object context) {
                 if (!effects.isEmpty()) {
                     Debug.log(" ==== effects for %s", context);
@@ -126,8 +138,8 @@
                 return info.exitStates;
             }
         };
-        ReentrantBlockIterator.apply(closure, schedule.getCFG().getStartBlock(), null, null);
-        return obsoleteNodes;
+        ReentrantBlockIterator.apply(closure, schedule.getCFG().getStartBlock());
+        assert VirtualUtil.assertNonReachable(graph, obsoleteNodes);
     }
 
     public Map<Invoke, Double> getHints() {
@@ -135,11 +147,11 @@
     }
 
     @Override
-    protected BlockState processBlock(Block block, BlockState state) {
+    protected BlockT processBlock(Block block, BlockT state) {
         GraphEffectList effects = blockEffects.get(block);
         tool.setEffects(effects);
 
-        trace("\nBlock: %s (", block);
+        VirtualUtil.trace("\nBlock: %s (", block);
         List<ScheduledNode> nodeList = schedule.getBlockToNodesMap().get(block);
 
         FixedWithNextNode lastFixedNode = null;
@@ -147,11 +159,11 @@
             boolean deleted;
             boolean isMarked = usages.isMarked(node);
             if (isMarked || node instanceof VirtualizableRoot) {
-                trace("[[%s]] ", node);
+                VirtualUtil.trace("[[%s]] ", node);
                 FixedNode nextFixedNode = lastFixedNode == null ? null : lastFixedNode.next();
                 deleted = processNode((ValueNode) node, nextFixedNode, state, effects, isMarked);
             } else {
-                trace("%s ", node);
+                VirtualUtil.trace("%s ", node);
                 deleted = false;
             }
             if (GraalOptions.OptEarlyReadElimination) {
@@ -171,11 +183,11 @@
                 lastFixedNode = (FixedWithNextNode) node;
             }
         }
-        trace(")\n    end state: %s\n", state);
+        VirtualUtil.trace(")\n    end state: %s\n", state);
         return state;
     }
 
-    private boolean processNode(final ValueNode node, FixedNode insertBefore, final BlockState state, final GraphEffectList effects, boolean isMarked) {
+    private boolean processNode(final ValueNode node, FixedNode insertBefore, final BlockT state, final GraphEffectList effects, boolean isMarked) {
         tool.reset(state, node, insertBefore);
         if (node instanceof Virtualizable) {
             ((Virtualizable) node).virtualize(tool);
@@ -268,7 +280,7 @@
                         Invoke invoke = ((MethodCallTargetNode) node).invoke();
                         hints.put(invoke, 5d);
                     }
-                    trace("replacing input %s at %s: %s", input, node, obj);
+                    VirtualUtil.trace("replacing input %s at %s: %s", input, node, obj);
                     replaceWithMaterialized(input, node, insertBefore, state, obj, effects, METRIC_MATERIALIZATIONS_UNHANDLED);
                 }
             }
@@ -293,9 +305,9 @@
     }
 
     @Override
-    protected BlockState merge(Block merge, List<BlockState> states) {
+    protected BlockT merge(Block merge, List<BlockT> states) {
         assert blockEffects.get(merge).isEmpty();
-        MergeProcessor processor = new MergeProcessor(merge, usages, blockEffects);
+        MergeProcessor<BlockT> processor = new MergeProcessor<>(merge, usages, blockEffects);
         processor.merge(states);
         blockEffects.get(merge).addAll(processor.mergeEffects);
         blockEffects.get(merge).addAll(processor.afterMergeEffects);
@@ -303,20 +315,22 @@
 
     }
 
+    @SuppressWarnings("unchecked")
     @Override
-    protected BlockState cloneState(BlockState oldState) {
-        return oldState.cloneState();
+    protected BlockT cloneState(BlockState oldState) {
+        return (BlockT) oldState.cloneState();
     }
 
     @Override
-    protected List<BlockState> processLoop(Loop loop, BlockState initialState) {
+    protected List<BlockT> processLoop(Loop loop, BlockT initialState) {
         BlockState loopEntryState = initialState;
         BlockState lastMergedState = initialState;
-        MergeProcessor mergeProcessor = new MergeProcessor(loop.header, usages, blockEffects);
+        MergeProcessor<BlockT> mergeProcessor = new MergeProcessor<>(loop.header, usages, blockEffects);
         for (int iteration = 0; iteration < 10; iteration++) {
-            LoopInfo<BlockState> info = ReentrantBlockIterator.processLoop(this, loop, lastMergedState.cloneState());
+            @SuppressWarnings("unchecked")
+            LoopInfo<BlockT> info = ReentrantBlockIterator.processLoop(this, loop, (BlockT) lastMergedState.cloneState());
 
-            List<BlockState> states = new ArrayList<>();
+            List<BlockT> states = new ArrayList<>();
             states.add(initialState);
             states.addAll(info.endStates);
             mergeProcessor.merge(states);
@@ -399,7 +413,7 @@
         }
     }
 
-    private static class MergeProcessor {
+    private static class MergeProcessor<BlockT extends BlockState> {
 
         private final Block mergeBlock;
         private final MergeNode merge;
@@ -412,7 +426,7 @@
         private final IdentityHashMap<VirtualObjectNode, PhiNode[]> valuePhis = new IdentityHashMap<>();
         private final IdentityHashMap<PhiNode, PhiNode[]> valueObjectMergePhis = new IdentityHashMap<>();
         private final IdentityHashMap<PhiNode, VirtualObjectNode> valueObjectVirtuals = new IdentityHashMap<>();
-        private BlockState newState;
+        private BlockT newState;
 
         public MergeProcessor(Block mergeBlock, NodeBitMap usages, BlockMap<GraphEffectList> blockEffects) {
             this.usages = usages;
@@ -459,8 +473,9 @@
             return result;
         }
 
-        private void merge(List<BlockState> states) {
-            newState = BlockState.meetAliases(states);
+        @SuppressWarnings("unchecked")
+        private void merge(List<BlockT> states) {
+            newState = (BlockT) states.get(0).meetAliases(states);
 
             /*
              * Iterative processing: Merging the materialized/virtual state of virtual objects can
@@ -559,7 +574,7 @@
             mergeReadCache(states);
         }
 
-        private boolean processPhi(PhiNode phi, List<BlockState> states) {
+        private boolean processPhi(PhiNode phi, List<BlockT> states) {
             assert states.size() == phi.valueCount();
             int virtualInputs = 0;
             boolean materialized = false;
@@ -643,7 +658,7 @@
             return materialized;
         }
 
-        private void mergeReadCache(List<BlockState> states) {
+        private void mergeReadCache(List<BlockT> states) {
             for (Map.Entry<ReadCacheEntry, ValueNode> entry : states.get(0).readCache.entrySet()) {
                 ReadCacheEntry key = entry.getKey();
                 ValueNode value = entry.getValue();
@@ -682,7 +697,7 @@
             }
         }
 
-        private void mergeReadCachePhi(PhiNode phi, ResolvedJavaField identity, List<BlockState> states) {
+        private void mergeReadCachePhi(PhiNode phi, ResolvedJavaField identity, List<BlockT> states) {
             ValueNode[] values = new ValueNode[phi.valueCount()];
             for (int i = 0; i < phi.valueCount(); i++) {
                 ValueNode value = states.get(i).getReadCache(phi.valueAt(i), identity);
diff -r 12fdb8fe0a35 -r a8a5d5832def graal/com.oracle.graal.virtual/src/com/oracle/graal/virtual/phases/ea/VirtualUtil.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.virtual/src/com/oracle/graal/virtual/phases/ea/VirtualUtil.java	Fri May 17 16:47:13 2013 +0200
@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) 2013, Oracle and/or its affiliates. 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.
+ *
+ * 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 com.oracle.graal.virtual.phases.ea;
+
+import java.util.*;
+
+import com.oracle.graal.api.meta.*;
+import com.oracle.graal.debug.*;
+import com.oracle.graal.graph.*;
+import com.oracle.graal.nodes.*;
+import com.oracle.graal.phases.*;
+
+public final class VirtualUtil {
+
+    private VirtualUtil() {
+        GraalInternalError.shouldNotReachHere();
+    }
+
+    public static boolean assertNonReachable(StructuredGraph graph, List<Node> obsoleteNodes) {
+        // helper code that determines the paths that keep obsolete nodes alive:
+
+        NodeFlood flood = graph.createNodeFlood();
+        IdentityHashMap<Node, Node> path = new IdentityHashMap<>();
+        flood.add(graph.start());
+        for (Node current : flood) {
+            if (current instanceof AbstractEndNode) {
+                AbstractEndNode end = (AbstractEndNode) current;
+                flood.add(end.merge());
+                if (!path.containsKey(end.merge())) {
+                    path.put(end.merge(), end);
+                }
+            } else {
+                for (Node successor : current.successors()) {
+                    flood.add(successor);
+                    if (!path.containsKey(successor)) {
+                        path.put(successor, current);
+                    }
+                }
+            }
+        }
+
+        for (Node node : obsoleteNodes) {
+            if (node instanceof FixedNode) {
+                assert !flood.isMarked(node) : node;
+            }
+        }
+
+        for (Node node : graph.getNodes()) {
+            if (node instanceof LocalNode) {
+                flood.add(node);
+            }
+            if (flood.isMarked(node)) {
+                for (Node input : node.inputs()) {
+                    flood.add(input);
+                    if (!path.containsKey(input)) {
+                        path.put(input, node);
+                    }
+                }
+            }
+        }
+        for (Node current : flood) {
+            for (Node input : current.inputs()) {
+                flood.add(input);
+                if (!path.containsKey(input)) {
+                    path.put(input, current);
+                }
+            }
+        }
+        boolean success = true;
+        for (Node node : obsoleteNodes) {
+            if (flood.isMarked(node)) {
+                TTY.print("offending node path:");
+                Node current = node;
+                while (current != null) {
+                    TTY.println(current.toString());
+                    current = path.get(current);
+                    if (current != null && current instanceof FixedNode && !obsoleteNodes.contains(current)) {
+                        break;
+                    }
+                }
+                success = false;
+            }
+        }
+        return success;
+    }
+
+    public static void trace(String format, Object... obj) {
+        if (GraalOptions.TraceEscapeAnalysis) {
+            Debug.log(format, obj);
+        }
+    }
+
+    static boolean matches(StructuredGraph graph, String filter) {
+        if (filter != null) {
+            if (filter.startsWith("~")) {
+                ResolvedJavaMethod method = graph.method();
+                return method == null || !MetaUtil.format("%H.%n", method).contains(filter.substring(1));
+            } else {
+                ResolvedJavaMethod method = graph.method();
+                return method != null && MetaUtil.format("%H.%n", method).contains(filter);
+            }
+        }
+        return true;
+    }
+
+}
diff -r 12fdb8fe0a35 -r a8a5d5832def graal/com.oracle.graal.virtual/src/com/oracle/graal/virtual/phases/ea/VirtualizerToolImpl.java
--- a/graal/com.oracle.graal.virtual/src/com/oracle/graal/virtual/phases/ea/VirtualizerToolImpl.java	Fri May 17 15:41:39 2013 +0200
+++ b/graal/com.oracle.graal.virtual/src/com/oracle/graal/virtual/phases/ea/VirtualizerToolImpl.java	Fri May 17 16:47:13 2013 +0200
@@ -22,8 +22,6 @@
  */
 package com.oracle.graal.virtual.phases.ea;
 
-import static com.oracle.graal.virtual.phases.ea.PartialEscapeAnalysisPhase.*;
-
 import com.oracle.graal.api.code.*;
 import com.oracle.graal.api.meta.*;
 import com.oracle.graal.graph.*;
@@ -149,7 +147,7 @@
 
     @Override
     public void createVirtualObject(VirtualObjectNode virtualObject, ValueNode[] entryState, int[] locks) {
-        trace("{{%s}} ", current);
+        VirtualUtil.trace("{{%s}} ", current);
         if (virtualObject.isAlive()) {
             state.addAndMarkAlias(virtualObject, virtualObject, usages);
         } else {