Mercurial > hg > truffle
changeset 15145:df2ef5204f2b
Remove AbstractBeginNode, move the framestate from AbstractBeginNode to BeginStateSplitNode.
This required some changes to loop transformations: when peeling don't create duplicates for the exit proxies.
line wrap: on
line diff
--- a/graal/com.oracle.graal.compiler.test/src/com/oracle/graal/compiler/test/SimpleCFGTest.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.compiler.test/src/com/oracle/graal/compiler/test/SimpleCFGTest.java Mon Apr 14 15:21:27 2014 +0200 @@ -41,9 +41,9 @@ AbstractEndNode trueEnd = graph.add(new EndNode()); AbstractEndNode falseEnd = graph.add(new EndNode()); - AbstractBeginNode trueBegin = graph.add(new BeginNode()); + BeginNode trueBegin = graph.add(new BeginNode()); trueBegin.setNext(trueEnd); - AbstractBeginNode falseBegin = graph.add(new BeginNode()); + BeginNode falseBegin = graph.add(new BeginNode()); falseBegin.setNext(falseEnd); IfNode ifNode = graph.add(new IfNode(null, trueBegin, falseBegin, 0.5));
--- a/graal/com.oracle.graal.compiler/src/com/oracle/graal/compiler/gen/NodeLIRBuilder.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.compiler/src/com/oracle/graal/compiler/gen/NodeLIRBuilder.java Mon Apr 14 15:21:27 2014 +0200 @@ -659,7 +659,7 @@ return debugInfoBuilder; } - public void emitOverflowCheckBranch(AbstractBeginNode overflowSuccessor, AbstractBeginNode next, double probability) { + public void emitOverflowCheckBranch(BeginNode overflowSuccessor, BeginNode next, double probability) { gen.emitOverflowCheckBranch(getLIRBlock(overflowSuccessor), getLIRBlock(next), probability); }
--- a/graal/com.oracle.graal.hotspot.hsail/src/com/oracle/graal/hotspot/hsail/HSAILHotSpotBackend.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.hotspot.hsail/src/com/oracle/graal/hotspot/hsail/HSAILHotSpotBackend.java Mon Apr 14 15:21:27 2014 +0200 @@ -843,7 +843,7 @@ ParameterNode hsailFrame = hostGraph.unique(new ParameterNode(1, StampFactory.forKind(providers.getCodeCache().getTarget().wordKind))); ParameterNode reasonAndAction = hostGraph.unique(new ParameterNode(2, StampFactory.intValue())); ParameterNode speculation = hostGraph.unique(new ParameterNode(3, StampFactory.object())); - AbstractBeginNode[] branches = new AbstractBeginNode[deopts.size() + 1]; + BeginNode[] branches = new BeginNode[deopts.size() + 1]; int[] keys = new int[deopts.size()]; int[] keySuccessors = new int[deopts.size() + 1]; double[] keyProbabilities = new double[deopts.size() + 1]; @@ -875,14 +875,14 @@ return hostGraph; } - private static AbstractBeginNode createHostCrashBranch(StructuredGraph hostGraph, ValueNode deoptId) { + private static BeginNode createHostCrashBranch(StructuredGraph hostGraph, ValueNode deoptId) { VMErrorNode vmError = hostGraph.add(new VMErrorNode("Error in HSAIL deopt. DeoptId=%d", deoptId)); // ConvertNode.convert(hostGraph, Kind.Long, deoptId))); vmError.setNext(hostGraph.add(new ReturnNode(ConstantNode.defaultForKind(hostGraph.method().getSignature().getReturnKind(), hostGraph)))); return BeginNode.begin(vmError); } - private static AbstractBeginNode createHostDeoptBranch(DeoptimizeOp deopt, ParameterNode hsailFrame, ValueNode reasonAndAction, ValueNode speculation, HotSpotProviders providers, + private static BeginNode createHostDeoptBranch(DeoptimizeOp deopt, ParameterNode hsailFrame, ValueNode reasonAndAction, ValueNode speculation, HotSpotProviders providers, HotSpotVMConfig config) { BeginNode branch = hsailFrame.graph().add(new BeginNode()); DynamicDeoptimizeNode deoptimization = hsailFrame.graph().add(new DynamicDeoptimizeNode(reasonAndAction, speculation));
--- a/graal/com.oracle.graal.hotspot.test/src/com/oracle/graal/hotspot/test/WriteBarrierVerificationTest.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.hotspot.test/src/com/oracle/graal/hotspot/test/WriteBarrierVerificationTest.java Mon Apr 14 15:21:27 2014 +0200 @@ -685,7 +685,7 @@ } @Override - protected Boolean afterSplit(AbstractBeginNode node, Boolean oldState) { + protected Boolean afterSplit(BeginNode node, Boolean oldState) { return false; } };
--- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/meta/HotSpotLoweringProvider.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/meta/HotSpotLoweringProvider.java Mon Apr 14 15:21:27 2014 +0200 @@ -474,7 +474,7 @@ ReadNode memoryRead = createUnsafeRead(graph, load, null); // An unsafe read must not float outside its block otherwise // it may float above an explicit null check on its object. - memoryRead.setGuard(AbstractBeginNode.prevBegin(load)); + memoryRead.setGuard(BeginNode.prevBegin(load)); graph.replaceFixedWithFixed(load, memoryRead); } }
--- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/SnippetAnchorNode.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/SnippetAnchorNode.java Mon Apr 14 15:21:27 2014 +0200 @@ -37,7 +37,7 @@ @Override public void simplify(SimplifierTool tool) { - AbstractBeginNode prevBegin = BeginNode.prevBegin(this); + BeginNode prevBegin = BeginNode.prevBegin(this); replaceAtUsages(InputType.Anchor, prevBegin); replaceAtUsages(InputType.Guard, prevBegin); if (usages().isEmpty()) {
--- a/graal/com.oracle.graal.java/src/com/oracle/graal/java/GraphBuilderPhase.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.java/src/com/oracle/graal/java/GraphBuilderPhase.java Mon Apr 14 15:21:27 2014 +0200 @@ -1077,11 +1077,11 @@ * Returns a block begin node with the specified state. If the specified probability is * 0, the block deoptimizes immediately. */ - private AbstractBeginNode createBlockTarget(double probability, BciBlock block, HIRFrameStateBuilder stateAfter) { + private BeginNode createBlockTarget(double probability, BciBlock block, HIRFrameStateBuilder stateAfter) { FixedNode target = createTarget(probability, block, stateAfter); - AbstractBeginNode begin = AbstractBeginNode.begin(target); + BeginNode begin = BeginNode.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 " + assert !(target instanceof DeoptimizeNode && begin instanceof BeginStateSplitNode && ((BeginStateSplitNode) 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."; return begin; } @@ -1299,7 +1299,7 @@ frameState.clearNonLiveLocals(currentBlock, liveness, false); } if (lastInstr instanceof StateSplit) { - if (lastInstr.getClass() == AbstractBeginNode.class) { + if (lastInstr.getClass() == BeginNode.class) { // BeginNodes do not need a frame state } else { StateSplit stateSplit = (StateSplit) lastInstr;
--- a/graal/com.oracle.graal.java/src/com/oracle/graal/java/HIRFrameStateBuilder.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.java/src/com/oracle/graal/java/HIRFrameStateBuilder.java Mon Apr 14 15:21:27 2014 +0200 @@ -259,7 +259,7 @@ } } - public void insertProxies(AbstractBeginNode begin) { + public void insertProxies(BeginNode begin) { for (int i = 0; i < localsSize(); i++) { ValueNode value = localAt(i); if (value != null) {
--- a/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/CountedLoopInfo.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/CountedLoopInfo.java Mon Apr 14 15:21:27 2014 +0200 @@ -37,9 +37,9 @@ private InductionVariable iv; private ValueNode end; private boolean oneOff; - private AbstractBeginNode body; + private BeginNode body; - CountedLoopInfo(LoopEx loop, InductionVariable iv, ValueNode end, boolean oneOff, AbstractBeginNode body) { + CountedLoopInfo(LoopEx loop, InductionVariable iv, ValueNode end, boolean oneOff, BeginNode body) { this.loop = loop; this.iv = iv; this.end = end; @@ -117,7 +117,7 @@ return oneOff; } - public AbstractBeginNode getBody() { + public BeginNode getBody() { return body; }
--- a/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/LoopEx.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/LoopEx.java Mon Apr 14 15:21:27 2014 +0200 @@ -222,9 +222,9 @@ return data; } - public NodeBitMap nodesInLoopFrom(AbstractBeginNode point, AbstractBeginNode until) { - Collection<AbstractBeginNode> blocks = new LinkedList<>(); - Collection<AbstractBeginNode> exits = new LinkedList<>(); + public NodeBitMap nodesInLoopFrom(BeginNode point, BeginNode until) { + Collection<BeginNode> blocks = new LinkedList<>(); + Collection<LoopExitNode> exits = new LinkedList<>(); Queue<Block> work = new LinkedList<>(); ControlFlowGraph cfg = loopsData().controlFlowGraph(); work.add(cfg.blockFor(point)); @@ -235,7 +235,7 @@ continue; } if (lirLoop().exits.contains(b)) { - exits.add(b.getBeginNode()); + exits.add((LoopExitNode) b.getBeginNode()); } else if (lirLoop().blocks.contains(b)) { blocks.add(b.getBeginNode()); work.addAll(b.getDominated());
--- a/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/LoopFragment.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/LoopFragment.java Mon Apr 14 15:21:27 2014 +0200 @@ -31,7 +31,6 @@ import com.oracle.graal.nodes.VirtualState.VirtualClosure; import com.oracle.graal.nodes.cfg.*; import com.oracle.graal.nodes.java.*; -import com.oracle.graal.nodes.util.*; import com.oracle.graal.nodes.virtual.*; public abstract class LoopFragment { @@ -150,13 +149,13 @@ } } - protected static NodeBitMap computeNodes(Graph graph, Iterable<AbstractBeginNode> blocks) { - return computeNodes(graph, blocks, Collections.<AbstractBeginNode> emptyList()); + protected static NodeBitMap computeNodes(Graph graph, Iterable<BeginNode> blocks) { + return computeNodes(graph, blocks, Collections.emptyList()); } - protected static NodeBitMap computeNodes(Graph graph, Iterable<AbstractBeginNode> blocks, Iterable<AbstractBeginNode> earlyExits) { + protected static NodeBitMap computeNodes(Graph graph, Iterable<BeginNode> blocks, Iterable<LoopExitNode> earlyExits) { final NodeBitMap nodes = graph.createNodeBitMap(true); - for (AbstractBeginNode b : blocks) { + for (BeginNode b : blocks) { if (b.isDeleted()) { continue; } @@ -174,7 +173,7 @@ nodes.mark(n); } } - for (AbstractBeginNode earlyExit : earlyExits) { + for (LoopExitNode earlyExit : earlyExits) { if (earlyExit.isDeleted()) { continue; } @@ -197,7 +196,7 @@ } final NodeBitMap notloopNodes = graph.createNodeBitMap(true); - for (AbstractBeginNode b : blocks) { + for (BeginNode b : blocks) { if (b.isDeleted()) { continue; } @@ -254,19 +253,19 @@ return false; } - public static NodeIterable<AbstractBeginNode> toHirBlocks(final Iterable<Block> blocks) { - return new AbstractNodeIterable<AbstractBeginNode>() { + public static NodeIterable<BeginNode> toHirBlocks(final Iterable<Block> blocks) { + return new AbstractNodeIterable<BeginNode>() { - public Iterator<AbstractBeginNode> iterator() { + public Iterator<BeginNode> iterator() { final Iterator<Block> it = blocks.iterator(); - return new Iterator<AbstractBeginNode>() { + return new Iterator<BeginNode>() { @Override public void remove() { throw new UnsupportedOperationException(); } - public AbstractBeginNode next() { + public BeginNode next() { return it.next().getBeginNode(); } @@ -279,6 +278,31 @@ }; } + public static NodeIterable<LoopExitNode> toHirExits(final Iterable<Block> blocks) { + return new AbstractNodeIterable<LoopExitNode>() { + + public Iterator<LoopExitNode> iterator() { + final Iterator<Block> it = blocks.iterator(); + return new Iterator<LoopExitNode>() { + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + + public LoopExitNode next() { + return (LoopExitNode) it.next().getBeginNode(); + } + + public boolean hasNext() { + return it.hasNext(); + } + }; + } + + }; + } + /** * Merges the early exits (i.e. loop exits) that were duplicated as part of this fragment, with * the original fragment's exits. @@ -286,31 +310,31 @@ protected void mergeEarlyExits() { assert isDuplicate(); StructuredGraph graph = graph(); - for (AbstractBeginNode earlyExit : LoopFragment.toHirBlocks(original().loop().lirLoop().exits)) { - FixedNode next = earlyExit.next(); - if (earlyExit.isDeleted() || !this.original().contains(earlyExit)) { + for (BeginNode earlyExit : LoopFragment.toHirBlocks(original().loop().lirLoop().exits)) { + LoopExitNode loopEarlyExit = (LoopExitNode) earlyExit; + FixedNode next = loopEarlyExit.next(); + if (loopEarlyExit.isDeleted() || !this.original().contains(loopEarlyExit)) { continue; } - AbstractBeginNode newEarlyExit = getDuplicatedNode(earlyExit); + BeginNode newEarlyExit = getDuplicatedNode(loopEarlyExit); if (newEarlyExit == null) { continue; } - boolean newEarlyExitIsBegin = newEarlyExit instanceof BeginNode; MergeNode merge = graph.add(new MergeNode()); AbstractEndNode originalEnd = graph.add(new EndNode()); AbstractEndNode newEnd = graph.add(new EndNode()); merge.addForwardEnd(originalEnd); merge.addForwardEnd(newEnd); - earlyExit.setNext(originalEnd); + loopEarlyExit.setNext(originalEnd); newEarlyExit.setNext(newEnd); merge.setNext(next); - FrameState exitState = earlyExit.stateAfter(); + FrameState exitState = loopEarlyExit.stateAfter(); FrameState state = null; if (exitState != null) { state = exitState; exitState = exitState.duplicateWithVirtualState(); - earlyExit.setStateAfter(exitState); + loopEarlyExit.setStateAfter(exitState); merge.setStateAfter(state); /* * Using the old exit's state as the merge's state is necessary because some of the @@ -332,13 +356,17 @@ }); } - for (Node anchored : earlyExit.anchored().snapshot()) { - anchored.replaceFirstInput(earlyExit, merge); + for (Node anchored : loopEarlyExit.anchored().snapshot()) { + anchored.replaceFirstInput(loopEarlyExit, merge); } - for (final ProxyNode vpn : earlyExit.proxies().snapshot()) { + boolean newEarlyExitIsLoopExit = newEarlyExit instanceof LoopExitNode; + for (final ProxyNode vpn : loopEarlyExit.proxies().snapshot()) { + if (vpn.usages().isEmpty()) { + continue; + } final ValueNode replaceWith; - ProxyNode newVpn = getDuplicatedNode(vpn); + ValueNode newVpn = prim(newEarlyExitIsLoopExit ? vpn : vpn.value()); if (newVpn != null) { PhiNode phi; if (vpn instanceof ValueProxyNode) { @@ -351,7 +379,7 @@ throw GraalInternalError.shouldNotReachHere(); } phi.addInput(vpn); - phi.addInput(newEarlyExitIsBegin ? newVpn.value() : newVpn); + phi.addInput(newVpn); replaceWith = phi; } else { replaceWith = vpn.value(); @@ -368,16 +396,6 @@ } } } - if (newEarlyExitIsBegin) { - FrameState stateAtNewEarlyExit = newEarlyExit.stateAfter(); - if (stateAtNewEarlyExit != null) { - newEarlyExit.setStateAfter(null); - GraphUtil.killWithUnusedFloatingInputs(stateAtNewEarlyExit); - } - for (ProxyNode proxy : newEarlyExit.proxies().snapshot()) { - GraphUtil.killWithUnusedFloatingInputs(proxy); - } - } } } }
--- a/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/LoopFragmentInside.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/LoopFragmentInside.java Mon Apr 14 15:21:27 2014 +0200 @@ -29,7 +29,6 @@ import com.oracle.graal.graph.iterators.*; import com.oracle.graal.nodes.*; import com.oracle.graal.nodes.VirtualState.NodeClosure; -import com.oracle.graal.nodes.util.*; public class LoopFragmentInside extends LoopFragment { @@ -88,18 +87,13 @@ patchNodes(dataFixBefore); - AbstractBeginNode end = mergeEnds(); - - original().patchPeeling(this); + BeginNode end = mergeEnds(); mergeEarlyExits(); - AbstractBeginNode entry = getDuplicatedNode(loop.loopBegin()); - FrameState state = entry.stateAfter(); - if (state != null) { - entry.setStateAfter(null); - GraphUtil.killWithUnusedFloatingInputs(state); - } + original().patchPeeling(this); + + BeginNode entry = getDuplicatedNode(loop.loopBegin()); loop.entryPoint().replaceAtPredecessor(entry); end.setNext(loop.entryPoint()); } @@ -111,13 +105,27 @@ whole.nodes(); // init nodes bitmap in whole nodes = whole.nodes.copy(); // remove the phis - for (PhiNode phi : loop().loopBegin().phis()) { + LoopBeginNode loopBegin = loop().loopBegin(); + for (PhiNode phi : loopBegin.phis()) { nodes.clear(phi); } + for (LoopExitNode exit : exits()) { + FrameState exitState = exit.stateAfter(); + if (exitState != null) { + exitState.applyToVirtual(v -> nodes.clear(v)); + } + for (ProxyNode proxy : exit.proxies()) { + nodes.clear(proxy); + } + } } return nodes; } + public NodeIterable<LoopExitNode> exits() { + return loop().loopBegin().loopExits(); + } + @Override protected DuplicationReplacement getDuplicationReplacement() { final LoopBeginNode loopBegin = loop().loopBegin(); @@ -183,6 +191,18 @@ LoopBeginNode loopBegin = loop().loopBegin(); StructuredGraph graph = loopBegin.graph(); List<PhiNode> newPhis = new LinkedList<>(); + + NodeBitMap usagesToPatch = nodes.copy(); + for (LoopExitNode exit : exits()) { + FrameState exitState = exit.stateAfter(); + if (exitState != null) { + exitState.applyToVirtual(v -> usagesToPatch.mark(v)); + } + for (ProxyNode proxy : exit.proxies()) { + usagesToPatch.mark(proxy); + } + } + for (PhiNode phi : loopBegin.phis().snapshot()) { if (phi.usages().isEmpty()) { continue; @@ -204,9 +224,8 @@ peel.putDuplicatedNode(phi, newPhi); newPhis.add(newPhi); for (Node usage : phi.usages().snapshot()) { - if (peel.getDuplicatedNode(usage) != null) { // patch only usages that should use - // the new phi ie usages that were - // peeled + // patch only usages that should use the new phi ie usages that were peeled + if (usagesToPatch.isMarked(usage)) { usage.replaceFirstInput(phi, newPhi); } } @@ -250,7 +269,7 @@ } } - private AbstractBeginNode mergeEnds() { + private BeginNode mergeEnds() { assert isDuplicate(); List<AbstractEndNode> endsToMerge = new LinkedList<>(); Map<AbstractEndNode, LoopEndNode> reverseEnds = new HashMap<>(); // map peel's exit to the @@ -264,7 +283,7 @@ } } mergedInitializers = new IdentityHashMap<>(); - AbstractBeginNode newExit; + BeginNode newExit; StructuredGraph graph = graph(); if (endsToMerge.size() == 1) { AbstractEndNode end = endsToMerge.get(0);
--- a/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/LoopFragmentWhole.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/LoopFragmentWhole.java Mon Apr 14 15:21:27 2014 +0200 @@ -57,7 +57,7 @@ public NodeIterable<Node> nodes() { if (nodes == null) { Loop<Block> lirLoop = loop().lirLoop(); - nodes = LoopFragment.computeNodes(graph(), LoopFragment.toHirBlocks(lirLoop.blocks), LoopFragment.toHirBlocks(lirLoop.exits)); + nodes = LoopFragment.computeNodes(graph(), LoopFragment.toHirBlocks(lirLoop.blocks), LoopFragment.toHirExits(lirLoop.exits)); } return nodes; }
--- a/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/LoopPolicies.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/LoopPolicies.java Mon Apr 14 15:21:27 2014 +0200 @@ -64,12 +64,12 @@ public static boolean shouldUnswitch(LoopEx loop, ControlSplitNode controlSplit) { Block postDomBlock = loop.loopsData().controlFlowGraph().blockFor(controlSplit).getPostdominator(); - AbstractBeginNode postDom = postDomBlock != null ? postDomBlock.getBeginNode() : null; + BeginNode postDom = postDomBlock != null ? postDomBlock.getBeginNode() : null; int loopTotal = loop.size(); int inBranchTotal = 0; double maxProbability = 0; for (Node successor : controlSplit.successors()) { - AbstractBeginNode branch = (AbstractBeginNode) successor; + BeginNode branch = (BeginNode) 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 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/LoopTransformations.java Mon Apr 14 15:21:27 2014 +0200 @@ -82,19 +82,19 @@ // original loop is used as first successor Position firstPosition = successors.nextPosition(); NodeClass controlSplitClass = controlSplitNode.getNodeClass(); - controlSplitClass.set(newControlSplit, firstPosition, AbstractBeginNode.begin(originalLoop.entryPoint())); + controlSplitClass.set(newControlSplit, firstPosition, BeginNode.begin(originalLoop.entryPoint())); StructuredGraph graph = 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, AbstractBeginNode.begin(duplicateLoop.entryPoint())); + controlSplitClass.set(newControlSplit, position, BeginNode.begin(duplicateLoop.entryPoint())); ControlSplitNode duplicatedControlSplit = duplicateLoop.getDuplicatedNode(controlSplitNode); - graph.removeSplitPropagate(duplicatedControlSplit, (AbstractBeginNode) controlSplitClass.get(duplicatedControlSplit, position)); + graph.removeSplitPropagate(duplicatedControlSplit, (BeginNode) controlSplitClass.get(duplicatedControlSplit, position)); } // original loop is simplified last to avoid deleting controlSplitNode too early - graph.removeSplitPropagate(controlSplitNode, (AbstractBeginNode) controlSplitClass.get(controlSplitNode, firstPosition)); + graph.removeSplitPropagate(controlSplitNode, (BeginNode) 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 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/phases/LoopTransformLowPhase.java Mon Apr 14 15:21:27 2014 +0200 @@ -78,7 +78,7 @@ sb.append(loop).append(" at ").append(controlSplit).append(" ["); NodeClassIterator it = controlSplit.successors().iterator(); while (it.hasNext()) { - sb.append(controlSplit.probability((AbstractBeginNode) it.next())); + sb.append(controlSplit.probability((BeginNode) it.next())); if (it.hasNext()) { sb.append(", "); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/AbstractBeginNode.java Mon Apr 14 15:16:59 2014 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,194 +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.graph.spi.*; -import com.oracle.graal.nodes.extended.*; -import com.oracle.graal.nodes.spi.*; -import com.oracle.graal.nodes.type.*; - -@NodeInfo(allowedUsageTypes = {InputType.Guard, InputType.Anchor}) -public abstract class AbstractBeginNode extends FixedWithNextNode implements StateSplit, LIRLowerable, Simplifiable, GuardingNode, AnchoringNode, IterableNodeType { - - @Input(InputType.State) 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.forVoid()); - } - - 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()); - 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 == graph().start() || this instanceof MergeNode, "begin nodes must be connected"); - return super.verify(); - } - - @Override - public void generate(NodeLIRBuilderTool 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(); - } - } - - public FrameState getState() { - return stateAfter(); - } -}
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/AbstractFixedGuardNode.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/AbstractFixedGuardNode.java Mon Apr 14 15:21:27 2014 +0200 @@ -89,7 +89,7 @@ DeoptimizeNode deopt = graph().add(new DeoptimizeNode(action, reason)); deopt.setStateBefore(stateBefore()); IfNode ifNode; - AbstractBeginNode noDeoptSuccessor; + BeginNode noDeoptSuccessor; if (negated) { ifNode = graph().add(new IfNode(condition, deopt, next, 0)); noDeoptSuccessor = ifNode.falseSuccessor();
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/BeginNode.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/BeginNode.java Mon Apr 14 15:21:27 2014 +0200 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2013, 2013, Oracle and/or its affiliates. All rights reserved. + * 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 @@ -22,11 +22,153 @@ */ 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.graph.spi.*; +import com.oracle.graal.nodes.extended.*; +import com.oracle.graal.nodes.spi.*; import com.oracle.graal.nodes.type.*; -public final class BeginNode extends AbstractBeginNode { +@NodeInfo(allowedUsageTypes = {InputType.Guard, InputType.Anchor}) +public class BeginNode extends FixedWithNextNode implements LIRLowerable, Simplifiable, GuardingNode, AnchoringNode, IterableNodeType { public BeginNode() { super(StampFactory.forVoid()); } + + public 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()); + 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 == graph().start() || this instanceof MergeNode, "begin nodes must be connected"); + return super.verify(); + } + + @Override + public void generate(NodeLIRBuilderTool 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(); + } + } }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/BeginStateSplitNode.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/BeginStateSplitNode.java Mon Apr 14 15:21:27 2014 +0200 @@ -22,16 +22,19 @@ */ package com.oracle.graal.nodes; +import com.oracle.graal.graph.*; import com.oracle.graal.nodes.type.*; /** - * Base class for {@link AbstractBeginNode}s that are associated with a frame state. - * - * TODO (dnsimon) this not needed until {@link AbstractBeginNode} no longer implements + * 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 until loop peeling works without requiring begin nodes * to have frames states. */ -public abstract class BeginStateSplitNode extends AbstractBeginNode implements StateSplit { +public abstract class BeginStateSplitNode extends BeginNode implements StateSplit { + + @Input(InputType.State) private FrameState stateAfter; public BeginStateSplitNode() { } @@ -40,6 +43,16 @@ super(stamp); } + 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; + } + /** * A begin node has no side effect. */
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/ControlSplitNode.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/ControlSplitNode.java Mon Apr 14 15:21:27 2014 +0200 @@ -35,7 +35,7 @@ super(stamp); } - public abstract double probability(AbstractBeginNode successor); + public abstract double probability(BeginNode successor); - public abstract void setProbability(AbstractBeginNode successor, double value); + public abstract void setProbability(BeginNode successor, double value); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/EntryMarkerNode.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/EntryMarkerNode.java Mon Apr 14 15:21:27 2014 +0200 @@ -31,7 +31,7 @@ * by the graph builder. */ @NodeInfo(allowedUsageTypes = {InputType.Association}) -public class EntryMarkerNode extends AbstractBeginNode implements IterableNodeType, Simplifiable, LIRLowerable { +public class EntryMarkerNode extends BeginStateSplitNode implements IterableNodeType, Simplifiable, LIRLowerable { @Override public void simplify(SimplifierTool tool) {
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/GuardProxyNode.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/GuardProxyNode.java Mon Apr 14 15:21:27 2014 +0200 @@ -32,7 +32,7 @@ @Input(InputType.Guard) private GuardingNode value; - public GuardProxyNode(GuardingNode value, AbstractBeginNode proxyPoint) { + public GuardProxyNode(GuardingNode value, BeginNode proxyPoint) { super(StampFactory.forVoid(), proxyPoint); this.value = value; }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/IfNode.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/IfNode.java Mon Apr 14 15:21:27 2014 +0200 @@ -44,8 +44,8 @@ */ public final class IfNode extends ControlSplitNode implements Simplifiable, LIRLowerable, MemoryArithmeticLIRLowerable { - @Successor private AbstractBeginNode trueSuccessor; - @Successor private AbstractBeginNode falseSuccessor; + @Successor private BeginNode trueSuccessor; + @Successor private BeginNode falseSuccessor; @Input(InputType.Condition) private LogicNode condition; private double trueSuccessorProbability; @@ -59,10 +59,10 @@ } public IfNode(LogicNode condition, FixedNode trueSuccessor, FixedNode falseSuccessor, double trueSuccessorProbability) { - this(condition, AbstractBeginNode.begin(trueSuccessor), AbstractBeginNode.begin(falseSuccessor), trueSuccessorProbability); + this(condition, BeginNode.begin(trueSuccessor), BeginNode.begin(falseSuccessor), trueSuccessorProbability); } - public IfNode(LogicNode condition, AbstractBeginNode trueSuccessor, AbstractBeginNode falseSuccessor, double trueSuccessorProbability) { + public IfNode(LogicNode condition, BeginNode trueSuccessor, BeginNode falseSuccessor, double trueSuccessorProbability) { super(StampFactory.forVoid()); this.condition = condition; this.falseSuccessor = falseSuccessor; @@ -76,7 +76,7 @@ * * @return the true successor */ - public AbstractBeginNode trueSuccessor() { + public BeginNode trueSuccessor() { return trueSuccessor; } @@ -85,16 +85,16 @@ * * @return the false successor */ - public AbstractBeginNode falseSuccessor() { + public BeginNode falseSuccessor() { return falseSuccessor; } - public void setTrueSuccessor(AbstractBeginNode node) { + public void setTrueSuccessor(BeginNode node) { updatePredecessor(trueSuccessor, node); trueSuccessor = node; } - public void setFalseSuccessor(AbstractBeginNode node) { + public void setFalseSuccessor(BeginNode node) { updatePredecessor(falseSuccessor, node); falseSuccessor = node; } @@ -105,7 +105,7 @@ * @param istrue {@code true} if the true successor is requested, {@code false} otherwise * @return the corresponding successor */ - public AbstractBeginNode successor(boolean istrue) { + public BeginNode successor(boolean istrue) { return istrue ? trueSuccessor : falseSuccessor; } @@ -115,12 +115,12 @@ } @Override - public double probability(AbstractBeginNode successor) { + public double probability(BeginNode successor) { return successor == trueSuccessor ? trueSuccessorProbability : 1 - trueSuccessorProbability; } @Override - public void setProbability(AbstractBeginNode successor, double value) { + public void setProbability(BeginNode successor, double value) { assert successor == trueSuccessor || successor == falseSuccessor; setTrueSuccessorProbability(successor == trueSuccessor ? value : 1 - value); } @@ -146,8 +146,8 @@ @Override public void simplify(SimplifierTool tool) { if (condition() instanceof LogicNegationNode) { - AbstractBeginNode trueSucc = trueSuccessor(); - AbstractBeginNode falseSucc = falseSuccessor(); + BeginNode trueSucc = trueSuccessor(); + BeginNode falseSucc = falseSuccessor(); setTrueSuccessor(null); setFalseSuccessor(null); LogicNegationNode negation = (LogicNegationNode) condition(); @@ -182,7 +182,7 @@ } if (falseSuccessor().usages().isEmpty() && (!(falseSuccessor() instanceof LoopExitNode)) && falseSuccessor().next() instanceof IfNode) { - AbstractBeginNode intermediateBegin = falseSuccessor(); + BeginNode intermediateBegin = falseSuccessor(); IfNode nextIf = (IfNode) intermediateBegin.next(); double probabilityB = (1.0 - this.trueSuccessorProbability) * nextIf.trueSuccessorProbability; if (this.trueSuccessorProbability < probabilityB) { @@ -191,7 +191,7 @@ if (prepareForSwap(tool.getConstantReflection(), condition(), nextIf.condition(), this.trueSuccessorProbability, probabilityB)) { // Reording is allowed from (if1 => begin => if2) to (if2 => begin => if1). assert intermediateBegin.next() == nextIf; - AbstractBeginNode bothFalseBegin = nextIf.falseSuccessor(); + BeginNode bothFalseBegin = nextIf.falseSuccessor(); nextIf.setFalseSuccessor(null); intermediateBegin.setNext(null); this.setFalseSuccessor(null); @@ -547,8 +547,8 @@ List<AbstractEndNode> trueEnds = new ArrayList<>(mergePredecessors.size()); Map<AbstractEndNode, ValueNode> phiValues = new HashMap<>(mergePredecessors.size()); - AbstractBeginNode oldFalseSuccessor = falseSuccessor(); - AbstractBeginNode oldTrueSuccessor = trueSuccessor(); + BeginNode oldFalseSuccessor = falseSuccessor(); + BeginNode oldTrueSuccessor = trueSuccessor(); setFalseSuccessor(null); setTrueSuccessor(null); @@ -637,7 +637,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, AbstractBeginNode successor, MergeNode oldMerge, SimplifierTool tool) { + private void connectEnds(List<AbstractEndNode> ends, Map<AbstractEndNode, ValueNode> phiValues, BeginNode successor, MergeNode oldMerge, SimplifierTool tool) { if (!ends.isEmpty()) { if (ends.size() == 1) { AbstractEndNode end = ends.get(0); @@ -703,8 +703,8 @@ } private void removeEmptyIf(SimplifierTool tool) { - AbstractBeginNode originalTrueSuccessor = trueSuccessor(); - AbstractBeginNode originalFalseSuccessor = falseSuccessor(); + BeginNode originalTrueSuccessor = trueSuccessor(); + BeginNode 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 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/InvokeWithExceptionNode.java Mon Apr 14 15:21:27 2014 +0200 @@ -36,7 +36,7 @@ private static final double EXCEPTION_PROBA = 1e-5; - @Successor private AbstractBeginNode next; + @Successor private BeginNode next; @Successor private DispatchBeginNode exceptionEdge; @Input(InputType.Extension) private CallTargetNode callTarget; @Input(InputType.State) private FrameState stateDuring; @@ -66,11 +66,11 @@ exceptionEdge = x; } - public AbstractBeginNode next() { + public BeginNode next() { return next; } - public void setNext(AbstractBeginNode x) { + public void setNext(BeginNode x) { updatePredecessor(next, x); next = x; } @@ -163,7 +163,7 @@ } public void killExceptionEdge() { - AbstractBeginNode edge = exceptionEdge(); + BeginNode edge = exceptionEdge(); setExceptionEdge(null); GraphUtil.killCFG(edge); } @@ -196,12 +196,12 @@ } @Override - public double probability(AbstractBeginNode successor) { + public double probability(BeginNode successor) { return successor == next ? 1 - exceptionProbability : exceptionProbability; } @Override - public void setProbability(AbstractBeginNode successor, double value) { + public void setProbability(BeginNode successor, double value) { assert successor == next || successor == exceptionEdge; this.exceptionProbability = successor == next ? 1 - value : value; }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/KillingBeginNode.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/KillingBeginNode.java Mon Apr 14 15:21:27 2014 +0200 @@ -27,7 +27,7 @@ import com.oracle.graal.nodes.extended.*; @NodeInfo(allowedUsageTypes = {InputType.Memory}) -public class KillingBeginNode extends AbstractBeginNode implements MemoryCheckpoint.Single { +public class KillingBeginNode extends BeginNode implements MemoryCheckpoint.Single { private LocationIdentity locationIdentity;
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/LoopBeginNode.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/LoopBeginNode.java Mon Apr 14 15:21:27 2014 +0200 @@ -178,7 +178,7 @@ // nothing yet } - public boolean isLoopExit(AbstractBeginNode begin) { + public boolean isLoopExit(BeginNode begin) { return begin instanceof LoopExitNode && ((LoopExitNode) begin).loopBegin() == this; }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/MemoryProxyNode.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/MemoryProxyNode.java Mon Apr 14 15:21:27 2014 +0200 @@ -34,7 +34,7 @@ @Input(InputType.Memory) private MemoryNode value; private final LocationIdentity identity; - public MemoryProxyNode(MemoryNode value, AbstractBeginNode exit, LocationIdentity identity) { + public MemoryProxyNode(MemoryNode value, BeginNode exit, LocationIdentity identity) { super(StampFactory.forVoid(), exit); this.value = value; this.identity = identity;
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/ProxyNode.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/ProxyNode.java Mon Apr 14 15:21:27 2014 +0200 @@ -35,9 +35,9 @@ */ public abstract class ProxyNode extends FloatingNode implements IterableNodeType, ValueNumberable { - @Input(InputType.Association) private AbstractBeginNode proxyPoint; + @Input(InputType.Association) private BeginNode proxyPoint; - public ProxyNode(Stamp stamp, AbstractBeginNode proxyPoint) { + public ProxyNode(Stamp stamp, BeginNode proxyPoint) { super(stamp); assert proxyPoint != null; this.proxyPoint = proxyPoint; @@ -45,7 +45,7 @@ public abstract ValueNode value(); - public AbstractBeginNode proxyPoint() { + public BeginNode proxyPoint() { return proxyPoint; } @@ -57,15 +57,15 @@ return super.verify(); } - public static MemoryProxyNode forMemory(MemoryNode value, AbstractBeginNode exit, LocationIdentity location, StructuredGraph graph) { + public static MemoryProxyNode forMemory(MemoryNode value, BeginNode exit, LocationIdentity location, StructuredGraph graph) { return graph.unique(new MemoryProxyNode(value, exit, location)); } - public static ValueProxyNode forValue(ValueNode value, AbstractBeginNode exit, StructuredGraph graph) { + public static ValueProxyNode forValue(ValueNode value, BeginNode exit, StructuredGraph graph) { return graph.unique(new ValueProxyNode(value, exit)); } - public static GuardProxyNode forGuard(GuardingNode value, AbstractBeginNode exit, StructuredGraph graph) { + public static GuardProxyNode forGuard(GuardingNode value, BeginNode exit, StructuredGraph graph) { return graph.unique(new GuardProxyNode(value, exit)); } }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/StructuredGraph.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/StructuredGraph.java Mon Apr 14 15:21:27 2014 +0200 @@ -79,7 +79,7 @@ private boolean isAfterFloatingReadPhase = false; /** - * Creates a new Graph containing a single {@link AbstractBeginNode} as the {@link #start() + * Creates a new Graph containing a single {@link BeginNode} as the {@link #start() * start} node. */ public StructuredGraph() { @@ -87,7 +87,7 @@ } /** - * Creates a new Graph containing a single {@link AbstractBeginNode} as the {@link #start() + * Creates a new Graph containing a single {@link BeginNode} as the {@link #start() * start} node. */ public StructuredGraph(String name, ResolvedJavaMethod method) { @@ -255,8 +255,8 @@ */ public void removeFixed(FixedWithNextNode node) { assert node != null; - if (node instanceof AbstractBeginNode) { - ((AbstractBeginNode) node).prepareDelete(); + if (node instanceof BeginNode) { + ((BeginNode) node).prepareDelete(); } assert node.usages().isEmpty() : node + " " + node.usages(); FixedNode next = node.next(); @@ -295,7 +295,7 @@ node.safeDelete(); } - public void removeSplit(ControlSplitNode node, AbstractBeginNode survivingSuccessor) { + public void removeSplit(ControlSplitNode node, BeginNode survivingSuccessor) { assert node != null; assert node.usages().isEmpty(); assert survivingSuccessor != null; @@ -304,7 +304,7 @@ node.safeDelete(); } - public void removeSplitPropagate(ControlSplitNode node, AbstractBeginNode survivingSuccessor) { + public void removeSplitPropagate(ControlSplitNode node, BeginNode survivingSuccessor) { assert node != null; assert node.usages().isEmpty(); assert survivingSuccessor != null; @@ -321,7 +321,7 @@ } } - public void replaceSplit(ControlSplitNode node, Node replacement, AbstractBeginNode survivingSuccessor) { + public void replaceSplit(ControlSplitNode node, Node replacement, BeginNode survivingSuccessor) { if (replacement instanceof FixedWithNextNode) { replaceSplitWithFixed(node, (FixedWithNextNode) replacement, survivingSuccessor); } else { @@ -331,7 +331,7 @@ } } - public void replaceSplitWithFixed(ControlSplitNode node, FixedWithNextNode replacement, AbstractBeginNode survivingSuccessor) { + public void replaceSplitWithFixed(ControlSplitNode node, FixedWithNextNode replacement, BeginNode survivingSuccessor) { assert node != null && replacement != null && node.isAlive() && replacement.isAlive() : "cannot replace " + node + " with " + replacement; assert survivingSuccessor != null; node.clearSuccessors(); @@ -339,7 +339,7 @@ node.replaceAndDelete(replacement); } - public void replaceSplitWithFloating(ControlSplitNode node, FloatingNode replacement, AbstractBeginNode survivingSuccessor) { + public void replaceSplitWithFloating(ControlSplitNode node, FloatingNode replacement, BeginNode 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/ValueProxyNode.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/ValueProxyNode.java Mon Apr 14 15:21:27 2014 +0200 @@ -30,7 +30,7 @@ @Input private ValueNode value; - public ValueProxyNode(ValueNode value, AbstractBeginNode proxyPoint) { + public ValueProxyNode(ValueNode value, BeginNode proxyPoint) { super(value.stamp(), proxyPoint); this.value = value; }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/cfg/Block.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/cfg/Block.java Mon Apr 14 15:21:27 2014 +0200 @@ -29,7 +29,7 @@ public final class Block extends AbstractBlockBase<Block> { - protected final AbstractBeginNode beginNode; + protected final BeginNode beginNode; protected FixedNode endNode; protected Loop<Block> loop; @@ -37,11 +37,11 @@ protected List<Block> dominated; protected Block postdominator; - protected Block(AbstractBeginNode node) { + protected Block(BeginNode node) { this.beginNode = node; } - public AbstractBeginNode getBeginNode() { + public BeginNode getBeginNode() { return beginNode; } @@ -122,7 +122,7 @@ } else { cur = ((FixedWithNextNode) cur).next(); } - assert !(cur instanceof AbstractBeginNode); + assert !(cur instanceof BeginNode); return result; }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/cfg/ControlFlowGraph.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/cfg/ControlFlowGraph.java Mon Apr 14 15:21:27 2014 +0200 @@ -125,7 +125,7 @@ Node last; // assign proxies of a loop exit to this block - if (cur instanceof AbstractBeginNode) { + if (cur instanceof BeginNode) { for (Node usage : cur.usages()) { if (usage instanceof ProxyNode) { nodeToBlock.set(usage, block); @@ -146,7 +146,7 @@ last = cur; cur = cur.successors().first(); - } while (cur != null && !(cur instanceof AbstractBeginNode)); + } while (cur != null && !(cur instanceof BeginNode)); block.endNode = (FixedNode) last; } @@ -154,7 +154,7 @@ private void identifyBlocks() { // Find all block headers int numBlocks = 0; - for (AbstractBeginNode begin : graph.getNodes(AbstractBeginNode.class)) { + for (BeginNode begin : graph.getNodes(BeginNode.class)) { Block block = new Block(begin); numBlocks++; identifyBlock(block); @@ -256,7 +256,7 @@ for (Block b : loop.blocks) { for (Block sux : b.getSuccessors()) { if (sux.loop != loop) { - AbstractBeginNode begin = sux.getBeginNode(); + BeginNode 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 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/extended/IntegerSwitchNode.java Mon Apr 14 15:21:27 2014 +0200 @@ -49,7 +49,7 @@ * @param keyProbabilities the probabilities of the keys * @param keySuccessors the successor index for each key */ - public IntegerSwitchNode(ValueNode value, AbstractBeginNode[] successors, int[] keys, double[] keyProbabilities, int[] keySuccessors) { + public IntegerSwitchNode(ValueNode value, BeginNode[] successors, int[] keys, double[] keyProbabilities, int[] keySuccessors) { super(value, successors, keySuccessors, keyProbabilities); assert keySuccessors.length == keys.length + 1; assert keySuccessors.length == keyProbabilities.length; @@ -76,7 +76,7 @@ * @param keySuccessors the successor index for each key */ public IntegerSwitchNode(ValueNode value, int successorCount, int[] keys, double[] keyProbabilities, int[] keySuccessors) { - this(value, new AbstractBeginNode[successorCount], keys, keyProbabilities, keySuccessors); + this(value, new BeginNode[successorCount], keys, keyProbabilities, keySuccessors); } @Override @@ -139,7 +139,7 @@ tool.addToWorkList(defaultSuccessor()); graph().removeSplitPropagate(this, defaultSuccessor()); } else if (validKeys != keys.length) { - ArrayList<AbstractBeginNode> newSuccessors = new ArrayList<>(blockSuccessorCount()); + ArrayList<BeginNode> newSuccessors = new ArrayList<>(blockSuccessorCount()); int[] newKeys = new int[validKeys]; int[] newKeySuccessors = new int[validKeys + 1]; double[] newKeyProbabilities = new double[validKeys + 1]; @@ -172,14 +172,14 @@ } for (int i = 0; i < blockSuccessorCount(); i++) { - AbstractBeginNode successor = blockSuccessor(i); + BeginNode successor = blockSuccessor(i); if (!newSuccessors.contains(successor)) { tool.deleteBranch(successor); } setBlockSuccessor(i, null); } - AbstractBeginNode[] successorsArray = newSuccessors.toArray(new AbstractBeginNode[newSuccessors.size()]); + BeginNode[] successorsArray = newSuccessors.toArray(new BeginNode[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 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/extended/SwitchNode.java Mon Apr 14 15:21:27 2014 +0200 @@ -34,7 +34,7 @@ */ public abstract class SwitchNode extends ControlSplitNode { - @Successor private final NodeSuccessorList<AbstractBeginNode> successors; + @Successor private final NodeSuccessorList<BeginNode> 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, AbstractBeginNode[] successors, int[] keySuccessors, double[] keyProbabilities) { + public SwitchNode(ValueNode value, BeginNode[] successors, int[] keySuccessors, double[] keyProbabilities) { super(StampFactory.forVoid()); assert value.getKind() == Kind.Int || value.getKind() == Kind.Long || value.getKind() == Kind.Object : value.getKind() + " key not supported by SwitchNode"; assert keySuccessors.length == keyProbabilities.length; @@ -76,7 +76,7 @@ } @Override - public double probability(AbstractBeginNode successor) { + public double probability(BeginNode successor) { double sum = 0; for (int i = 0; i < keySuccessors.length; i++) { if (successors.get(keySuccessors[i]) == successor) { @@ -87,7 +87,7 @@ } @Override - public void setProbability(AbstractBeginNode successor, double value) { + public void setProbability(BeginNode successor, double value) { double changeInProbability = 0; int nonZeroProbabilityCases = 0; for (int i = 0; i < keySuccessors.length; i++) { @@ -139,7 +139,7 @@ /** * Returns the successor for the key at the given index. */ - public AbstractBeginNode keySuccessor(int i) { + public BeginNode keySuccessor(int i) { return successors.get(keySuccessors[i]); } @@ -157,11 +157,11 @@ return keySuccessors[keySuccessors.length - 1]; } - public AbstractBeginNode blockSuccessor(int i) { + public BeginNode blockSuccessor(int i) { return successors.get(i); } - public void setBlockSuccessor(int i, AbstractBeginNode s) { + public void setBlockSuccessor(int i, BeginNode s) { successors.set(i, s); } @@ -174,7 +174,7 @@ * * @return the default successor */ - public AbstractBeginNode defaultSuccessor() { + public BeginNode defaultSuccessor() { if (defaultSuccessorIndex() == -1) { throw new GraalInternalError("unexpected"); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/extended/ValueAnchorNode.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/extended/ValueAnchorNode.java Mon Apr 14 15:21:27 2014 +0200 @@ -91,7 +91,7 @@ @Override public void virtualize(VirtualizerTool tool) { - if (anchored != null && !(anchored instanceof AbstractBeginNode)) { + if (anchored != null && !(anchored instanceof BeginNode)) { State state = tool.getObjectState(anchored); if (state == null || state.getState() != EscapeState.Virtual) { return;
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/java/TypeSwitchNode.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/java/TypeSwitchNode.java Mon Apr 14 15:21:27 2014 +0200 @@ -51,7 +51,7 @@ * @param keyProbabilities the probabilities of the keys * @param keySuccessors the successor index for each key */ - public TypeSwitchNode(ValueNode value, AbstractBeginNode[] successors, ResolvedJavaType[] keys, double[] keyProbabilities, int[] keySuccessors) { + public TypeSwitchNode(ValueNode value, BeginNode[] successors, ResolvedJavaType[] keys, double[] keyProbabilities, int[] keySuccessors) { super(value, successors, keySuccessors, keyProbabilities); assert successors.length <= keys.length + 1; assert keySuccessors.length == keyProbabilities.length; @@ -134,7 +134,7 @@ tool.addToWorkList(defaultSuccessor()); graph().removeSplitPropagate(this, defaultSuccessor()); } else if (validKeys != keys.length) { - ArrayList<AbstractBeginNode> newSuccessors = new ArrayList<>(blockSuccessorCount()); + ArrayList<BeginNode> newSuccessors = new ArrayList<>(blockSuccessorCount()); ResolvedJavaType[] newKeys = new ResolvedJavaType[validKeys]; int[] newKeySuccessors = new int[validKeys + 1]; double[] newKeyProbabilities = new double[validKeys + 1]; @@ -167,14 +167,14 @@ } for (int i = 0; i < blockSuccessorCount(); i++) { - AbstractBeginNode successor = blockSuccessor(i); + BeginNode successor = blockSuccessor(i); if (!newSuccessors.contains(successor)) { tool.deleteBranch(successor); } setBlockSuccessor(i, null); } - AbstractBeginNode[] successorsArray = newSuccessors.toArray(new AbstractBeginNode[newSuccessors.size()]); + BeginNode[] successorsArray = newSuccessors.toArray(new BeginNode[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/spi/NodeLIRBuilderTool.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/spi/NodeLIRBuilderTool.java Mon Apr 14 15:21:27 2014 +0200 @@ -59,7 +59,7 @@ LIRGeneratorTool getLIRGeneratorTool(); - void emitOverflowCheckBranch(AbstractBeginNode overflowSuccessor, AbstractBeginNode next, double probability); + void emitOverflowCheckBranch(BeginNode overflowSuccessor, BeginNode next, double probability); Value[] visitInvokeArguments(CallingConvention cc, Collection<ValueNode> arguments);
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/util/GraphUtil.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/util/GraphUtil.java Mon Apr 14 15:21:27 2014 +0200 @@ -163,7 +163,7 @@ } public static void checkRedundantProxy(ProxyNode vpn) { - AbstractBeginNode proxyPoint = vpn.proxyPoint(); + BeginNode 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 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/ConditionalEliminationPhase.java Mon Apr 14 15:21:27 2014 +0200 @@ -407,7 +407,7 @@ } } - private void registerControlSplitInfo(Node pred, AbstractBeginNode begin) { + private void registerControlSplitInfo(Node pred, BeginNode begin) { assert pred != null && begin != null; if (begin instanceof LoopExitNode) { state.clear(); @@ -656,8 +656,8 @@ @Override protected void node(FixedNode node) { - if (node instanceof AbstractBeginNode) { - AbstractBeginNode begin = (AbstractBeginNode) node; + if (node instanceof BeginNode) { + BeginNode begin = (BeginNode) node; Node pred = node.predecessor(); if (pred != null) { @@ -742,7 +742,7 @@ LogicNode replacement = null; ValueNode replacementAnchor = null; - AbstractBeginNode survivingSuccessor = null; + BeginNode survivingSuccessor = null; if (state.trueConditions.containsKey(compare)) { replacement = trueConstant; replacementAnchor = state.trueConditions.get(compare); @@ -764,7 +764,7 @@ } if (replacement != null) { - if (!(replacementAnchor instanceof AbstractBeginNode)) { + if (!(replacementAnchor instanceof BeginNode)) { ValueAnchorNode anchor = graph.add(new ValueAnchorNode(replacementAnchor)); graph.addBeforeFixed(ifNode, anchor); }
--- a/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/ConvertDeoptimizeToGuardPhase.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/ConvertDeoptimizeToGuardPhase.java Mon Apr 14 15:21:27 2014 +0200 @@ -47,11 +47,11 @@ */ public class ConvertDeoptimizeToGuardPhase extends Phase { - private static AbstractBeginNode findBeginNode(FixedNode startNode) { + private static BeginNode findBeginNode(FixedNode startNode) { Node n = startNode; while (true) { - if (n instanceof AbstractBeginNode) { - return (AbstractBeginNode) n; + if (n instanceof BeginNode) { + return (BeginNode) n; } else { n = n.predecessor(); } @@ -71,7 +71,7 @@ for (FixedGuardNode fixedGuard : graph.getNodes(FixedGuardNode.class)) { - AbstractBeginNode pred = BeginNode.prevBegin(fixedGuard); + BeginNode pred = BeginNode.prevBegin(fixedGuard); if (pred instanceof MergeNode) { MergeNode merge = (MergeNode) pred; if (fixedGuard.condition() instanceof CompareNode) { @@ -109,17 +109,17 @@ new DeadCodeEliminationPhase().apply(graph); } - private void visitDeoptBegin(AbstractBeginNode deoptBegin, DeoptimizationAction deoptAction, DeoptimizationReason deoptReason, StructuredGraph graph) { + private void visitDeoptBegin(BeginNode deoptBegin, DeoptimizationAction deoptAction, DeoptimizationReason deoptReason, StructuredGraph graph) { if (deoptBegin instanceof MergeNode) { MergeNode mergeNode = (MergeNode) deoptBegin; Debug.log("Visiting %s", mergeNode); - List<AbstractBeginNode> begins = new ArrayList<>(); + List<BeginNode> begins = new ArrayList<>(); for (AbstractEndNode end : mergeNode.forwardEnds()) { - AbstractBeginNode newBeginNode = findBeginNode(end); + BeginNode newBeginNode = findBeginNode(end); assert !begins.contains(newBeginNode); begins.add(newBeginNode); } - for (AbstractBeginNode begin : begins) { + for (BeginNode begin : begins) { assert !begin.isDeleted(); visitDeoptBegin(begin, deoptAction, deoptReason, graph); } @@ -127,11 +127,11 @@ return; } else if (deoptBegin.predecessor() instanceof IfNode) { IfNode ifNode = (IfNode) deoptBegin.predecessor(); - AbstractBeginNode otherBegin = ifNode.trueSuccessor(); + BeginNode otherBegin = ifNode.trueSuccessor(); LogicNode conditionNode = ifNode.condition(); FixedGuardNode guard = graph.add(new FixedGuardNode(conditionNode, deoptReason, deoptAction, deoptBegin == ifNode.trueSuccessor())); FixedWithNextNode pred = (FixedWithNextNode) ifNode.predecessor(); - AbstractBeginNode survivingSuccessor; + BeginNode survivingSuccessor; if (deoptBegin == ifNode.trueSuccessor()) { survivingSuccessor = ifNode.falseSuccessor(); } else {
--- a/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/ExpandLogicPhase.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/ExpandLogicPhase.java Mon Apr 14 15:21:27 2014 +0200 @@ -54,8 +54,8 @@ } private static void processIf(LogicNode x, boolean xNegated, LogicNode y, boolean yNegated, IfNode ifNode, double shortCircuitProbability) { - AbstractBeginNode trueTarget = ifNode.trueSuccessor(); - AbstractBeginNode falseTarget = ifNode.falseSuccessor(); + BeginNode trueTarget = ifNode.trueSuccessor(); + BeginNode falseTarget = ifNode.falseSuccessor(); double firstIfProbability = shortCircuitProbability; /* * P(Y | not(X)) = P(Y inter not(X)) / P(not(X)) = (P(X union Y) - P(X)) / (1 - P(X)) @@ -77,9 +77,9 @@ EndNode secondTrueEnd = graph.add(new EndNode()); trueTargetMerge.addForwardEnd(firstTrueEnd); trueTargetMerge.addForwardEnd(secondTrueEnd); - AbstractBeginNode firstTrueTarget = AbstractBeginNode.begin(firstTrueEnd); - AbstractBeginNode secondTrueTarget = AbstractBeginNode.begin(secondTrueEnd); - AbstractBeginNode secondIf = AbstractBeginNode.begin(graph.add(new IfNode(y, yNegated ? falseTarget : secondTrueTarget, yNegated ? secondTrueTarget : falseTarget, secondIfProbability))); + BeginNode firstTrueTarget = BeginNode.begin(firstTrueEnd); + BeginNode secondTrueTarget = BeginNode.begin(secondTrueEnd); + BeginNode secondIf = BeginNode.begin(graph.add(new IfNode(y, yNegated ? falseTarget : secondTrueTarget, yNegated ? secondTrueTarget : falseTarget, secondIfProbability))); IfNode firstIf = graph.add(new IfNode(x, xNegated ? secondIf : firstTrueTarget, xNegated ? firstTrueTarget : secondIf, firstIfProbability)); ifNode.replaceAtPredecessor(firstIf); ifNode.safeDelete();
--- a/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/FloatingReadPhase.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/FloatingReadPhase.java Mon Apr 14 15:21:27 2014 +0200 @@ -191,7 +191,7 @@ } @Override - protected Set<LocationIdentity> afterSplit(AbstractBeginNode node, Set<LocationIdentity> oldState) { + protected Set<LocationIdentity> afterSplit(BeginNode node, Set<LocationIdentity> oldState) { return new HashSet<>(oldState); } @@ -292,7 +292,7 @@ } @Override - protected MemoryMapImpl afterSplit(AbstractBeginNode node, MemoryMapImpl oldState) { + protected MemoryMapImpl afterSplit(BeginNode node, MemoryMapImpl oldState) { MemoryMapImpl result = new MemoryMapImpl(oldState); if (node.predecessor() instanceof InvokeWithExceptionNode) { /*
--- a/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/FrameStateAssignmentPhase.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/FrameStateAssignmentPhase.java Mon Apr 14 15:21:27 2014 +0200 @@ -92,7 +92,7 @@ } @Override - protected FrameState afterSplit(AbstractBeginNode node, FrameState oldState) { + protected FrameState afterSplit(BeginNode node, FrameState oldState) { return oldState; }
--- a/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/GuardLoweringPhase.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/GuardLoweringPhase.java Mon Apr 14 15:21:27 2014 +0200 @@ -154,12 +154,12 @@ private void lowerToIf(GuardNode guard) { StructuredGraph graph = guard.graph(); - AbstractBeginNode fastPath = graph.add(new BeginNode()); + BeginNode fastPath = graph.add(new BeginNode()); @SuppressWarnings("deprecation") DeoptimizeNode deopt = graph.add(new DeoptimizeNode(guard.action(), guard.reason(), useGuardIdAsDebugId ? guard.getId() : 0, guard.getSpeculation())); - AbstractBeginNode deoptBranch = AbstractBeginNode.begin(deopt); - AbstractBeginNode trueSuccessor; - AbstractBeginNode falseSuccessor; + BeginNode deoptBranch = BeginNode.begin(deopt); + BeginNode trueSuccessor; + BeginNode 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 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/InliningUtil.java Mon Apr 14 15:21:27 2014 +0200 @@ -646,7 +646,7 @@ } // create one separate block for each invoked method - AbstractBeginNode[] successors = new AbstractBeginNode[numberOfMethods + 1]; + BeginNode[] successors = new BeginNode[numberOfMethods + 1]; for (int i = 0; i < numberOfMethods; i++) { successors[i] = createInvocationBlock(graph, invoke, returnMerge, returnValuePhi, exceptionMerge, exceptionObjectPhi, true); } @@ -658,7 +658,7 @@ } else { unknownTypeSux = graph.add(new DeoptimizeNode(DeoptimizationAction.InvalidateReprofile, DeoptimizationReason.TypeCheckedInliningViolated)); } - successors[successors.length - 1] = AbstractBeginNode.begin(unknownTypeSux); + successors[successors.length - 1] = BeginNode.begin(unknownTypeSux); // replace the invoke exception edge if (invoke instanceof InvokeWithExceptionNode) { @@ -684,7 +684,7 @@ // do the actual inlining for every invoke for (int i = 0; i < numberOfMethods; i++) { - AbstractBeginNode node = successors[i]; + BeginNode node = successors[i]; Invoke invokeForInlining = (Invoke) node.next(); ResolvedJavaType commonType; @@ -770,10 +770,10 @@ private void inlineSingleMethod(StructuredGraph graph, MetaAccessProvider metaAccess, Assumptions assumptions) { assert concretes.size() == 1 && inlineableElements.length == 1 && ptypes.size() > 1 && !shouldFallbackToInvoke() && notRecordedTypeProbability == 0; - AbstractBeginNode calleeEntryNode = graph.add(new BeginNode()); + BeginNode calleeEntryNode = graph.add(new BeginNode()); - AbstractBeginNode unknownTypeSux = createUnknownTypeSuccessor(graph); - AbstractBeginNode[] successors = new AbstractBeginNode[]{calleeEntryNode, unknownTypeSux}; + BeginNode unknownTypeSux = createUnknownTypeSuccessor(graph); + BeginNode[] successors = new BeginNode[]{calleeEntryNode, unknownTypeSux}; createDispatchOnTypeBeforeInvoke(graph, successors, false, metaAccess); calleeEntryNode.setNext(invoke.asNode()); @@ -781,7 +781,7 @@ inline(invoke, methodAt(0), inlineableElementAt(0), assumptions, false); } - private boolean createDispatchOnTypeBeforeInvoke(StructuredGraph graph, AbstractBeginNode[] successors, boolean invokeIsOnlySuccessor, MetaAccessProvider metaAccess) { + private boolean createDispatchOnTypeBeforeInvoke(StructuredGraph graph, BeginNode[] successors, boolean invokeIsOnlySuccessor, MetaAccessProvider metaAccess) { assert ptypes.size() >= 1; ValueNode nonNullReceiver = nonNullReceiver(invoke); Kind hubKind = ((MethodCallTargetNode) invoke.callTarget()).targetMethod().getDeclaringClass().getEncoding(Representation.ObjectHub).getKind(); @@ -891,10 +891,10 @@ return costEstimateMethodDispatch < costEstimateTypeDispatch; } - private static AbstractBeginNode createInvocationBlock(StructuredGraph graph, Invoke invoke, MergeNode returnMerge, PhiNode returnValuePhi, MergeNode exceptionMerge, + private static BeginNode createInvocationBlock(StructuredGraph graph, Invoke invoke, MergeNode returnMerge, PhiNode returnValuePhi, MergeNode exceptionMerge, PhiNode exceptionObjectPhi, boolean useForInlining) { Invoke duplicatedInvoke = duplicateInvokeForInlining(graph, invoke, exceptionMerge, exceptionObjectPhi, useForInlining); - AbstractBeginNode calleeEntryNode = graph.add(new BeginNode()); + BeginNode calleeEntryNode = graph.add(new BeginNode()); calleeEntryNode.setNext(duplicatedInvoke.asNode()); AbstractEndNode endNode = graph.add(new EndNode()); @@ -969,9 +969,9 @@ } private void devirtualizeWithTypeSwitch(StructuredGraph graph, InvokeKind kind, ResolvedJavaMethod target, MetaAccessProvider metaAccess) { - AbstractBeginNode invocationEntry = graph.add(new BeginNode()); - AbstractBeginNode unknownTypeSux = createUnknownTypeSuccessor(graph); - AbstractBeginNode[] successors = new AbstractBeginNode[]{invocationEntry, unknownTypeSux}; + BeginNode invocationEntry = graph.add(new BeginNode()); + BeginNode unknownTypeSux = createUnknownTypeSuccessor(graph); + BeginNode[] successors = new BeginNode[]{invocationEntry, unknownTypeSux}; createDispatchOnTypeBeforeInvoke(graph, successors, true, metaAccess); invocationEntry.setNext(invoke.asNode()); @@ -981,8 +981,8 @@ replaceInvokeCallTarget(invoke, graph, kind, target); } - private static AbstractBeginNode createUnknownTypeSuccessor(StructuredGraph graph) { - return AbstractBeginNode.begin(graph.add(new DeoptimizeNode(DeoptimizationAction.InvalidateReprofile, DeoptimizationReason.TypeCheckedInliningViolated))); + private static BeginNode createUnknownTypeSuccessor(StructuredGraph graph) { + return BeginNode.begin(graph.add(new DeoptimizeNode(DeoptimizationAction.InvalidateReprofile, DeoptimizationReason.TypeCheckedInliningViolated))); } @Override @@ -1347,7 +1347,7 @@ } } - final AbstractBeginNode prevBegin = AbstractBeginNode.prevBegin(invokeNode); + final BeginNode prevBegin = BeginNode.prevBegin(invokeNode); DuplicationReplacement localReplacement = new DuplicationReplacement() { public Node replacement(Node node) { @@ -1386,7 +1386,7 @@ } // get rid of memory kill - AbstractBeginNode begin = invokeWithException.next(); + BeginNode begin = invokeWithException.next(); if (begin instanceof KillingBeginNode) { BeginNode newBegin = new BeginNode(); graph.addAfterFixed(begin, graph.add(newBegin));
--- a/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/OptimizeGuardAnchorsPhase.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/OptimizeGuardAnchorsPhase.java Mon Apr 14 15:21:27 2014 +0200 @@ -55,11 +55,11 @@ @Override protected void run(StructuredGraph graph) { LazyCFG cfg = new LazyCFG(graph); - for (AbstractBeginNode begin : graph.getNodes(AbstractBeginNode.class)) { + for (BeginNode begin : graph.getNodes(BeginNode.class)) { if (!(begin instanceof StartNode || begin.predecessor() instanceof ControlSplitNode)) { NodeIterable<GuardNode> guards = begin.guards(); if (guards.isNotEmpty()) { - AbstractBeginNode newAnchor = computeOptimalAnchor(cfg.get(), begin); + BeginNode newAnchor = computeOptimalAnchor(cfg.get(), begin); // newAnchor == begin is possible because postdominator computation assumes that // loops never end if (newAnchor != begin) { @@ -76,14 +76,14 @@ } } - public static AbstractBeginNode getOptimalAnchor(LazyCFG cfg, AbstractBeginNode begin) { + public static BeginNode getOptimalAnchor(LazyCFG cfg, BeginNode begin) { if (begin instanceof StartNode || begin.predecessor() instanceof ControlSplitNode) { return begin; } return computeOptimalAnchor(cfg.get(), begin); } - private static AbstractBeginNode computeOptimalAnchor(ControlFlowGraph cfg, AbstractBeginNode begin) { + private static BeginNode computeOptimalAnchor(ControlFlowGraph cfg, BeginNode begin) { Block anchor = cfg.blockFor(begin); while (anchor.getDominator() != null && anchor.getDominator().getPostdominator() == anchor) { anchor = anchor.getDominator(); @@ -92,7 +92,7 @@ } private static void optimizeAtControlSplit(ControlSplitNode controlSplit, LazyCFG cfg) { - AbstractBeginNode successor = findMinimumUsagesSuccessor(controlSplit); + BeginNode successor = findMinimumUsagesSuccessor(controlSplit); int successorCount = controlSplit.successors().count(); List<GuardNode> otherGuards = new ArrayList<>(successorCount - 1); for (GuardNode guard : successor.guards().snapshot()) { @@ -109,7 +109,7 @@ } if (otherGuards.size() == successorCount - 1) { - AbstractBeginNode anchor = computeOptimalAnchor(cfg.get(), AbstractBeginNode.prevBegin(controlSplit)); + BeginNode anchor = computeOptimalAnchor(cfg.get(), BeginNode.prevBegin(controlSplit)); GuardNode newGuard = controlSplit.graph().unique(new GuardNode(guard.condition(), anchor, guard.reason(), guard.action(), guard.negated(), guard.getSpeculation())); for (GuardNode otherGuard : otherGuards) { otherGuard.replaceAndDelete(newGuard); @@ -126,12 +126,12 @@ conditonGuard.getSpeculation().equals(guard.getSpeculation()); } - private static AbstractBeginNode findMinimumUsagesSuccessor(ControlSplitNode controlSplit) { + private static BeginNode findMinimumUsagesSuccessor(ControlSplitNode controlSplit) { NodeClassIterator successors = controlSplit.successors().iterator(); - AbstractBeginNode min = (AbstractBeginNode) successors.next(); + BeginNode min = (BeginNode) successors.next(); int minUsages = min.usages().count(); while (successors.hasNext()) { - AbstractBeginNode successor = (AbstractBeginNode) successors.next(); + BeginNode successor = (BeginNode) successors.next(); int count = successor.usages().count(); if (count < minUsages) { minUsages = count;
--- a/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/ProfileCompiledMethodsPhase.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/ProfileCompiledMethodsPhase.java Mon Apr 14 15:21:27 2014 +0200 @@ -108,7 +108,7 @@ private static double getNodeWeight(ScheduledNode node) { if (node instanceof MergeNode) { return ((MergeNode) node).phiPredecessorCount(); - } else if (node instanceof AbstractBeginNode || node instanceof AbstractEndNode || node instanceof MonitorIdNode || node instanceof ConstantNode || node instanceof ParameterNode || + } else if (node instanceof BeginNode || node instanceof AbstractEndNode || node instanceof MonitorIdNode || node instanceof ConstantNode || node instanceof ParameterNode || node instanceof CallTargetNode || node instanceof ValueProxy || node instanceof VirtualObjectNode || node instanceof ReinterpretNode) { return 0; } else if (node instanceof AccessMonitorNode) {
--- a/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/TailDuplicationPhase.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/TailDuplicationPhase.java Mon Apr 14 15:21:27 2014 +0200 @@ -293,7 +293,7 @@ // EndNode FixedWithNextNode anchorDuplicate = (FixedWithNextNode) duplicates.get(anchor); // move dependencies on the ValueAnchorNode to the previous BeginNode - AbstractBeginNode prevBegin = AbstractBeginNode.prevBegin(forwardEnd); + BeginNode prevBegin = BeginNode.prevBegin(forwardEnd); anchorDuplicate.replaceAtUsages(InputType.Guard, prevBegin); anchorDuplicate.replaceAtUsages(InputType.Anchor, prevBegin); assert anchorDuplicate.usages().isEmpty();
--- a/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/UseTrappingNullChecksPhase.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/UseTrappingNullChecksPhase.java Mon Apr 14 15:21:27 2014 +0200 @@ -55,7 +55,7 @@ } Node predecessor = deopt.predecessor(); Node branch = null; - while (predecessor instanceof AbstractBeginNode) { + while (predecessor instanceof BeginNode) { branch = predecessor; predecessor = predecessor.predecessor(); } @@ -73,8 +73,8 @@ private static void replaceWithTrappingNullCheck(DeoptimizeNode deopt, IfNode ifNode, LogicNode condition) { IsNullNode isNullNode = (IsNullNode) condition; - AbstractBeginNode nonTrappingContinuation = ifNode.falseSuccessor(); - AbstractBeginNode trappingContinuation = ifNode.trueSuccessor(); + BeginNode nonTrappingContinuation = ifNode.falseSuccessor(); + BeginNode trappingContinuation = ifNode.trueSuccessor(); NullCheckNode trappingNullCheck = deopt.graph().add(new NullCheckNode(isNullNode.object())); trappingNullCheck.setStateBefore(deopt.stateBefore()); deopt.graph().replaceSplit(ifNode, trappingNullCheck, nonTrappingContinuation);
--- a/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/graph/ComputeInliningRelevanceClosure.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/graph/ComputeInliningRelevanceClosure.java Mon Apr 14 15:21:27 2014 +0200 @@ -171,7 +171,7 @@ int pathBeginCount = pathBeginNodes.size(); for (Node sux : controlSplit.successors()) { - double probability = controlSplit.probability((AbstractBeginNode) sux); + double probability = controlSplit.probability((BeginNode) sux); if (probability > maxProbability) { maxProbability = probability; maxSux = sux;
--- a/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/graph/ComputeProbabilityClosure.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/graph/ComputeProbabilityClosure.java Mon Apr 14 15:21:27 2014 +0200 @@ -223,7 +223,7 @@ } @Override - public void afterSplit(AbstractBeginNode node) { + public void afterSplit(BeginNode node) { assert node.predecessor() != null; Node pred = node.predecessor(); ControlSplitNode x = (ControlSplitNode) pred;
--- a/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/graph/MergeableState.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/graph/MergeableState.java Mon Apr 14 15:21:27 2014 +0200 @@ -58,7 +58,7 @@ * * @param node the successor of the control split that is about to be visited */ - public void afterSplit(AbstractBeginNode node) { + public void afterSplit(BeginNode node) { // empty default implementation } }
--- a/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/graph/PostOrderNodeIterator.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/graph/PostOrderNodeIterator.java Mon Apr 14 15:21:27 2014 +0200 @@ -43,7 +43,7 @@ public abstract class PostOrderNodeIterator<T extends MergeableState<T>> { private final NodeBitMap visitedEnds; - private final Deque<AbstractBeginNode> nodeQueue; + private final Deque<BeginNode> 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((AbstractBeginNode) node); + nodeQueue.addFirst((BeginNode) node); } } } else { for (Node node : x.successors()) { if (node != null) { - nodeQueue.addFirst((AbstractBeginNode) node); + nodeQueue.addFirst((BeginNode) node); } } } @@ -124,7 +124,7 @@ private FixedNode nextQueuedNode() { int maxIterations = nodeQueue.size(); while (maxIterations-- > 0) { - AbstractBeginNode node = nodeQueue.removeFirst(); + BeginNode 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 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/graph/ReentrantNodeIterator.java Mon Apr 14 15:21:27 2014 +0200 @@ -41,7 +41,7 @@ protected abstract StateT merge(MergeNode merge, List<StateT> states); - protected abstract StateT afterSplit(AbstractBeginNode node, StateT oldState); + protected abstract StateT afterSplit(BeginNode node, StateT oldState); protected abstract Map<LoopExitNode, StateT> processLoop(LoopBeginNode loop, StateT initialState); @@ -81,7 +81,7 @@ } public static <StateT> Map<FixedNode, StateT> apply(NodeIteratorClosure<StateT> closure, FixedNode start, StateT initialState, Set<FixedNode> boundary) { - Deque<AbstractBeginNode> nodeQueue = new ArrayDeque<>(); + Deque<BeginNode> nodeQueue = new ArrayDeque<>(); IdentityHashMap<FixedNode, StateT> blockEndStates = new IdentityHashMap<>(); StateT state = initialState; @@ -146,14 +146,14 @@ continue; } else { while (successors.hasNext()) { - AbstractBeginNode successor = (AbstractBeginNode) successors.next(); + BeginNode successor = (BeginNode) successors.next(); StateT successorState = closure.afterSplit(successor, state); if (closure.continueIteration(successorState)) { blockEndStates.put(successor, successorState); nodeQueue.add(successor); } } - state = closure.afterSplit((AbstractBeginNode) firstSuccessor, state); + state = closure.afterSplit((BeginNode) firstSuccessor, state); current = closure.continueIteration(state) ? firstSuccessor : null; continue; } @@ -167,7 +167,7 @@ } else { current = nodeQueue.removeFirst(); state = blockEndStates.get(current); - assert !(current instanceof MergeNode) && current instanceof AbstractBeginNode; + assert !(current instanceof MergeNode) && current instanceof BeginNode; } } while (true); }
--- a/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/graph/StatelessPostOrderNodeIterator.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/graph/StatelessPostOrderNodeIterator.java Mon Apr 14 15:21:27 2014 +0200 @@ -36,7 +36,7 @@ public abstract class StatelessPostOrderNodeIterator { private final NodeBitMap visitedEnds; - private final Deque<AbstractBeginNode> nodeQueue; + private final Deque<BeginNode> nodeQueue; private final FixedNode start; public StatelessPostOrderNodeIterator(FixedNode start) { @@ -76,7 +76,7 @@ controlSplit((ControlSplitNode) current); for (Node node : current.successors()) { if (node != null) { - nodeQueue.addFirst((AbstractBeginNode) node); + nodeQueue.addFirst((BeginNode) node); } } current = nodeQueue.pollFirst();
--- a/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/schedule/SchedulePhase.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/schedule/SchedulePhase.java Mon Apr 14 15:21:27 2014 +0200 @@ -201,7 +201,7 @@ } } - AbstractBeginNode startNode = cfg.getStartBlock().getBeginNode(); + BeginNode startNode = cfg.getStartBlock().getBeginNode(); assert startNode instanceof StartNode; KillSet accm = foundExcludeNode ? set : excludedLocations; @@ -753,7 +753,7 @@ // If a FrameState is an outer FrameState this method behaves as if the inner // FrameState was the actual usage, by recursing. blocksForUsage(node, unscheduledUsage, closure, strategy); - } else if (unscheduledUsage instanceof AbstractBeginNode) { + } else if (unscheduledUsage instanceof BeginNode) { // Only FrameStates can be connected to BeginNodes. if (!(usage instanceof FrameState)) { throw new SchedulingError(usage.toString()); @@ -1047,7 +1047,7 @@ } } - if (instruction instanceof AbstractBeginNode) { + if (instruction instanceof BeginNode) { ArrayList<ProxyNode> proxies = (instruction instanceof LoopExitNode) ? new ArrayList<>() : 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 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.printer/src/com/oracle/graal/printer/CFGPrinter.java Mon Apr 14 15:21:27 2014 +0200 @@ -488,7 +488,7 @@ return "-"; } String prefix; - if (node instanceof AbstractBeginNode && (lir == null && schedule == null)) { + if (node instanceof BeginNode && (lir == null && schedule == 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 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.printer/src/com/oracle/graal/printer/IdealGraphPrinter.java Mon Apr 14 15:21:27 2014 +0200 @@ -171,7 +171,7 @@ printProperty(bit, "true"); } } - if (node.getClass() == AbstractBeginNode.class) { + if (node.getClass() == BeginNode.class) { printProperty("shortName", "B"); } else if (node.getClass() == AbstractEndNode.class) { printProperty("shortName", "E");
--- a/graal/com.oracle.graal.replacements/src/com/oracle/graal/replacements/CollapseFrameForSingleSideEffectPhase.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.replacements/src/com/oracle/graal/replacements/CollapseFrameForSingleSideEffectPhase.java Mon Apr 14 15:21:27 2014 +0200 @@ -65,7 +65,7 @@ return new IterationState(this, sideEffect.asNode(), null, true); } - public IterationState addBranch(AbstractBeginNode begin) { + public IterationState addBranch(BeginNode begin) { return new IterationState(this, begin, null, this.invalid); } @@ -192,7 +192,7 @@ } @Override - protected IterationState afterSplit(AbstractBeginNode node, IterationState oldState) { + protected IterationState afterSplit(BeginNode node, IterationState oldState) { return oldState.addBranch(node); }
--- a/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/nodes/arithmetic/IntegerAddExactNode.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/nodes/arithmetic/IntegerAddExactNode.java Mon Apr 14 15:21:27 2014 +0200 @@ -77,7 +77,7 @@ } @Override - public IntegerExactArithmeticSplitNode createSplit(AbstractBeginNode next, AbstractBeginNode deopt) { + public IntegerExactArithmeticSplitNode createSplit(BeginNode next, BeginNode deopt) { return graph().add(new IntegerAddExactSplitNode(stamp(), x(), y(), next, deopt)); }
--- a/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/nodes/arithmetic/IntegerAddExactSplitNode.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/nodes/arithmetic/IntegerAddExactSplitNode.java Mon Apr 14 15:21:27 2014 +0200 @@ -29,7 +29,7 @@ public class IntegerAddExactSplitNode extends IntegerExactArithmeticSplitNode { - public IntegerAddExactSplitNode(Stamp stamp, ValueNode x, ValueNode y, AbstractBeginNode next, AbstractBeginNode overflowSuccessor) { + public IntegerAddExactSplitNode(Stamp stamp, ValueNode x, ValueNode y, BeginNode next, BeginNode overflowSuccessor) { super(stamp, x, y, next, overflowSuccessor); }
--- a/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/nodes/arithmetic/IntegerExactArithmeticNode.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/nodes/arithmetic/IntegerExactArithmeticNode.java Mon Apr 14 15:21:27 2014 +0200 @@ -28,5 +28,5 @@ interface IntegerExactArithmeticNode extends Lowerable, IterableNodeType { - IntegerExactArithmeticSplitNode createSplit(AbstractBeginNode next, AbstractBeginNode deopt); + IntegerExactArithmeticSplitNode createSplit(BeginNode next, BeginNode deopt); }
--- a/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/nodes/arithmetic/IntegerExactArithmeticSplitNode.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/nodes/arithmetic/IntegerExactArithmeticSplitNode.java Mon Apr 14 15:21:27 2014 +0200 @@ -30,12 +30,12 @@ public abstract class IntegerExactArithmeticSplitNode extends ControlSplitNode implements LIRLowerable { - @Successor private AbstractBeginNode overflowSuccessor; - @Successor private AbstractBeginNode next; + @Successor private BeginNode overflowSuccessor; + @Successor private BeginNode next; @Input private ValueNode x; @Input private ValueNode y; - public IntegerExactArithmeticSplitNode(Stamp stamp, ValueNode x, ValueNode y, AbstractBeginNode next, AbstractBeginNode overflowSuccessor) { + public IntegerExactArithmeticSplitNode(Stamp stamp, ValueNode x, ValueNode y, BeginNode next, BeginNode overflowSuccessor) { super(stamp); this.x = x; this.y = y; @@ -44,20 +44,20 @@ } @Override - public double probability(AbstractBeginNode successor) { + public double probability(BeginNode successor) { return successor == next ? 1 : 0; } @Override - public void setProbability(AbstractBeginNode successor, double value) { + public void setProbability(BeginNode successor, double value) { assert probability(successor) == value; } - public AbstractBeginNode getNext() { + public BeginNode getNext() { return next; } - public AbstractBeginNode getOverflowSuccessor() { + public BeginNode getOverflowSuccessor() { return overflowSuccessor; }
--- a/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/nodes/arithmetic/IntegerMulExactNode.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/nodes/arithmetic/IntegerMulExactNode.java Mon Apr 14 15:21:27 2014 +0200 @@ -74,7 +74,7 @@ } @Override - public IntegerExactArithmeticSplitNode createSplit(AbstractBeginNode next, AbstractBeginNode deopt) { + public IntegerExactArithmeticSplitNode createSplit(BeginNode next, BeginNode deopt) { return graph().add(new IntegerMulExactSplitNode(stamp(), x(), y(), next, deopt)); }
--- a/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/nodes/arithmetic/IntegerMulExactSplitNode.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/nodes/arithmetic/IntegerMulExactSplitNode.java Mon Apr 14 15:21:27 2014 +0200 @@ -29,7 +29,7 @@ public class IntegerMulExactSplitNode extends IntegerExactArithmeticSplitNode { - public IntegerMulExactSplitNode(Stamp stamp, ValueNode x, ValueNode y, AbstractBeginNode next, AbstractBeginNode overflowSuccessor) { + public IntegerMulExactSplitNode(Stamp stamp, ValueNode x, ValueNode y, BeginNode next, BeginNode overflowSuccessor) { super(stamp, x, y, next, overflowSuccessor); }
--- a/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/nodes/arithmetic/IntegerSubExactNode.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/nodes/arithmetic/IntegerSubExactNode.java Mon Apr 14 15:21:27 2014 +0200 @@ -77,7 +77,7 @@ } @Override - public IntegerExactArithmeticSplitNode createSplit(AbstractBeginNode next, AbstractBeginNode deopt) { + public IntegerExactArithmeticSplitNode createSplit(BeginNode next, BeginNode deopt) { return graph().add(new IntegerSubExactSplitNode(stamp(), x(), y(), next, deopt)); }
--- a/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/nodes/arithmetic/IntegerSubExactSplitNode.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/nodes/arithmetic/IntegerSubExactSplitNode.java Mon Apr 14 15:21:27 2014 +0200 @@ -29,7 +29,7 @@ public class IntegerSubExactSplitNode extends IntegerExactArithmeticSplitNode { - public IntegerSubExactSplitNode(Stamp stamp, ValueNode x, ValueNode y, AbstractBeginNode next, AbstractBeginNode overflowSuccessor) { + public IntegerSubExactSplitNode(Stamp stamp, ValueNode x, ValueNode y, BeginNode next, BeginNode overflowSuccessor) { super(stamp, x, y, next, overflowSuccessor); }
--- a/graal/com.oracle.graal.word/src/com/oracle/graal/word/phases/WordTypeRewriterPhase.java Mon Apr 14 15:16:59 2014 +0200 +++ b/graal/com.oracle.graal.word/src/com/oracle/graal/word/phases/WordTypeRewriterPhase.java Mon Apr 14 15:21:27 2014 +0200 @@ -379,7 +379,7 @@ * The read must not float outside its block otherwise it may float above an explicit zero * check on its base address. */ - read.setGuard(AbstractBeginNode.prevBegin(invoke.asNode())); + read.setGuard(BeginNode.prevBegin(invoke.asNode())); return read; }