Mercurial > hg > truffle
changeset 9436:ae815a4c112a
Rename BeginNode => AbstractBeginNode and make abstract. Introduce concrete subclass BeginNode.
line wrap: on
line diff
--- a/graal/com.oracle.graal.compiler.test/src/com/oracle/graal/compiler/test/SimpleCFGTest.java Mon Apr 29 00:06:45 2013 +0200 +++ b/graal/com.oracle.graal.compiler.test/src/com/oracle/graal/compiler/test/SimpleCFGTest.java Mon Apr 29 00:25:09 2013 +0200 @@ -38,9 +38,9 @@ AbstractEndNode trueEnd = graph.add(new EndNode()); AbstractEndNode falseEnd = graph.add(new EndNode()); - BeginNode trueBegin = graph.add(new BeginNode()); + AbstractBeginNode trueBegin = graph.add(new BeginNode()); trueBegin.setNext(trueEnd); - BeginNode falseBegin = graph.add(new BeginNode()); + AbstractBeginNode falseBegin = graph.add(new BeginNode()); falseBegin.setNext(falseEnd); IfNode ifNode = graph.add(new IfNode(null, trueBegin, falseBegin, 0.5));
--- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/meta/HotSpotRuntime.java Mon Apr 29 00:06:45 2013 +0200 +++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/meta/HotSpotRuntime.java Mon Apr 29 00:25:09 2013 +0200 @@ -653,7 +653,7 @@ ReadNode memoryRead = graph.add(new ReadNode(load.object(), location, load.stamp())); // An unsafe read must not floating outside its block as may float above an explicit // null check on its object. - memoryRead.dependencies().add(BeginNode.prevBegin(load)); + memoryRead.dependencies().add(AbstractBeginNode.prevBegin(load)); graph.replaceFixedWithFixed(load, memoryRead); } else if (n instanceof UnsafeStoreNode) { UnsafeStoreNode store = (UnsafeStoreNode) n;
--- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/phases/WriteBarrierVerificationPhase.java Mon Apr 29 00:06:45 2013 +0200 +++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/phases/WriteBarrierVerificationPhase.java Mon Apr 29 00:25:09 2013 +0200 @@ -103,7 +103,7 @@ } @Override - public void afterSplit(BeginNode node) { + public void afterSplit(AbstractBeginNode node) { } @Override
--- a/graal/com.oracle.graal.java/src/com/oracle/graal/java/FrameStateBuilder.java Mon Apr 29 00:06:45 2013 +0200 +++ b/graal/com.oracle.graal.java/src/com/oracle/graal/java/FrameStateBuilder.java Mon Apr 29 00:25:09 2013 +0200 @@ -253,7 +253,7 @@ } } - public void insertProxies(BeginNode begin) { + public void insertProxies(AbstractBeginNode begin) { for (int i = 0; i < localsSize(); i++) { ValueNode value = localAt(i); if (value != null) {
--- a/graal/com.oracle.graal.java/src/com/oracle/graal/java/GraphBuilderPhase.java Mon Apr 29 00:06:45 2013 +0200 +++ b/graal/com.oracle.graal.java/src/com/oracle/graal/java/GraphBuilderPhase.java Mon Apr 29 00:25:09 2013 +0200 @@ -725,8 +725,8 @@ } condition = currentGraph.unique(condition); - BeginNode trueSuccessor = createBlockTarget(probability, trueBlock, frameState); - BeginNode falseSuccessor = createBlockTarget(1 - probability, falseBlock, frameState); + AbstractBeginNode trueSuccessor = createBlockTarget(probability, trueBlock, frameState); + AbstractBeginNode falseSuccessor = createBlockTarget(1 - probability, falseBlock, frameState); IfNode ifNode = negate ? new IfNode(condition, falseSuccessor, trueSuccessor, 1 - probability) : new IfNode(condition, trueSuccessor, falseSuccessor, probability); append(currentGraph.add(ifNode)); @@ -1522,9 +1522,9 @@ * Returns a block begin node with the specified state. If the specified probability is 0, the * block deoptimizes immediately. */ - private BeginNode createBlockTarget(double probability, Block block, FrameStateBuilder stateAfter) { + private AbstractBeginNode createBlockTarget(double probability, Block block, FrameStateBuilder stateAfter) { FixedNode target = createTarget(probability, block, stateAfter); - BeginNode begin = BeginNode.begin(target); + AbstractBeginNode begin = AbstractBeginNode.begin(target); assert !(target instanceof DeoptimizeNode && begin.stateAfter() != null) : "We are not allowed to set the stateAfter of the begin node, because we have to deoptimize " + "to a bci _before_ the actual if, so that the interpreter can update the profiling information."; @@ -1773,7 +1773,7 @@ frameState.clearNonLiveLocals(currentBlock.localsLiveOut); } if (lastInstr instanceof StateSplit) { - if (lastInstr.getClass() == BeginNode.class) { + if (lastInstr.getClass() == AbstractBeginNode.class) { // BeginNodes do not need a frame state } else { StateSplit stateSplit = (StateSplit) lastInstr;
--- a/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/LoopEx.java Mon Apr 29 00:06:45 2013 +0200 +++ b/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/LoopEx.java Mon Apr 29 00:25:09 2013 +0200 @@ -148,9 +148,9 @@ return data; } - public NodeBitMap nodesInLoopFrom(BeginNode point, BeginNode until) { - Collection<BeginNode> blocks = new LinkedList<>(); - Collection<BeginNode> exits = new LinkedList<>(); + public NodeBitMap nodesInLoopFrom(AbstractBeginNode point, AbstractBeginNode until) { + Collection<AbstractBeginNode> blocks = new LinkedList<>(); + Collection<AbstractBeginNode> exits = new LinkedList<>(); Queue<Block> work = new LinkedList<>(); ControlFlowGraph cfg = loopsData().controlFlowGraph(); work.add(cfg.blockFor(point));
--- a/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/LoopFragment.java Mon Apr 29 00:06:45 2013 +0200 +++ b/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/LoopFragment.java Mon Apr 29 00:25:09 2013 +0200 @@ -145,13 +145,13 @@ } } - protected static NodeBitMap computeNodes(Graph graph, Collection<BeginNode> blocks) { - return computeNodes(graph, blocks, Collections.<BeginNode> emptyList()); + protected static NodeBitMap computeNodes(Graph graph, Collection<AbstractBeginNode> blocks) { + return computeNodes(graph, blocks, Collections.<AbstractBeginNode> emptyList()); } - protected static NodeBitMap computeNodes(Graph graph, Collection<BeginNode> blocks, Collection<BeginNode> earlyExits) { + protected static NodeBitMap computeNodes(Graph graph, Collection<AbstractBeginNode> blocks, Collection<AbstractBeginNode> earlyExits) { final NodeBitMap nodes = graph.createNodeBitMap(true); - for (BeginNode b : blocks) { + for (AbstractBeginNode b : blocks) { for (Node n : b.getBlockNodes()) { if (n instanceof Invoke) { nodes.mark(((Invoke) n).callTarget()); @@ -165,7 +165,7 @@ nodes.mark(n); } } - for (BeginNode earlyExit : earlyExits) { + for (AbstractBeginNode earlyExit : earlyExits) { FrameState stateAfter = earlyExit.stateAfter(); if (stateAfter != null) { nodes.mark(stateAfter); @@ -183,7 +183,7 @@ } } - for (BeginNode b : blocks) { + for (AbstractBeginNode b : blocks) { for (Node n : b.getBlockNodes()) { for (Node usage : n.usages()) { markFloating(usage, nodes); @@ -223,8 +223,8 @@ return false; } - public static Collection<BeginNode> toHirBlocks(Collection<Block> blocks) { - List<BeginNode> hir = new ArrayList<>(blocks.size()); + public static Collection<AbstractBeginNode> toHirBlocks(Collection<Block> blocks) { + List<AbstractBeginNode> hir = new ArrayList<>(blocks.size()); for (Block b : blocks) { hir.add(b.getBeginNode()); } @@ -238,12 +238,12 @@ protected void mergeEarlyExits() { assert isDuplicate(); StructuredGraph graph = graph(); - for (BeginNode earlyExit : LoopFragment.toHirBlocks(original().loop().lirLoop().exits)) { + for (AbstractBeginNode earlyExit : LoopFragment.toHirBlocks(original().loop().lirLoop().exits)) { FixedNode next = earlyExit.next(); if (earlyExit.isDeleted() || !this.original().contains(earlyExit)) { continue; } - BeginNode newEarlyExit = getDuplicatedNode(earlyExit); + AbstractBeginNode newEarlyExit = getDuplicatedNode(earlyExit); if (newEarlyExit == null) { continue; }
--- a/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/LoopFragmentInside.java Mon Apr 29 00:06:45 2013 +0200 +++ b/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/LoopFragmentInside.java Mon Apr 29 00:25:09 2013 +0200 @@ -89,13 +89,13 @@ patchNodes(dataFixBefore); - BeginNode end = mergeEnds(); + AbstractBeginNode end = mergeEnds(); original().patchPeeling(this); mergeEarlyExits(); - BeginNode entry = getDuplicatedNode(loop.loopBegin()); + AbstractBeginNode entry = getDuplicatedNode(loop.loopBegin()); FrameState state = entry.stateAfter(); if (state != null) { entry.setStateAfter(null); @@ -213,7 +213,7 @@ } } - private BeginNode mergeEnds() { + private AbstractBeginNode mergeEnds() { assert isDuplicate(); List<AbstractEndNode> endsToMerge = new LinkedList<>(); Map<AbstractEndNode, LoopEndNode> reverseEnds = new HashMap<>(); // map peel's exit to the @@ -227,7 +227,7 @@ } } mergedInitializers = new IdentityHashMap<>(); - BeginNode newExit; + AbstractBeginNode newExit; StructuredGraph graph = graph(); if (endsToMerge.size() == 1) { AbstractEndNode end = endsToMerge.get(0);
--- a/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/LoopPolicies.java Mon Apr 29 00:06:45 2013 +0200 +++ b/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/LoopPolicies.java Mon Apr 29 00:25:09 2013 +0200 @@ -60,12 +60,12 @@ public static boolean shouldUnswitch(LoopEx loop, ControlSplitNode controlSplit) { Block postDomBlock = loop.loopsData().controlFlowGraph().blockFor(controlSplit).getPostdominator(); - BeginNode postDom = postDomBlock != null ? postDomBlock.getBeginNode() : null; + AbstractBeginNode postDom = postDomBlock != null ? postDomBlock.getBeginNode() : null; int loopTotal = loop.size(); int inBranchTotal = 0; double maxProbability = 0; for (Node successor : controlSplit.successors()) { - BeginNode branch = (BeginNode) successor; + AbstractBeginNode branch = (AbstractBeginNode) successor; inBranchTotal += loop.nodesInLoopFrom(branch, postDom).cardinality(); // this may count // twice because // of fall-through
--- a/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/LoopTransformations.java Mon Apr 29 00:06:45 2013 +0200 +++ b/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/LoopTransformations.java Mon Apr 29 00:25:09 2013 +0200 @@ -78,19 +78,19 @@ // original loop is used as first successor Position firstPosition = successors.nextPosition(); NodeClass controlSplitClass = controlSplitNode.getNodeClass(); - controlSplitClass.set(newControlSplit, firstPosition, BeginNode.begin(originalLoop.entryPoint())); + controlSplitClass.set(newControlSplit, firstPosition, AbstractBeginNode.begin(originalLoop.entryPoint())); StructuredGraph graph = (StructuredGraph) controlSplitNode.graph(); while (successors.hasNext()) { Position position = successors.nextPosition(); // create a new loop duplicate, connect it and simplify it LoopFragmentWhole duplicateLoop = originalLoop.duplicate(); - controlSplitClass.set(newControlSplit, position, BeginNode.begin(duplicateLoop.entryPoint())); + controlSplitClass.set(newControlSplit, position, AbstractBeginNode.begin(duplicateLoop.entryPoint())); ControlSplitNode duplicatedControlSplit = duplicateLoop.getDuplicatedNode(controlSplitNode); - graph.removeSplitPropagate(duplicatedControlSplit, (BeginNode) controlSplitClass.get(duplicatedControlSplit, position)); + graph.removeSplitPropagate(duplicatedControlSplit, (AbstractBeginNode) controlSplitClass.get(duplicatedControlSplit, position)); } // original loop is simplified last to avoid deleting controlSplitNode too early - graph.removeSplitPropagate(controlSplitNode, (BeginNode) controlSplitClass.get(controlSplitNode, firstPosition)); + graph.removeSplitPropagate(controlSplitNode, (AbstractBeginNode) controlSplitClass.get(controlSplitNode, firstPosition)); // TODO (gd) probabilities need some amount of fixup.. (probably also in other transforms) }
--- a/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/phases/LoopTransformLowPhase.java Mon Apr 29 00:06:45 2013 +0200 +++ b/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/phases/LoopTransformLowPhase.java Mon Apr 29 00:25:09 2013 +0200 @@ -77,7 +77,7 @@ sb.append(loop).append(" at ").append(controlSplit).append(" ["); NodeClassIterator it = controlSplit.successors().iterator(); while (it.hasNext()) { - sb.append(controlSplit.probability((BeginNode) it.next())); + sb.append(controlSplit.probability((AbstractBeginNode) it.next())); if (it.hasNext()) { sb.append(", "); }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/AbstractBeginNode.java Mon Apr 29 00:25:09 2013 +0200 @@ -0,0 +1,187 @@ +/* + * Copyright (c) 2011, 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.nodes; + +import static com.oracle.graal.graph.iterators.NodePredicates.*; + +import java.util.*; + +import com.oracle.graal.graph.*; +import com.oracle.graal.graph.iterators.*; +import com.oracle.graal.nodes.spi.*; +import com.oracle.graal.nodes.type.*; + +public abstract class AbstractBeginNode extends FixedWithNextNode implements StateSplit, LIRLowerable, Simplifiable, Node.IterableNodeType { + + @Input(notDataflow = true) private FrameState stateAfter; + + public FrameState stateAfter() { + return stateAfter; + } + + public void setStateAfter(FrameState x) { + assert x == null || x.isAlive() : "frame state must be in a graph"; + updateUsages(stateAfter, x); + stateAfter = x; + } + + public boolean hasSideEffect() { + return false; + } + + protected AbstractBeginNode() { + super(StampFactory.dependency()); + } + + protected AbstractBeginNode(Stamp stamp) { + super(stamp); + } + + public static AbstractBeginNode begin(FixedNode with) { + if (with instanceof AbstractBeginNode) { + return (AbstractBeginNode) with; + } + AbstractBeginNode begin = with.graph().add(new BeginNode()); + begin.setNext(with); + return begin; + } + + @Override + public void simplify(SimplifierTool tool) { + FixedNode prev = (FixedNode) this.predecessor(); + if (prev == null) { + // This is the start node. + } else if (prev instanceof ControlSplitNode) { + // This begin node is necessary. + } else { + // This begin node can be removed and all guards moved up to the preceding begin node. + prepareDelete(); + tool.addToWorkList(next()); + ((StructuredGraph) graph()).removeFixed(this); + } + } + + public static AbstractBeginNode prevBegin(FixedNode from) { + Node prevBegin = from; + while (prevBegin != null) { + if (prevBegin instanceof AbstractBeginNode) { + return (AbstractBeginNode) prevBegin; + } + prevBegin = prevBegin.predecessor(); + } + return null; + } + + private void evacuateGuards(FixedNode evacuateFrom) { + if (!usages().isEmpty()) { + AbstractBeginNode prevBegin = prevBegin(evacuateFrom); + assert prevBegin != null; + for (Node anchored : anchored().snapshot()) { + anchored.replaceFirstInput(this, prevBegin); + } + } + } + + public void prepareDelete() { + prepareDelete((FixedNode) predecessor()); + } + + public void prepareDelete(FixedNode evacuateFrom) { + removeProxies(); + evacuateGuards(evacuateFrom); + } + + public void removeProxies() { + for (ProxyNode vpn : proxies().snapshot()) { + // can not use graph.replaceFloating because vpn.value may be null during killCFG + vpn.replaceAtUsages(vpn.value()); + vpn.safeDelete(); + } + } + + @Override + public boolean verify() { + assertTrue(predecessor() != null || this == ((StructuredGraph) graph()).start() || this instanceof MergeNode, "begin nodes must be connected"); + return super.verify(); + } + + @Override + public void generate(LIRGeneratorTool gen) { + // nop + } + + public NodeIterable<GuardNode> guards() { + return usages().filter(GuardNode.class); + } + + public NodeIterable<Node> anchored() { + return usages().filter(isNotA(ProxyNode.class)); + } + + public NodeIterable<ProxyNode> proxies() { + return usages().filter(ProxyNode.class); + } + + public NodeIterable<FixedNode> getBlockNodes() { + return new AbstractNodeIterable<FixedNode>() { + + @Override + public Iterator<FixedNode> iterator() { + return new BlockNodeIterator(AbstractBeginNode.this); + } + }; + } + + private class BlockNodeIterator implements Iterator<FixedNode> { + + private FixedNode current; + + public BlockNodeIterator(FixedNode next) { + this.current = next; + } + + @Override + public boolean hasNext() { + return current != null; + } + + @Override + public FixedNode next() { + FixedNode ret = current; + if (ret == null) { + throw new NoSuchElementException(); + } + if (!(current instanceof FixedWithNextNode) || (current instanceof AbstractBeginNode && current != AbstractBeginNode.this)) { + current = null; + } else { + current = ((FixedWithNextNode) current).next(); + } + return ret; + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + } +}
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/BeginNode.java Mon Apr 29 00:06:45 2013 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,190 +0,0 @@ -/* - * Copyright (c) 2011, 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.nodes; - -import static com.oracle.graal.graph.iterators.NodePredicates.*; - -import java.util.*; - -import com.oracle.graal.graph.*; -import com.oracle.graal.graph.iterators.*; -import com.oracle.graal.nodes.spi.*; -import com.oracle.graal.nodes.type.*; - -public class BeginNode extends FixedWithNextNode implements StateSplit, LIRLowerable, Simplifiable, Node.IterableNodeType { - - @Input(notDataflow = true) private FrameState stateAfter; - - public FrameState stateAfter() { - return stateAfter; - } - - public void setStateAfter(FrameState x) { - assert x == null || x.isAlive() : "frame state must be in a graph"; - updateUsages(stateAfter, x); - stateAfter = x; - } - - public boolean hasSideEffect() { - return false; - } - - public BeginNode() { - super(StampFactory.dependency()); - } - - protected BeginNode(Stamp stamp) { - super(stamp); - } - - public static BeginNode begin(FixedNode with) { - if (with instanceof BeginNode) { - return (BeginNode) with; - } - BeginNode begin = with.graph().add(new BeginNode()); - begin.setNext(with); - return begin; - } - - @Override - public void simplify(SimplifierTool tool) { - FixedNode prev = (FixedNode) this.predecessor(); - if (prev == null) { - // This is the start node. - } else if (prev instanceof ControlSplitNode) { - // This begin node is necessary. - } else { - // This begin node can be removed and all guards moved up to the preceding begin node. - prepareDelete(); - tool.addToWorkList(next()); - ((StructuredGraph) graph()).removeFixed(this); - } - } - - public static BeginNode prevBegin(FixedNode from) { - Node prevBegin = from; - while (prevBegin != null) { - if (prevBegin instanceof BeginNode) { - return (BeginNode) prevBegin; - } - prevBegin = prevBegin.predecessor(); - } - return null; - } - - private void evacuateGuards(FixedNode evacuateFrom) { - if (!usages().isEmpty()) { - BeginNode prevBegin = prevBegin(evacuateFrom); - assert prevBegin != null; - for (Node anchored : anchored().snapshot()) { - anchored.replaceFirstInput(this, prevBegin); - } - } - } - - public void prepareDelete() { - prepareDelete((FixedNode) predecessor()); - } - - public void prepareDelete(FixedNode evacuateFrom) { - removeProxies(); - evacuateGuards(evacuateFrom); - } - - public void removeProxies() { - for (ProxyNode vpn : proxies().snapshot()) { - // can not use graph.replaceFloating because vpn.value may be null during killCFG - vpn.replaceAtUsages(vpn.value()); - vpn.safeDelete(); - } - } - - @Override - public boolean verify() { - assertTrue(predecessor() != null || this == ((StructuredGraph) graph()).start() || this instanceof MergeNode, "begin nodes must be connected"); - return super.verify(); - } - - @Override - public void generate(LIRGeneratorTool gen) { - // nop - } - - public NodeIterable<GuardNode> guards() { - return usages().filter(GuardNode.class); - } - - public NodeIterable<Node> anchored() { - return usages().filter(isNotA(ProxyNode.class)); - } - - public NodeIterable<ProxyNode> proxies() { - return usages().filter(ProxyNode.class); - } - - public NodeIterable<FixedNode> getBlockNodes() { - return new AbstractNodeIterable<FixedNode>() { - - @Override - public Iterator<FixedNode> iterator() { - return new BlockNodeIterator(BeginNode.this); - } - }; - } - - private class BlockNodeIterator implements Iterator<FixedNode> { - - private FixedNode current; - - public BlockNodeIterator(FixedNode next) { - this.current = next; - } - - @Override - public boolean hasNext() { - return current != null; - } - - @Override - public FixedNode next() { - FixedNode ret = current; - if (ret == null) { - throw new NoSuchElementException(); - } - if (!(current instanceof FixedWithNextNode) || (current instanceof BeginNode && current != BeginNode.this)) { - current = null; - } else { - current = ((FixedWithNextNode) current).next(); - } - return ret; - } - - @Override - public void remove() { - throw new UnsupportedOperationException(); - } - } - - @NodeIntrinsic - public static native BeginNode anchor(@ConstantNodeParameter Stamp stamp); -}
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/BeginStateSplitNode.java Mon Apr 29 00:06:45 2013 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/BeginStateSplitNode.java Mon Apr 29 00:25:09 2013 +0200 @@ -25,11 +25,11 @@ import com.oracle.graal.nodes.type.*; /** - * Base class for {@link BeginNode}s that are associated with a frame state. TODO (dnsimon) this not - * needed until {@link BeginNode} no longer implements {@link StateSplit} which is not possible + * Base class for {@link AbstractBeginNode}s that are associated with a frame state. TODO (dnsimon) this not + * needed until {@link AbstractBeginNode} no longer implements {@link StateSplit} which is not possible * until loop peeling works without requiring begin nodes to have frames states */ -public abstract class BeginStateSplitNode extends BeginNode implements StateSplit { +public abstract class BeginStateSplitNode extends AbstractBeginNode implements StateSplit { public BeginStateSplitNode() { }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/ControlSplitNode.java Mon Apr 29 00:06:45 2013 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/ControlSplitNode.java Mon Apr 29 00:25:09 2013 +0200 @@ -34,5 +34,5 @@ super(stamp); } - public abstract double probability(BeginNode successor); + public abstract double probability(AbstractBeginNode successor); }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/EndNode.java Mon Apr 29 00:25:09 2013 +0200 @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2011, 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.nodes; + +public final class EndNode extends AbstractEndNode { +}
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/EntryMarkerNode.java Mon Apr 29 00:06:45 2013 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/EntryMarkerNode.java Mon Apr 29 00:25:09 2013 +0200 @@ -29,7 +29,7 @@ * This node will be inserted at point specified by {@link StructuredGraph#getEntryBCI()}, usually * by the graph builder. */ -public class EntryMarkerNode extends BeginNode implements Node.IterableNodeType, Simplifiable, LIRLowerable { +public class EntryMarkerNode extends AbstractBeginNode implements Node.IterableNodeType, Simplifiable, LIRLowerable { @Override public void simplify(SimplifierTool tool) {
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/IfNode.java Mon Apr 29 00:06:45 2013 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/IfNode.java Mon Apr 29 00:25:09 2013 +0200 @@ -43,8 +43,8 @@ */ public final class IfNode extends ControlSplitNode implements Simplifiable, LIRLowerable, Negatable { - @Successor private BeginNode trueSuccessor; - @Successor private BeginNode falseSuccessor; + @Successor private AbstractBeginNode trueSuccessor; + @Successor private AbstractBeginNode falseSuccessor; @Input private LogicNode condition; private double trueSuccessorProbability; @@ -58,10 +58,10 @@ } public IfNode(LogicNode condition, FixedNode trueSuccessor, FixedNode falseSuccessor, double trueSuccessorProbability) { - this(condition, BeginNode.begin(trueSuccessor), BeginNode.begin(falseSuccessor), trueSuccessorProbability); + this(condition, AbstractBeginNode.begin(trueSuccessor), AbstractBeginNode.begin(falseSuccessor), trueSuccessorProbability); } - public IfNode(LogicNode condition, BeginNode trueSuccessor, BeginNode falseSuccessor, double trueSuccessorProbability) { + public IfNode(LogicNode condition, AbstractBeginNode trueSuccessor, AbstractBeginNode falseSuccessor, double trueSuccessorProbability) { super(StampFactory.forVoid()); this.condition = condition; this.falseSuccessor = falseSuccessor; @@ -75,7 +75,7 @@ * * @return the true successor */ - public BeginNode trueSuccessor() { + public AbstractBeginNode trueSuccessor() { return trueSuccessor; } @@ -84,16 +84,16 @@ * * @return the false successor */ - public BeginNode falseSuccessor() { + public AbstractBeginNode falseSuccessor() { return falseSuccessor; } - public void setTrueSuccessor(BeginNode node) { + public void setTrueSuccessor(AbstractBeginNode node) { updatePredecessor(trueSuccessor, node); trueSuccessor = node; } - public void setFalseSuccessor(BeginNode node) { + public void setFalseSuccessor(AbstractBeginNode node) { updatePredecessor(falseSuccessor, node); falseSuccessor = node; } @@ -104,14 +104,14 @@ * @param istrue {@code true} if the true successor is requested, {@code false} otherwise * @return the corresponding successor */ - public BeginNode successor(boolean istrue) { + public AbstractBeginNode successor(boolean istrue) { return istrue ? trueSuccessor : falseSuccessor; } @Override public Negatable negate() { - BeginNode trueSucc = trueSuccessor(); - BeginNode falseSucc = falseSuccessor(); + AbstractBeginNode trueSucc = trueSuccessor(); + AbstractBeginNode falseSucc = falseSuccessor(); setTrueSuccessor(null); setFalseSuccessor(null); setTrueSuccessor(falseSucc); @@ -125,7 +125,7 @@ } @Override - public double probability(BeginNode successor) { + public double probability(AbstractBeginNode successor) { return successor == trueSuccessor ? trueSuccessorProbability : 1 - trueSuccessorProbability; } @@ -169,7 +169,7 @@ } if (falseSuccessor().usages().isEmpty() && (!(falseSuccessor() instanceof LoopExitNode)) && falseSuccessor().next() instanceof IfNode) { - BeginNode intermediateBegin = falseSuccessor(); + AbstractBeginNode intermediateBegin = falseSuccessor(); IfNode nextIf = (IfNode) intermediateBegin.next(); double probabilityB = (1.0 - this.trueSuccessorProbability) * nextIf.trueSuccessorProbability; if (this.trueSuccessorProbability < probabilityB) { @@ -178,7 +178,7 @@ if (prepareForSwap(tool.runtime(), condition(), nextIf.condition(), this.trueSuccessorProbability, probabilityB)) { // Reording is allowed from (if1 => begin => if2) to (if2 => begin => if1). assert intermediateBegin.next() == nextIf; - BeginNode bothFalseBegin = nextIf.falseSuccessor(); + AbstractBeginNode bothFalseBegin = nextIf.falseSuccessor(); nextIf.setFalseSuccessor(null); intermediateBegin.setNext(null); this.setFalseSuccessor(null); @@ -465,8 +465,8 @@ List<AbstractEndNode> trueEnds = new ArrayList<>(mergePredecessors.size()); Map<AbstractEndNode, ValueNode> phiValues = new HashMap<>(mergePredecessors.size()); - BeginNode oldFalseSuccessor = falseSuccessor(); - BeginNode oldTrueSuccessor = trueSuccessor(); + AbstractBeginNode oldFalseSuccessor = falseSuccessor(); + AbstractBeginNode oldTrueSuccessor = trueSuccessor(); setFalseSuccessor(null); setTrueSuccessor(null); @@ -545,7 +545,7 @@ * @param oldMerge the merge being removed * @param phiValues the values of the phi at the merge, keyed by the merge ends */ - private void connectEnds(List<AbstractEndNode> ends, Map<AbstractEndNode, ValueNode> phiValues, BeginNode successor, MergeNode oldMerge, SimplifierTool tool) { + private void connectEnds(List<AbstractEndNode> ends, Map<AbstractEndNode, ValueNode> phiValues, AbstractBeginNode successor, MergeNode oldMerge, SimplifierTool tool) { if (ends.isEmpty()) { GraphUtil.killCFG(successor); } else { @@ -613,8 +613,8 @@ } private void removeEmptyIf(SimplifierTool tool) { - BeginNode originalTrueSuccessor = trueSuccessor(); - BeginNode originalFalseSuccessor = falseSuccessor(); + AbstractBeginNode originalTrueSuccessor = trueSuccessor(); + AbstractBeginNode originalFalseSuccessor = falseSuccessor(); assert originalTrueSuccessor.next() instanceof AbstractEndNode && originalFalseSuccessor.next() instanceof AbstractEndNode; AbstractEndNode trueEnd = (AbstractEndNode) originalTrueSuccessor.next();
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/InvokeWithExceptionNode.java Mon Apr 29 00:06:45 2013 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/InvokeWithExceptionNode.java Mon Apr 29 00:25:09 2013 +0200 @@ -34,7 +34,7 @@ @NodeInfo(nameTemplate = "Invoke!#{p#targetMethod/s}") public class InvokeWithExceptionNode extends ControlSplitNode implements Node.IterableNodeType, Invoke, MemoryCheckpoint, LIRLowerable { - @Successor private BeginNode next; + @Successor private AbstractBeginNode next; @Successor private DispatchBeginNode exceptionEdge; @Input private final CallTargetNode callTarget; @Input private FrameState deoptState; @@ -61,11 +61,11 @@ exceptionEdge = x; } - public BeginNode next() { + public AbstractBeginNode next() { return next; } - public void setNext(BeginNode x) { + public void setNext(AbstractBeginNode x) { updatePredecessor(next, x); next = x; } @@ -121,7 +121,7 @@ @Override public void setNext(FixedNode x) { if (x != null) { - this.setNext(BeginNode.begin(x)); + this.setNext(AbstractBeginNode.begin(x)); } else { this.setNext(null); } @@ -170,7 +170,7 @@ } public void killExceptionEdge() { - BeginNode edge = exceptionEdge(); + AbstractBeginNode edge = exceptionEdge(); setExceptionEdge(null); GraphUtil.killCFG(edge); } @@ -205,7 +205,7 @@ private static final double EXCEPTION_PROBA = 1e-5; @Override - public double probability(BeginNode successor) { + public double probability(AbstractBeginNode successor) { return successor == next ? 1 - EXCEPTION_PROBA : EXCEPTION_PROBA; }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/LoopBeginNode.java Mon Apr 29 00:06:45 2013 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/LoopBeginNode.java Mon Apr 29 00:25:09 2013 +0200 @@ -173,7 +173,7 @@ // nothing yet } - public boolean isLoopExit(BeginNode begin) { + public boolean isLoopExit(AbstractBeginNode begin) { return begin instanceof LoopExitNode && ((LoopExitNode) begin).loopBegin() == this; }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/ProxyNode.java Mon Apr 29 00:06:45 2013 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/ProxyNode.java Mon Apr 29 00:25:09 2013 +0200 @@ -37,12 +37,12 @@ @NodeInfo(nameTemplate = "{p#type/s}Proxy") public class ProxyNode extends FloatingNode implements Node.IterableNodeType, ValueNumberable, Canonicalizable, Virtualizable, LIRLowerable { - @Input(notDataflow = true) private BeginNode proxyPoint; + @Input(notDataflow = true) private AbstractBeginNode proxyPoint; @Input private ValueNode value; private final PhiType type; private final Object identity; - public ProxyNode(ValueNode value, BeginNode exit, PhiType type, Object identity) { + public ProxyNode(ValueNode value, AbstractBeginNode exit, PhiType type, Object identity) { super(type == PhiType.Value ? value.stamp() : type.stamp); this.type = type; this.identity = identity; @@ -65,7 +65,7 @@ return value().stamp(); } - public BeginNode proxyPoint() { + public AbstractBeginNode proxyPoint() { return proxyPoint; } @@ -108,11 +108,11 @@ } } - public static ProxyNode forValue(ValueNode value, BeginNode exit, StructuredGraph graph) { + public static ProxyNode forValue(ValueNode value, AbstractBeginNode exit, StructuredGraph graph) { return graph.unique(new ProxyNode(value, exit, PhiType.Value, null)); } - public static ProxyNode forMemory(ValueNode value, BeginNode exit, Object location, StructuredGraph graph) { + public static ProxyNode forMemory(ValueNode value, AbstractBeginNode exit, Object location, StructuredGraph graph) { return graph.unique(new ProxyNode(value, exit, PhiType.Memory, location)); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/StructuredGraph.java Mon Apr 29 00:06:45 2013 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/StructuredGraph.java Mon Apr 29 00:25:09 2013 +0200 @@ -50,14 +50,14 @@ private final int entryBCI; /** - * Creates a new Graph containing a single {@link BeginNode} as the {@link #start() start} node. + * Creates a new Graph containing a single {@link AbstractBeginNode} as the {@link #start() start} node. */ public StructuredGraph() { this(null, null); } /** - * Creates a new Graph containing a single {@link BeginNode} as the {@link #start() start} node. + * Creates a new Graph containing a single {@link AbstractBeginNode} as the {@link #start() start} node. */ public StructuredGraph(String name, ResolvedJavaMethod method) { this(name, method, uniqueGraphIds.incrementAndGet(), INVOCATION_ENTRY_BCI); @@ -214,8 +214,8 @@ */ public void removeFixed(FixedWithNextNode node) { assert node != null; - if (node instanceof BeginNode) { - ((BeginNode) node).prepareDelete(); + if (node instanceof AbstractBeginNode) { + ((AbstractBeginNode) node).prepareDelete(); } assert node.usages().isEmpty() : node + " " + node.usages(); FixedNode next = node.next(); @@ -251,7 +251,7 @@ node.safeDelete(); } - public void removeSplit(ControlSplitNode node, BeginNode survivingSuccessor) { + public void removeSplit(ControlSplitNode node, AbstractBeginNode survivingSuccessor) { assert node != null; assert node.usages().isEmpty(); assert survivingSuccessor != null; @@ -260,7 +260,7 @@ node.safeDelete(); } - public void removeSplitPropagate(ControlSplitNode node, BeginNode survivingSuccessor) { + public void removeSplitPropagate(ControlSplitNode node, AbstractBeginNode survivingSuccessor) { assert node != null; assert node.usages().isEmpty(); assert survivingSuccessor != null; @@ -271,13 +271,13 @@ for (Node successor : snapshot) { if (successor != null && successor.isAlive()) { if (successor != survivingSuccessor) { - GraphUtil.killCFG((BeginNode) successor); + GraphUtil.killCFG((AbstractBeginNode) successor); } } } } - public void replaceSplit(ControlSplitNode node, Node replacement, BeginNode survivingSuccessor) { + public void replaceSplit(ControlSplitNode node, Node replacement, AbstractBeginNode survivingSuccessor) { if (replacement instanceof FixedWithNextNode) { replaceSplitWithFixed(node, (FixedWithNextNode) replacement, survivingSuccessor); } else { @@ -287,7 +287,7 @@ } } - public void replaceSplitWithFixed(ControlSplitNode node, FixedWithNextNode replacement, BeginNode survivingSuccessor) { + public void replaceSplitWithFixed(ControlSplitNode node, FixedWithNextNode replacement, AbstractBeginNode survivingSuccessor) { assert node != null && replacement != null && node.isAlive() && replacement.isAlive() : "cannot replace " + node + " with " + replacement; assert survivingSuccessor != null; node.clearSuccessors(); @@ -295,7 +295,7 @@ node.replaceAndDelete(replacement); } - public void replaceSplitWithFloating(ControlSplitNode node, FloatingNode replacement, BeginNode survivingSuccessor) { + public void replaceSplitWithFloating(ControlSplitNode node, FloatingNode replacement, AbstractBeginNode survivingSuccessor) { assert node != null && replacement != null && node.isAlive() && replacement.isAlive() : "cannot replace " + node + " with " + replacement; assert survivingSuccessor != null; node.clearSuccessors();
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/cfg/Block.java Mon Apr 29 00:06:45 2013 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/cfg/Block.java Mon Apr 29 00:25:09 2013 +0200 @@ -29,7 +29,7 @@ public final class Block { - protected final BeginNode beginNode; + protected final AbstractBeginNode beginNode; protected int id; @@ -46,7 +46,7 @@ private boolean align; private int linearScanNumber; - protected Block(BeginNode node) { + protected Block(AbstractBeginNode node) { this.beginNode = node; this.id = ControlFlowGraph.BLOCK_ID_INITIAL; @@ -57,7 +57,7 @@ return id; } - public BeginNode getBeginNode() { + public AbstractBeginNode getBeginNode() { return beginNode; } @@ -150,7 +150,7 @@ } else { cur = ((FixedWithNextNode) cur).next(); } - assert !(cur instanceof BeginNode); + assert !(cur instanceof AbstractBeginNode); return result; }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/cfg/ControlFlowGraph.java Mon Apr 29 00:06:45 2013 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/cfg/ControlFlowGraph.java Mon Apr 29 00:25:09 2013 +0200 @@ -135,7 +135,7 @@ last = cur; cur = cur.successors().first(); - } while (cur != null && !(cur instanceof BeginNode)); + } while (cur != null && !(cur instanceof AbstractBeginNode)); block.endNode = (FixedNode) last; } @@ -144,8 +144,8 @@ // Find all block headers int numBlocks = 0; for (Node node : graph.getNodes()) { - if (node instanceof BeginNode) { - Block block = new Block((BeginNode) node); + if (node instanceof AbstractBeginNode) { + Block block = new Block((AbstractBeginNode) node); numBlocks++; identifyBlock(block); } @@ -247,7 +247,7 @@ for (Block b : loop.blocks) { for (Block sux : b.getSuccessors()) { if (sux.loop != loop) { - BeginNode begin = sux.getBeginNode(); + AbstractBeginNode begin = sux.getBeginNode(); if (!(begin instanceof LoopExitNode && ((LoopExitNode) begin).loopBegin() == loopBegin)) { Debug.log("Unexpected loop exit with %s, including whole branch in the loop", sux); unexpected.add(sux);
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/extended/IntegerSwitchNode.java Mon Apr 29 00:06:45 2013 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/extended/IntegerSwitchNode.java Mon Apr 29 00:25:09 2013 +0200 @@ -48,7 +48,7 @@ * @param keyProbabilities the probabilities of the keys * @param keySuccessors the successor index for each key */ - public IntegerSwitchNode(ValueNode value, BeginNode[] successors, int[] keys, double[] keyProbabilities, int[] keySuccessors) { + public IntegerSwitchNode(ValueNode value, AbstractBeginNode[] successors, int[] keys, double[] keyProbabilities, int[] keySuccessors) { super(value, successors, keySuccessors, keyProbabilities); assert keySuccessors.length == keys.length + 1; assert keySuccessors.length == keyProbabilities.length; @@ -66,7 +66,7 @@ * @param keySuccessors the successor index for each key */ public IntegerSwitchNode(ValueNode value, int successorCount, int[] keys, double[] keyProbabilities, int[] keySuccessors) { - this(value, new BeginNode[successorCount], keys, keyProbabilities, keySuccessors); + this(value, new AbstractBeginNode[successorCount], keys, keyProbabilities, keySuccessors); } /** @@ -124,7 +124,7 @@ tool.addToWorkList(defaultSuccessor()); ((StructuredGraph) graph()).removeSplitPropagate(this, defaultSuccessor()); } else if (validKeys != keys.length) { - ArrayList<BeginNode> newSuccessors = new ArrayList<>(blockSuccessorCount()); + ArrayList<AbstractBeginNode> newSuccessors = new ArrayList<>(blockSuccessorCount()); int[] newKeys = new int[validKeys]; int[] newKeySuccessors = new int[validKeys + 1]; double[] newKeyProbabilities = new double[validKeys + 1]; @@ -153,14 +153,14 @@ } for (int i = 0; i < blockSuccessorCount(); i++) { - BeginNode successor = blockSuccessor(i); + AbstractBeginNode successor = blockSuccessor(i); if (!newSuccessors.contains(successor)) { tool.deleteBranch(successor); } setBlockSuccessor(i, null); } - BeginNode[] successorsArray = newSuccessors.toArray(new BeginNode[newSuccessors.size()]); + AbstractBeginNode[] successorsArray = newSuccessors.toArray(new AbstractBeginNode[newSuccessors.size()]); IntegerSwitchNode newSwitch = graph().add(new IntegerSwitchNode(value(), successorsArray, newKeys, newKeyProbabilities, newKeySuccessors)); ((FixedWithNextNode) predecessor()).setNext(newSwitch); GraphUtil.killWithUnusedFloatingInputs(this);
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/extended/SwitchNode.java Mon Apr 29 00:06:45 2013 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/extended/SwitchNode.java Mon Apr 29 00:25:09 2013 +0200 @@ -34,7 +34,7 @@ */ public abstract class SwitchNode extends ControlSplitNode { - @Successor protected final NodeSuccessorList<BeginNode> successors; + @Successor protected final NodeSuccessorList<AbstractBeginNode> successors; @Input private ValueNode value; private double[] keyProbabilities; private int[] keySuccessors; @@ -45,7 +45,7 @@ * @param value the instruction that provides the value to be switched over * @param successors the list of successors of this switch */ - public SwitchNode(ValueNode value, BeginNode[] successors, int[] keySuccessors, double[] keyProbabilities) { + public SwitchNode(ValueNode value, AbstractBeginNode[] successors, int[] keySuccessors, double[] keyProbabilities) { super(StampFactory.forVoid()); assert keySuccessors.length == keyProbabilities.length; this.successors = new NodeSuccessorList<>(this, successors); @@ -55,7 +55,7 @@ } @Override - public double probability(BeginNode successor) { + public double probability(AbstractBeginNode successor) { double sum = 0; for (int i = 0; i < keySuccessors.length; i++) { if (successors.get(keySuccessors[i]) == successor) { @@ -89,7 +89,7 @@ /** * Returns the successor for the key at the given index. */ - public BeginNode keySuccessor(int i) { + public AbstractBeginNode keySuccessor(int i) { return successors.get(keySuccessors[i]); } @@ -107,11 +107,11 @@ return keySuccessors[keySuccessors.length - 1]; } - public BeginNode blockSuccessor(int i) { + public AbstractBeginNode blockSuccessor(int i) { return successors.get(i); } - public void setBlockSuccessor(int i, BeginNode s) { + public void setBlockSuccessor(int i, AbstractBeginNode s) { successors.set(i, s); } @@ -124,7 +124,7 @@ * * @return the default successor */ - public BeginNode defaultSuccessor() { + public AbstractBeginNode defaultSuccessor() { if (defaultSuccessorIndex() == -1) { throw new GraalInternalError("unexpected"); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/extended/ValueAnchorNode.java Mon Apr 29 00:06:45 2013 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/extended/ValueAnchorNode.java Mon Apr 29 00:25:09 2013 +0200 @@ -100,7 +100,7 @@ if (permanent) { return; } - for (ValueNode node : dependencies().nonNull().and(isNotA(BeginNode.class))) { + for (ValueNode node : dependencies().nonNull().and(isNotA(AbstractBeginNode.class))) { State state = tool.getObjectState(node); if (state == null || state.getState() != EscapeState.Virtual) { return;
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/java/TypeSwitchNode.java Mon Apr 29 00:06:45 2013 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/java/TypeSwitchNode.java Mon Apr 29 00:25:09 2013 +0200 @@ -50,7 +50,7 @@ * @param keyProbabilities the probabilities of the keys * @param keySuccessors the successor index for each key */ - public TypeSwitchNode(ValueNode value, BeginNode[] successors, ResolvedJavaType[] keys, double[] keyProbabilities, int[] keySuccessors) { + public TypeSwitchNode(ValueNode value, AbstractBeginNode[] successors, ResolvedJavaType[] keys, double[] keyProbabilities, int[] keySuccessors) { super(value, successors, keySuccessors, keyProbabilities); assert successors.length <= keys.length + 1; assert keySuccessors.length == keyProbabilities.length; @@ -110,7 +110,7 @@ tool.addToWorkList(defaultSuccessor()); ((StructuredGraph) graph()).removeSplitPropagate(this, defaultSuccessor()); } else if (validKeys != keys.length) { - ArrayList<BeginNode> newSuccessors = new ArrayList<>(blockSuccessorCount()); + ArrayList<AbstractBeginNode> newSuccessors = new ArrayList<>(blockSuccessorCount()); ResolvedJavaType[] newKeys = new ResolvedJavaType[validKeys]; int[] newKeySuccessors = new int[validKeys + 1]; double[] newKeyProbabilities = new double[validKeys + 1]; @@ -139,14 +139,14 @@ } for (int i = 0; i < blockSuccessorCount(); i++) { - BeginNode successor = blockSuccessor(i); + AbstractBeginNode successor = blockSuccessor(i); if (!newSuccessors.contains(successor)) { tool.deleteBranch(successor); } setBlockSuccessor(i, null); } - BeginNode[] successorsArray = newSuccessors.toArray(new BeginNode[newSuccessors.size()]); + AbstractBeginNode[] successorsArray = newSuccessors.toArray(new AbstractBeginNode[newSuccessors.size()]); TypeSwitchNode newSwitch = graph().add(new TypeSwitchNode(value(), successorsArray, newKeys, newKeyProbabilities, newKeySuccessors)); ((FixedWithNextNode) predecessor()).setNext(newSwitch); GraphUtil.killWithUnusedFloatingInputs(this);
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/util/GraphUtil.java Mon Apr 29 00:06:45 2013 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/util/GraphUtil.java Mon Apr 29 00:25:09 2013 +0200 @@ -152,7 +152,7 @@ } public static void checkRedundantProxy(ProxyNode vpn) { - BeginNode proxyPoint = vpn.proxyPoint(); + AbstractBeginNode proxyPoint = vpn.proxyPoint(); if (proxyPoint instanceof LoopExitNode) { LoopExitNode exit = (LoopExitNode) proxyPoint; LoopBeginNode loopBegin = exit.loopBegin();
--- a/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/ConditionalEliminationPhase.java Mon Apr 29 00:06:45 2013 +0200 +++ b/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/ConditionalEliminationPhase.java Mon Apr 29 00:25:09 2013 +0200 @@ -213,7 +213,7 @@ } @Override - public void afterSplit(BeginNode node) { + public void afterSplit(AbstractBeginNode node) { } @Override @@ -355,7 +355,7 @@ } } - private void registerControlSplitInfo(Node pred, BeginNode begin) { + private void registerControlSplitInfo(Node pred, AbstractBeginNode begin) { assert pred != null && begin != null; if (pred instanceof IfNode) { @@ -461,8 +461,8 @@ @Override protected void node(FixedNode node) { - if (node instanceof BeginNode) { - BeginNode begin = (BeginNode) node; + if (node instanceof AbstractBeginNode) { + AbstractBeginNode begin = (AbstractBeginNode) node; Node pred = node.predecessor(); if (pred != null) {
--- a/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/ConvertDeoptimizeToGuardPhase.java Mon Apr 29 00:06:45 2013 +0200 +++ b/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/ConvertDeoptimizeToGuardPhase.java Mon Apr 29 00:25:09 2013 +0200 @@ -32,11 +32,11 @@ public class ConvertDeoptimizeToGuardPhase extends Phase { - private static BeginNode findBeginNode(Node startNode) { + private static AbstractBeginNode findBeginNode(Node startNode) { Node n = startNode; while (true) { - if (n instanceof BeginNode) { - return (BeginNode) n; + if (n instanceof AbstractBeginNode) { + return (AbstractBeginNode) n; } else { n = n.predecessor(); } @@ -57,17 +57,17 @@ new DeadCodeEliminationPhase().apply(graph); } - private void visitDeoptBegin(BeginNode deoptBegin, DeoptimizeNode deopt, StructuredGraph graph) { + private void visitDeoptBegin(AbstractBeginNode deoptBegin, DeoptimizeNode deopt, StructuredGraph graph) { if (deoptBegin instanceof MergeNode) { MergeNode mergeNode = (MergeNode) deoptBegin; Debug.log("Visiting %s followed by %s", mergeNode, deopt); - List<BeginNode> begins = new ArrayList<>(); + List<AbstractBeginNode> begins = new ArrayList<>(); for (AbstractEndNode end : mergeNode.forwardEnds()) { - BeginNode newBeginNode = findBeginNode(end); + AbstractBeginNode newBeginNode = findBeginNode(end); assert !begins.contains(newBeginNode); begins.add(newBeginNode); } - for (BeginNode begin : begins) { + for (AbstractBeginNode begin : begins) { assert !begin.isDeleted(); visitDeoptBegin(begin, deopt, graph); } @@ -75,7 +75,7 @@ return; } else if (deoptBegin.predecessor() instanceof IfNode) { IfNode ifNode = (IfNode) deoptBegin.predecessor(); - BeginNode otherBegin = ifNode.trueSuccessor(); + AbstractBeginNode otherBegin = ifNode.trueSuccessor(); LogicNode conditionNode = ifNode.condition(); FixedGuardNode guard = graph.add(new FixedGuardNode(conditionNode, deopt.reason(), deopt.action(), deoptBegin == ifNode.trueSuccessor())); FixedWithNextNode pred = (FixedWithNextNode) ifNode.predecessor();
--- a/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/CullFrameStatesPhase.java Mon Apr 29 00:06:45 2013 +0200 +++ b/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/CullFrameStatesPhase.java Mon Apr 29 00:25:09 2013 +0200 @@ -90,7 +90,7 @@ } @Override - public void afterSplit(BeginNode node) { + public void afterSplit(AbstractBeginNode node) { } @Override
--- a/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/EliminatePartiallyRedundantGuardsPhase.java Mon Apr 29 00:06:45 2013 +0200 +++ b/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/EliminatePartiallyRedundantGuardsPhase.java Mon Apr 29 00:25:09 2013 +0200 @@ -120,7 +120,7 @@ continue; } for (AbstractEndNode end : merge.forwardEnds()) { - BeginNode begin = BeginNode.prevBegin(end); + AbstractBeginNode begin = AbstractBeginNode.prevBegin(end); boolean found = false; for (GuardNode predecessorGuard : begin.guards()) { if (predecessorGuard.dependencies().size() != 1) { @@ -141,7 +141,7 @@ for (GuardNode guard : hits) { PhiNode phi = graph.add(new PhiNode(PhiType.Guard, merge, null)); for (AbstractEndNode otherEnd : merge.forwardEnds()) { - phi.addInput(graph.unique(new GuardNode(guard.condition(), BeginNode.prevBegin(otherEnd), guard.reason(), guard.action(), guard.negated()))); + phi.addInput(graph.unique(new GuardNode(guard.condition(), AbstractBeginNode.prevBegin(otherEnd), guard.reason(), guard.action(), guard.negated()))); } guard.replaceAndDelete(phi); metricPRGuardsEliminatedAtMerge.increment(); @@ -152,7 +152,7 @@ private static boolean eliminateAtControlSplit(ControlSplitNode controlSplit) { Map<Condition, Collection<GuardNode>> conditionToGuard = new HashMap<>(); for (Node successor : controlSplit.successors()) { - BeginNode begin = (BeginNode) successor; + AbstractBeginNode begin = (AbstractBeginNode) successor; for (GuardNode guard : begin.guards()) { if (guard.dependencies().size() != 1) { continue; @@ -175,9 +175,9 @@ } DeoptimizationReason reason = null; DeoptimizationAction action = DeoptimizationAction.None; - Set<BeginNode> begins = new HashSet<>(3); + Set<AbstractBeginNode> begins = new HashSet<>(3); for (GuardNode guard : guards) { - BeginNode begin = (BeginNode) guard.dependencies().first(); + AbstractBeginNode begin = (AbstractBeginNode) guard.dependencies().first(); begins.add(begin); if (guard.action().ordinal() > action.ordinal()) { action = guard.action(); @@ -191,7 +191,7 @@ if (begins.size() == controlSplit.successors().count()) { hits = true; Condition condition = entry.getKey(); - GuardNode newGuard = controlSplit.graph().unique(new GuardNode(condition.conditionNode, BeginNode.prevBegin(controlSplit), reason, action, condition.negated)); + GuardNode newGuard = controlSplit.graph().unique(new GuardNode(condition.conditionNode, AbstractBeginNode.prevBegin(controlSplit), reason, action, condition.negated)); for (GuardNode guard : guards) { guard.replaceAndDelete(newGuard); metricPRGuardsEliminatedAtSplit.increment();
--- a/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/FloatingReadPhase.java Mon Apr 29 00:06:45 2013 +0200 +++ b/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/FloatingReadPhase.java Mon Apr 29 00:25:09 2013 +0200 @@ -105,7 +105,7 @@ } @Override - protected Set<Object> afterSplit(BeginNode node, Set<Object> oldState) { + protected Set<Object> afterSplit(AbstractBeginNode node, Set<Object> oldState) { return new HashSet<>(oldState); } @@ -214,7 +214,7 @@ } @Override - protected MemoryMap afterSplit(BeginNode node, MemoryMap oldState) { + protected MemoryMap afterSplit(AbstractBeginNode node, MemoryMap oldState) { MemoryMap result = new MemoryMap(oldState); if (node.predecessor() instanceof InvokeWithExceptionNode) { /*
--- a/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/GuardLoweringPhase.java Mon Apr 29 00:06:45 2013 +0200 +++ b/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/GuardLoweringPhase.java Mon Apr 29 00:25:09 2013 +0200 @@ -171,11 +171,11 @@ private void lowerToIf(GuardNode guard) { StructuredGraph graph = (StructuredGraph) guard.graph(); - BeginNode fastPath = graph.add(new BeginNode()); + AbstractBeginNode fastPath = graph.add(new BeginNode()); DeoptimizeNode deopt = graph.add(new DeoptimizeNode(guard.action(), guard.reason())); - BeginNode deoptBranch = BeginNode.begin(deopt); - BeginNode trueSuccessor; - BeginNode falseSuccessor; + AbstractBeginNode deoptBranch = AbstractBeginNode.begin(deopt); + AbstractBeginNode trueSuccessor; + AbstractBeginNode falseSuccessor; insertLoopExits(deopt); if (guard.negated()) { trueSuccessor = deoptBranch;
--- a/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/InliningUtil.java Mon Apr 29 00:06:45 2013 +0200 +++ b/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/InliningUtil.java Mon Apr 29 00:25:09 2013 +0200 @@ -495,7 +495,7 @@ } // create one separate block for each invoked method - BeginNode[] successors = new BeginNode[numberOfMethods + 1]; + AbstractBeginNode[] successors = new AbstractBeginNode[numberOfMethods + 1]; for (int i = 0; i < numberOfMethods; i++) { successors[i] = createInvocationBlock(graph, invoke, returnMerge, returnValuePhi, exceptionMerge, exceptionObjectPhi, true); } @@ -507,7 +507,7 @@ } else { unknownTypeSux = graph.add(new DeoptimizeNode(DeoptimizationAction.InvalidateReprofile, DeoptimizationReason.TypeCheckedInliningViolated)); } - successors[successors.length - 1] = BeginNode.begin(unknownTypeSux); + successors[successors.length - 1] = AbstractBeginNode.begin(unknownTypeSux); // replace the invoke exception edge if (invoke instanceof InvokeWithExceptionNode) { @@ -533,7 +533,7 @@ // do the actual inlining for every invoke for (int i = 0; i < numberOfMethods; i++) { - BeginNode node = successors[i]; + AbstractBeginNode node = successors[i]; Invoke invokeForInlining = (Invoke) node.next(); ResolvedJavaType commonType; @@ -616,10 +616,10 @@ private void inlineSingleMethod(StructuredGraph graph, InliningCallback callback, Replacements replacements, Assumptions assumptions, MetaAccessProvider runtime) { assert concretes.size() == 1 && ptypes.size() > 1 && !shouldFallbackToInvoke() && notRecordedTypeProbability == 0; - BeginNode calleeEntryNode = graph.add(new BeginNode()); + AbstractBeginNode calleeEntryNode = graph.add(new BeginNode()); - BeginNode unknownTypeSux = createUnknownTypeSuccessor(graph); - BeginNode[] successors = new BeginNode[]{calleeEntryNode, unknownTypeSux}; + AbstractBeginNode unknownTypeSux = createUnknownTypeSuccessor(graph); + AbstractBeginNode[] successors = new AbstractBeginNode[]{calleeEntryNode, unknownTypeSux}; createDispatchOnTypeBeforeInvoke(graph, successors, false, runtime); calleeEntryNode.setNext(invoke.asNode()); @@ -628,7 +628,7 @@ inline(invoke, concrete, callback, replacements, assumptions, false); } - private boolean createDispatchOnTypeBeforeInvoke(StructuredGraph graph, BeginNode[] successors, boolean invokeIsOnlySuccessor, MetaAccessProvider runtime) { + private boolean createDispatchOnTypeBeforeInvoke(StructuredGraph graph, AbstractBeginNode[] successors, boolean invokeIsOnlySuccessor, MetaAccessProvider runtime) { assert ptypes.size() >= 1; Kind hubKind = ((MethodCallTargetNode) invoke.callTarget()).targetMethod().getDeclaringClass().getEncoding(Representation.ObjectHub).getKind(); @@ -728,10 +728,10 @@ return costEstimateMethodDispatch < costEstimateTypeDispatch; } - private static BeginNode createInvocationBlock(StructuredGraph graph, Invoke invoke, MergeNode returnMerge, PhiNode returnValuePhi, MergeNode exceptionMerge, PhiNode exceptionObjectPhi, - boolean useForInlining) { + private static AbstractBeginNode createInvocationBlock(StructuredGraph graph, Invoke invoke, MergeNode returnMerge, PhiNode returnValuePhi, MergeNode exceptionMerge, + PhiNode exceptionObjectPhi, boolean useForInlining) { Invoke duplicatedInvoke = duplicateInvokeForInlining(graph, invoke, exceptionMerge, exceptionObjectPhi, useForInlining); - BeginNode calleeEntryNode = graph.add(new BeginNode()); + AbstractBeginNode calleeEntryNode = graph.add(new BeginNode()); calleeEntryNode.setNext(duplicatedInvoke.asNode()); AbstractEndNode endNode = graph.add(new EndNode()); @@ -812,9 +812,9 @@ private void devirtualizeWithTypeSwitch(StructuredGraph graph, InvokeKind kind, ResolvedJavaMethod target, MetaAccessProvider runtime) { InliningUtil.receiverNullCheck(invoke); - BeginNode invocationEntry = graph.add(new BeginNode()); - BeginNode unknownTypeSux = createUnknownTypeSuccessor(graph); - BeginNode[] successors = new BeginNode[]{invocationEntry, unknownTypeSux}; + AbstractBeginNode invocationEntry = graph.add(new BeginNode()); + AbstractBeginNode unknownTypeSux = createUnknownTypeSuccessor(graph); + AbstractBeginNode[] successors = new AbstractBeginNode[]{invocationEntry, unknownTypeSux}; createDispatchOnTypeBeforeInvoke(graph, successors, true, runtime); invocationEntry.setNext(invoke.asNode()); @@ -824,8 +824,8 @@ replaceInvokeCallTarget(invoke, graph, kind, target); } - private static BeginNode createUnknownTypeSuccessor(StructuredGraph graph) { - return BeginNode.begin(graph.add(new DeoptimizeNode(DeoptimizationAction.InvalidateReprofile, DeoptimizationReason.TypeCheckedInliningViolated))); + private static AbstractBeginNode createUnknownTypeSuccessor(StructuredGraph graph) { + return AbstractBeginNode.begin(graph.add(new DeoptimizeNode(DeoptimizationAction.InvalidateReprofile, DeoptimizationReason.TypeCheckedInliningViolated))); } @Override @@ -1175,7 +1175,7 @@ } } // ensure proper anchoring of things that were anchored to the StartNode - replacements.put(entryPointNode, BeginNode.prevBegin(invoke.asNode())); + replacements.put(entryPointNode, AbstractBeginNode.prevBegin(invoke.asNode())); assert invoke.asNode().successors().first() != null : invoke; assert invoke.asNode().predecessor() != null;
--- a/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/TailDuplicationPhase.java Mon Apr 29 00:06:45 2013 +0200 +++ b/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/TailDuplicationPhase.java Mon Apr 29 00:25:09 2013 +0200 @@ -276,7 +276,7 @@ FixedNode anchorDuplicate = (FixedNode) duplicates.get(anchor); ((FixedWithNextNode) forwardEnd.predecessor()).setNext(anchorDuplicate); // move dependencies on the ValueAnchorNode to the previous BeginNode - BeginNode prevBegin = BeginNode.prevBegin(anchorDuplicate); + AbstractBeginNode prevBegin = AbstractBeginNode.prevBegin(anchorDuplicate); anchorDuplicate.replaceAtUsages(prevBegin); // re-wire the phi duplicates to the correct input
--- a/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/graph/ComputeInliningRelevanceClosure.java Mon Apr 29 00:06:45 2013 +0200 +++ b/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/graph/ComputeInliningRelevanceClosure.java Mon Apr 29 00:25:09 2013 +0200 @@ -170,7 +170,7 @@ int pathBeginCount = pathBeginNodes.size(); for (Node sux : controlSplit.successors()) { - double probability = controlSplit.probability((BeginNode) sux); + double probability = controlSplit.probability((AbstractBeginNode) sux); if (probability > maxProbability) { maxProbability = probability; maxSux = sux;
--- a/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/graph/ComputeProbabilityClosure.java Mon Apr 29 00:06:45 2013 +0200 +++ b/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/graph/ComputeProbabilityClosure.java Mon Apr 29 00:25:09 2013 +0200 @@ -208,7 +208,7 @@ } @Override - public void afterSplit(BeginNode node) { + public void afterSplit(AbstractBeginNode node) { assert node.predecessor() != null; Node pred = node.predecessor(); if (pred instanceof Invoke) { @@ -275,7 +275,7 @@ } @Override - public void afterSplit(BeginNode node) { + public void afterSplit(AbstractBeginNode node) { // nothing to do... } }
--- a/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/graph/MergeableState.java Mon Apr 29 00:06:45 2013 +0200 +++ b/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/graph/MergeableState.java Mon Apr 29 00:25:09 2013 +0200 @@ -36,5 +36,5 @@ void loopEnds(LoopBeginNode loopBegin, List<T> loopEndStates); - void afterSplit(BeginNode node); + void afterSplit(AbstractBeginNode node); }
--- a/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/graph/PostOrderNodeIterator.java Mon Apr 29 00:06:45 2013 +0200 +++ b/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/graph/PostOrderNodeIterator.java Mon Apr 29 00:25:09 2013 +0200 @@ -43,7 +43,7 @@ public abstract class PostOrderNodeIterator<T extends MergeableState<T>> { private final NodeBitMap visitedEnds; - private final Deque<BeginNode> nodeQueue; + private final Deque<AbstractBeginNode> nodeQueue; private final IdentityHashMap<FixedNode, T> nodeStates; private final FixedNode start; @@ -109,13 +109,13 @@ for (Node node : successors) { if (node != null) { nodeStates.put((FixedNode) node.predecessor(), state); - nodeQueue.addFirst((BeginNode) node); + nodeQueue.addFirst((AbstractBeginNode) node); } } } else { for (Node node : x.successors()) { if (node != null) { - nodeQueue.addFirst((BeginNode) node); + nodeQueue.addFirst((AbstractBeginNode) node); } } } @@ -124,7 +124,7 @@ private FixedNode nextQueuedNode() { int maxIterations = nodeQueue.size(); while (maxIterations-- > 0) { - BeginNode node = nodeQueue.removeFirst(); + AbstractBeginNode node = nodeQueue.removeFirst(); if (node instanceof MergeNode) { MergeNode merge = (MergeNode) node; state = nodeStates.get(merge.forwardEndAt(0)).clone();
--- a/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/graph/ReentrantNodeIterator.java Mon Apr 29 00:06:45 2013 +0200 +++ b/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/graph/ReentrantNodeIterator.java Mon Apr 29 00:25:09 2013 +0200 @@ -41,7 +41,7 @@ protected abstract StateT merge(MergeNode merge, List<StateT> states); - protected abstract StateT afterSplit(BeginNode node, StateT oldState); + protected abstract StateT afterSplit(AbstractBeginNode node, StateT oldState); protected abstract Map<LoopExitNode, StateT> processLoop(LoopBeginNode loop, StateT initialState); } @@ -70,7 +70,7 @@ } public static <StateT> Map<FixedNode, StateT> apply(NodeIteratorClosure<StateT> closure, FixedNode start, StateT initialState, Set<FixedNode> boundary) { - Deque<BeginNode> nodeQueue = new ArrayDeque<>(); + Deque<AbstractBeginNode> nodeQueue = new ArrayDeque<>(); IdentityHashMap<FixedNode, StateT> blockEndStates = new IdentityHashMap<>(); StateT state = initialState; @@ -134,11 +134,11 @@ continue; } else { while (successors.hasNext()) { - BeginNode successor = (BeginNode) successors.next(); + AbstractBeginNode successor = (AbstractBeginNode) successors.next(); blockEndStates.put(successor, closure.afterSplit(successor, state)); nodeQueue.add(successor); } - state = closure.afterSplit((BeginNode) firstSuccessor, state); + state = closure.afterSplit((AbstractBeginNode) firstSuccessor, state); current = firstSuccessor; continue; } @@ -151,7 +151,7 @@ } else { current = nodeQueue.removeFirst(); state = blockEndStates.get(current); - assert !(current instanceof MergeNode) && current instanceof BeginNode; + assert !(current instanceof MergeNode) && current instanceof AbstractBeginNode; } } while (true); }
--- a/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/schedule/SchedulePhase.java Mon Apr 29 00:06:45 2013 +0200 +++ b/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/schedule/SchedulePhase.java Mon Apr 29 00:25:09 2013 +0200 @@ -652,7 +652,7 @@ } } - if (instruction instanceof BeginNode) { + if (instruction instanceof AbstractBeginNode) { ArrayList<ProxyNode> proxies = (instruction instanceof LoopExitNode) ? new ArrayList<ProxyNode>() : null; for (ScheduledNode inBlock : blockToNodesMap.get(b)) { if (!visited.isMarked(inBlock)) {
--- a/graal/com.oracle.graal.printer/src/com/oracle/graal/printer/CFGPrinter.java Mon Apr 29 00:06:45 2013 +0200 +++ b/graal/com.oracle.graal.printer/src/com/oracle/graal/printer/CFGPrinter.java Mon Apr 29 00:25:09 2013 +0200 @@ -471,7 +471,7 @@ return "-"; } String prefix; - if (node instanceof BeginNode && lir == null) { + if (node instanceof AbstractBeginNode && lir == null) { prefix = "B"; } else if (node instanceof ValueNode) { ValueNode value = (ValueNode) node;
--- a/graal/com.oracle.graal.printer/src/com/oracle/graal/printer/IdealGraphPrinter.java Mon Apr 29 00:06:45 2013 +0200 +++ b/graal/com.oracle.graal.printer/src/com/oracle/graal/printer/IdealGraphPrinter.java Mon Apr 29 00:25:09 2013 +0200 @@ -165,7 +165,7 @@ printProperty(bit, "true"); } } - if (node.getClass() == BeginNode.class) { + if (node.getClass() == AbstractBeginNode.class) { printProperty("shortName", "B"); } else if (node.getClass() == AbstractEndNode.class) { printProperty("shortName", "E");
--- a/graal/com.oracle.graal.replacements/src/com/oracle/graal/replacements/SnippetFrameStateCleanupPhase.java Mon Apr 29 00:06:45 2013 +0200 +++ b/graal/com.oracle.graal.replacements/src/com/oracle/graal/replacements/SnippetFrameStateCleanupPhase.java Mon Apr 29 00:25:09 2013 +0200 @@ -93,7 +93,7 @@ } @Override - protected CleanupState afterSplit(BeginNode node, CleanupState oldState) { + protected CleanupState afterSplit(AbstractBeginNode node, CleanupState oldState) { return new CleanupState(oldState.containsFrameState); }
--- a/graal/com.oracle.graal.word/src/com/oracle/graal/word/phases/WordTypeRewriterPhase.java Mon Apr 29 00:06:45 2013 +0200 +++ b/graal/com.oracle.graal.word/src/com/oracle/graal/word/phases/WordTypeRewriterPhase.java Mon Apr 29 00:25:09 2013 +0200 @@ -272,7 +272,7 @@ graph.addBeforeFixed(invoke.asNode(), read); // The read must not float outside its block otherwise it may float above an explicit zero // check on its base address - read.dependencies().add(BeginNode.prevBegin(invoke.asNode())); + read.dependencies().add(AbstractBeginNode.prevBegin(invoke.asNode())); return read; }