Mercurial > hg > truffle
changeset 18993:480bd3b1adcd
Rename BeginNode => AbstractBeginNode.
line wrap: on
line diff
--- a/graal/com.oracle.graal.compiler.test/src/com/oracle/graal/compiler/test/SimpleCFGTest.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.compiler.test/src/com/oracle/graal/compiler/test/SimpleCFGTest.java Wed Jan 28 00:50:31 2015 +0100 @@ -45,9 +45,9 @@ AbstractEndNode trueEnd = graph.add(new EndNode()); AbstractEndNode falseEnd = graph.add(new EndNode()); - BeginNode trueBegin = graph.add(new BeginNode()); + AbstractBeginNode trueBegin = graph.add(new AbstractBeginNode()); trueBegin.setNext(trueEnd); - BeginNode falseBegin = graph.add(new BeginNode()); + AbstractBeginNode falseBegin = graph.add(new AbstractBeginNode()); 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 Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.compiler/src/com/oracle/graal/compiler/gen/NodeLIRBuilder.java Wed Jan 28 00:50:31 2015 +0100 @@ -592,7 +592,7 @@ } @Override - public void emitOverflowCheckBranch(BeginNode overflowSuccessor, BeginNode next, Stamp stamp, double probability) { + public void emitOverflowCheckBranch(AbstractBeginNode overflowSuccessor, AbstractBeginNode next, Stamp stamp, double probability) { LIRKind cmpKind = getLIRGeneratorTool().getLIRKind(stamp); gen.emitOverflowCheckBranch(getLIRBlock(overflowSuccessor), getLIRBlock(next), cmpKind, probability); }
--- a/graal/com.oracle.graal.hotspot.test/src/com/oracle/graal/hotspot/test/WriteBarrierVerificationTest.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.hotspot.test/src/com/oracle/graal/hotspot/test/WriteBarrierVerificationTest.java Wed Jan 28 00:50:31 2015 +0100 @@ -698,7 +698,7 @@ } @Override - protected Boolean afterSplit(BeginNode node, Boolean oldState) { + protected Boolean afterSplit(AbstractBeginNode node, Boolean oldState) { return false; } };
--- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/meta/DefaultHotSpotLoweringProvider.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/meta/DefaultHotSpotLoweringProvider.java Wed Jan 28 00:50:31 2015 +0100 @@ -301,7 +301,7 @@ * Anchor the read of the element klass to the cfg, because it is only valid when arrayClass * is an object class, which might not be the case in other parts of the compiled method. */ - return graph.unique(new FloatingReadNode(arrayHub, location, null, KlassPointerStamp.klassNonNull(), BeginNode.prevBegin(anchor))); + return graph.unique(new FloatingReadNode(arrayHub, location, null, KlassPointerStamp.klassNonNull(), AbstractBeginNode.prevBegin(anchor))); } @Override
--- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/SnippetAnchorNode.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/nodes/SnippetAnchorNode.java Wed Jan 28 00:50:31 2015 +0100 @@ -37,7 +37,7 @@ @Override public void simplify(SimplifierTool tool) { - BeginNode prevBegin = BeginNode.prevBegin(this); + AbstractBeginNode prevBegin = AbstractBeginNode.prevBegin(this); replaceAtUsages(InputType.Anchor, prevBegin); replaceAtUsages(InputType.Guard, prevBegin); if (hasNoUsages()) {
--- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/word/HotSpotWordTypeRewriterPhase.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/word/HotSpotWordTypeRewriterPhase.java Wed Jan 28 00:50:31 2015 +0100 @@ -156,7 +156,7 @@ * The read must not float outside its block otherwise it may float above an explicit zero * check on its base address. */ - read.setGuard(BeginNode.prevBegin(invoke.asNode())); + read.setGuard(AbstractBeginNode.prevBegin(invoke.asNode())); return read; }
--- a/graal/com.oracle.graal.java/src/com/oracle/graal/java/ComputeLoopFrequenciesClosure.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.java/src/com/oracle/graal/java/ComputeLoopFrequenciesClosure.java Wed Jan 28 00:50:31 2015 +0100 @@ -51,7 +51,7 @@ } @Override - protected Double afterSplit(BeginNode node, Double oldState) { + protected Double afterSplit(AbstractBeginNode node, Double oldState) { // a control split splits up the probability ControlSplitNode split = (ControlSplitNode) node.predecessor(); return oldState * split.probability(node);
--- a/graal/com.oracle.graal.java/src/com/oracle/graal/java/GraphBuilderPhase.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.java/src/com/oracle/graal/java/GraphBuilderPhase.java Wed Jan 28 00:50:31 2015 +0100 @@ -299,7 +299,7 @@ @Override protected void handleUnresolvedInstanceOf(JavaType type, ValueNode object) { assert !graphBuilderConfig.eagerResolving(); - BeginNode successor = currentGraph.add(new BeginNode()); + AbstractBeginNode successor = currentGraph.add(new AbstractBeginNode()); DeoptimizeNode deopt = currentGraph.add(new DeoptimizeNode(InvalidateRecompile, Unresolved)); append(new IfNode(currentGraph.unique(new IsNullNode(object)), successor, deopt, 1)); lastInstr = successor; @@ -609,7 +609,7 @@ return; } BytecodeExceptionNode exception = currentGraph.add(new BytecodeExceptionNode(metaAccess, NullPointerException.class)); - BeginNode falseSucc = currentGraph.add(new BeginNode()); + AbstractBeginNode falseSucc = currentGraph.add(new AbstractBeginNode()); append(new IfNode(currentGraph.unique(new IsNullNode(receiver)), exception, falseSucc, 0.01)); lastInstr = falseSucc; @@ -619,7 +619,7 @@ @Override protected void emitBoundsCheck(ValueNode index, ValueNode length) { - BeginNode trueSucc = currentGraph.add(new BeginNode()); + AbstractBeginNode trueSucc = currentGraph.add(new AbstractBeginNode()); BytecodeExceptionNode exception = currentGraph.add(new BytecodeExceptionNode(metaAccess, ArrayIndexOutOfBoundsException.class, index)); append(new IfNode(currentGraph.unique(new IntegerBelowNode(index, length)), trueSucc, exception, 0.99)); lastInstr = trueSucc; @@ -795,7 +795,7 @@ createInvoke(callTarget, resultType); } else { InvokeWithExceptionNode invoke = createInvokeWithException(callTarget, resultType); - BeginNode beginNode = currentGraph.add(new KillingBeginNode(LocationIdentity.ANY_LOCATION)); + AbstractBeginNode beginNode = currentGraph.add(new KillingBeginNode(LocationIdentity.ANY_LOCATION)); invoke.setNext(beginNode); lastInstr = beginNode; } @@ -1044,7 +1044,7 @@ * this block again. */ FixedNode targetNode; - block.firstInstruction = currentGraph.add(new BeginNode()); + block.firstInstruction = currentGraph.add(new AbstractBeginNode()); targetNode = block.firstInstruction; Target target = checkLoopExit(targetNode, block, state); FixedNode result = target.fixed; @@ -1077,13 +1077,13 @@ assert currentBlock == null || currentBlock.getId() < block.getId() : "must not be backward branch"; assert block.firstInstruction.next() == null : "bytecodes already parsed for block"; - if (block.firstInstruction instanceof BeginNode && !(block.firstInstruction instanceof MergeNode)) { + if (block.firstInstruction instanceof AbstractBeginNode && !(block.firstInstruction instanceof MergeNode)) { /* * This is the second time we see this block. Create the actual MergeNode and * the End Node for the already existing edge. For simplicity, we leave the * placeholder in the graph and just append the new nodes after the placeholder. */ - BeginNode placeholder = (BeginNode) block.firstInstruction; + AbstractBeginNode placeholder = (AbstractBeginNode) block.firstInstruction; // The EndNode for the already existing edge. AbstractEndNode end = currentGraph.add(new EndNode()); @@ -1121,9 +1121,9 @@ * Returns a block begin node with the specified state. If the specified probability is * 0, the block deoptimizes immediately. */ - private BeginNode createBlockTarget(double probability, BciBlock block, HIRFrameStateBuilder stateAfter) { + private AbstractBeginNode createBlockTarget(double probability, BciBlock block, HIRFrameStateBuilder stateAfter) { FixedNode target = createTarget(probability, block, stateAfter); - BeginNode begin = BeginNode.begin(target); + AbstractBeginNode begin = AbstractBeginNode.begin(target); 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."; @@ -1355,7 +1355,7 @@ frameState.clearNonLiveLocals(currentBlock, liveness, false); } if (lastInstr instanceof StateSplit) { - if (lastInstr.getClass() == BeginNode.class) { + if (lastInstr.getClass() == AbstractBeginNode.class) { // BeginNodes do not need a frame state } else { StateSplit stateSplit = (StateSplit) lastInstr;
--- a/graal/com.oracle.graal.java/src/com/oracle/graal/java/HIRFrameStateBuilder.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.java/src/com/oracle/graal/java/HIRFrameStateBuilder.java Wed Jan 28 00:50:31 2015 +0100 @@ -294,7 +294,7 @@ } } - public void insertProxies(BeginNode begin) { + public void insertProxies(AbstractBeginNode begin) { for (int i = 0; i < localsSize(); i++) { ValueNode value = localAt(i); if (value != null) {
--- a/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/CountedLoopInfo.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/CountedLoopInfo.java Wed Jan 28 00:50:31 2015 +0100 @@ -38,9 +38,9 @@ private InductionVariable iv; private ValueNode end; private boolean oneOff; - private BeginNode body; + private AbstractBeginNode body; - CountedLoopInfo(LoopEx loop, InductionVariable iv, ValueNode end, boolean oneOff, BeginNode body) { + CountedLoopInfo(LoopEx loop, InductionVariable iv, ValueNode end, boolean oneOff, AbstractBeginNode body) { this.loop = loop; this.iv = iv; this.end = end; @@ -118,7 +118,7 @@ return oneOff; } - public BeginNode getBody() { + public AbstractBeginNode getBody() { return body; } @@ -157,7 +157,7 @@ } cond = graph.unique(new IntegerLessThanNode(end, v1)); } - overflowGuard = graph.unique(new GuardNode(cond, BeginNode.prevBegin(loop.entryPoint()), DeoptimizationReason.LoopLimitCheck, DeoptimizationAction.InvalidateRecompile, true, + overflowGuard = graph.unique(new GuardNode(cond, AbstractBeginNode.prevBegin(loop.entryPoint()), DeoptimizationReason.LoopLimitCheck, DeoptimizationAction.InvalidateRecompile, true, JavaConstant.NULL_POINTER)); // TODO gd: use speculation loop.loopBegin().setOverflowGuard(overflowGuard); return overflowGuard;
--- a/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/LoopEx.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/LoopEx.java Wed Jan 28 00:50:31 2015 +0100 @@ -230,8 +230,8 @@ return data; } - public NodeBitMap nodesInLoopFrom(BeginNode point, BeginNode until) { - Collection<BeginNode> blocks = new LinkedList<>(); + public NodeBitMap nodesInLoopFrom(AbstractBeginNode point, AbstractBeginNode until) { + Collection<AbstractBeginNode> blocks = new LinkedList<>(); Collection<LoopExitNode> exits = new LinkedList<>(); Queue<Block> work = new LinkedList<>(); ControlFlowGraph cfg = loopsData().controlFlowGraph();
--- a/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/LoopFragment.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/LoopFragment.java Wed Jan 28 00:50:31 2015 +0100 @@ -150,13 +150,13 @@ } } - protected static NodeBitMap computeNodes(Graph graph, Iterable<BeginNode> blocks) { + protected static NodeBitMap computeNodes(Graph graph, Iterable<AbstractBeginNode> blocks) { return computeNodes(graph, blocks, Collections.emptyList()); } - protected static NodeBitMap computeNodes(Graph graph, Iterable<BeginNode> blocks, Iterable<LoopExitNode> earlyExits) { + protected static NodeBitMap computeNodes(Graph graph, Iterable<AbstractBeginNode> blocks, Iterable<LoopExitNode> earlyExits) { final NodeBitMap nodes = graph.createNodeBitMap(); - for (BeginNode b : blocks) { + for (AbstractBeginNode b : blocks) { if (b.isDeleted()) { continue; } @@ -188,7 +188,7 @@ } final NodeBitMap notloopNodes = graph.createNodeBitMap(); - for (BeginNode b : blocks) { + for (AbstractBeginNode b : blocks) { if (b.isDeleted()) { continue; } @@ -245,19 +245,19 @@ return false; } - public static NodeIterable<BeginNode> toHirBlocks(final Iterable<Block> blocks) { - return new NodeIterable<BeginNode>() { + public static NodeIterable<AbstractBeginNode> toHirBlocks(final Iterable<Block> blocks) { + return new NodeIterable<AbstractBeginNode>() { - public Iterator<BeginNode> iterator() { + public Iterator<AbstractBeginNode> iterator() { final Iterator<Block> it = blocks.iterator(); - return new Iterator<BeginNode>() { + return new Iterator<AbstractBeginNode>() { @Override public void remove() { throw new UnsupportedOperationException(); } - public BeginNode next() { + public AbstractBeginNode next() { return it.next().getBeginNode(); } @@ -302,13 +302,13 @@ protected void mergeEarlyExits() { assert isDuplicate(); StructuredGraph graph = graph(); - for (BeginNode earlyExit : LoopFragment.toHirBlocks(original().loop().loop().getExits())) { + for (AbstractBeginNode earlyExit : LoopFragment.toHirBlocks(original().loop().loop().getExits())) { LoopExitNode loopEarlyExit = (LoopExitNode) earlyExit; FixedNode next = loopEarlyExit.next(); if (loopEarlyExit.isDeleted() || !this.original().contains(loopEarlyExit)) { continue; } - BeginNode newEarlyExit = getDuplicatedNode(loopEarlyExit); + AbstractBeginNode newEarlyExit = getDuplicatedNode(loopEarlyExit); if (newEarlyExit == null) { continue; }
--- a/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/LoopFragmentInside.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/LoopFragmentInside.java Wed Jan 28 00:50:31 2015 +0100 @@ -89,13 +89,13 @@ patchNodes(dataFixBefore); - BeginNode end = mergeEnds(); + AbstractBeginNode end = mergeEnds(); mergeEarlyExits(); original().patchPeeling(this); - BeginNode entry = getDuplicatedNode(loop.loopBegin()); + AbstractBeginNode entry = getDuplicatedNode(loop.loopBegin()); loop.entryPoint().replaceAtPredecessor(entry); end.setNext(loop.entryPoint()); } @@ -152,7 +152,7 @@ if (value != null) { return value; } - BeginNode newValue = graph.add(new BeginNode()); + AbstractBeginNode newValue = graph.add(new AbstractBeginNode()); seenNode.put(original, newValue); return newValue; } @@ -161,7 +161,7 @@ if (value != null) { return value; } - BeginNode newValue = graph.add(new BeginNode()); + AbstractBeginNode newValue = graph.add(new AbstractBeginNode()); seenNode.put(original, newValue); return newValue; } @@ -291,7 +291,7 @@ } } - private BeginNode mergeEnds() { + private AbstractBeginNode mergeEnds() { assert isDuplicate(); List<AbstractEndNode> endsToMerge = new LinkedList<>(); // map peel exits to the corresponding loop exits @@ -305,12 +305,12 @@ } } mergedInitializers = Node.newIdentityMap(); - BeginNode newExit; + AbstractBeginNode newExit; StructuredGraph graph = graph(); if (endsToMerge.size() == 1) { AbstractEndNode end = endsToMerge.get(0); assert end.hasNoUsages(); - newExit = graph.add(new BeginNode()); + newExit = graph.add(new AbstractBeginNode()); end.replaceAtPredecessor(newExit); end.safeDelete(); } else {
--- a/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/LoopPolicies.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/LoopPolicies.java Wed Jan 28 00:50:31 2015 +0100 @@ -70,9 +70,9 @@ double maxProbability = 0; for (ControlSplitNode controlSplit : controlSplits) { Block postDomBlock = loop.loopsData().controlFlowGraph().blockFor(controlSplit).getPostdominator(); - BeginNode postDom = postDomBlock != null ? postDomBlock.getBeginNode() : null; + AbstractBeginNode postDom = postDomBlock != null ? postDomBlock.getBeginNode() : null; for (Node successor : controlSplit.successors()) { - BeginNode branch = (BeginNode) successor; + AbstractBeginNode branch = (AbstractBeginNode) successor; // this may count twice because of fall-through in switches inBranchTotal += loop.nodesInLoopFrom(branch, postDom).count(); double probability = controlSplit.probability(branch);
--- a/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/LoopTransformations.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/LoopTransformations.java Wed Jan 28 00:50:31 2015 +0100 @@ -89,21 +89,21 @@ assert successors.hasNext(); // original loop is used as first successor Position firstPosition = successors.nextPosition(); - BeginNode originalLoopBegin = BeginNode.begin(originalLoop.entryPoint()); + AbstractBeginNode originalLoopBegin = AbstractBeginNode.begin(originalLoop.entryPoint()); firstPosition.set(newControlSplit, originalLoopBegin); while (successors.hasNext()) { Position position = successors.nextPosition(); // create a new loop duplicate and connect it. LoopFragmentWhole duplicateLoop = originalLoop.duplicate(); - BeginNode newBegin = BeginNode.begin(duplicateLoop.entryPoint()); + AbstractBeginNode newBegin = AbstractBeginNode.begin(duplicateLoop.entryPoint()); position.set(newControlSplit, newBegin); // For each cloned ControlSplitNode, simplify the proper path for (ControlSplitNode controlSplitNode : controlSplitNodeSet) { ControlSplitNode duplicatedControlSplit = duplicateLoop.getDuplicatedNode(controlSplitNode); if (duplicatedControlSplit.isAlive()) { - BeginNode survivingSuccessor = (BeginNode) position.get(duplicatedControlSplit); + AbstractBeginNode survivingSuccessor = (AbstractBeginNode) position.get(duplicatedControlSplit); survivingSuccessor.replaceAtUsages(InputType.Guard, newBegin); graph.removeSplitPropagate(duplicatedControlSplit, survivingSuccessor); } @@ -112,7 +112,7 @@ // original loop is simplified last to avoid deleting controlSplitNode too early for (ControlSplitNode controlSplitNode : controlSplitNodeSet) { if (controlSplitNode.isAlive()) { - BeginNode survivingSuccessor = (BeginNode) firstPosition.get(controlSplitNode); + AbstractBeginNode survivingSuccessor = (AbstractBeginNode) firstPosition.get(controlSplitNode); survivingSuccessor.replaceAtUsages(InputType.Guard, originalLoopBegin); graph.removeSplitPropagate(controlSplitNode, survivingSuccessor); }
--- a/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/phases/LoopTransformLowPhase.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.loop/src/com/oracle/graal/loop/phases/LoopTransformLowPhase.java Wed Jan 28 00:50:31 2015 +0100 @@ -86,7 +86,7 @@ sb.append(controlSplit).append(" ["); NodePosIterator it = controlSplit.successors().iterator(); while (it.hasNext()) { - sb.append(controlSplit.probability((BeginNode) it.next())); + sb.append(controlSplit.probability((AbstractBeginNode) it.next())); if (it.hasNext()) { sb.append(", "); }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/AbstractBeginNode.java Wed Jan 28 00:50:31 2015 +0100 @@ -0,0 +1,172 @@ +/* + * 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.compiler.common.type.*; +import com.oracle.graal.graph.*; +import com.oracle.graal.graph.iterators.*; +import com.oracle.graal.graph.spi.*; +import com.oracle.graal.nodeinfo.*; +import com.oracle.graal.nodes.extended.*; +import com.oracle.graal.nodes.spi.*; +import com.oracle.graal.nodes.util.*; + +@NodeInfo(allowedUsageTypes = {InputType.Guard, InputType.Anchor}) +public class AbstractBeginNode extends FixedWithNextNode implements LIRLowerable, Simplifiable, GuardingNode, AnchoringNode, IterableNodeType { + + public AbstractBeginNode() { + super(StampFactory.forVoid()); + } + + public AbstractBeginNode(Stamp stamp) { + super(stamp); + } + + public static AbstractBeginNode begin(FixedNode with) { + if (with instanceof AbstractBeginNode) { + return (AbstractBeginNode) with; + } + AbstractBeginNode begin = with.graph().add(new AbstractBeginNode()); + 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) { + for (AbstractBeginNode begin : GraphUtil.predecessorIterable(from).filter(AbstractBeginNode.class)) { + return begin; + } + return null; + } + + private void evacuateGuards(FixedNode evacuateFrom) { + if (!hasNoUsages()) { + 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 NodeIterable<FixedNode>() { + + @Override + public Iterator<FixedNode> iterator() { + return new BlockNodeIterator(AbstractBeginNode.this); + } + }; + } + + private class BlockNodeIterator implements Iterator<FixedNode> { + + private FixedNode current; + + public BlockNodeIterator(FixedNode next) { + this.current = next; + } + + @Override + public boolean hasNext() { + return current != null; + } + + @Override + public FixedNode next() { + FixedNode ret = current; + if (ret == null) { + throw new NoSuchElementException(); + } + if (!(current instanceof FixedWithNextNode) || (current instanceof AbstractBeginNode && current != AbstractBeginNode.this)) { + current = null; + } else { + current = ((FixedWithNextNode) current).next(); + } + return ret; + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + } +}
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/AbstractFixedGuardNode.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/AbstractFixedGuardNode.java Wed Jan 28 00:50:31 2015 +0100 @@ -90,7 +90,7 @@ DeoptimizeNode deopt = graph().add(new DeoptimizeNode(action, reason)); deopt.setStateBefore(stateBefore()); IfNode ifNode; - BeginNode noDeoptSuccessor; + AbstractBeginNode noDeoptSuccessor; if (negated) { ifNode = graph().add(new IfNode(condition, deopt, currentNext, 0)); noDeoptSuccessor = ifNode.falseSuccessor();
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/BeginNode.java Tue Jan 27 23:52:31 2015 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,172 +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.compiler.common.type.*; -import com.oracle.graal.graph.*; -import com.oracle.graal.graph.iterators.*; -import com.oracle.graal.graph.spi.*; -import com.oracle.graal.nodeinfo.*; -import com.oracle.graal.nodes.extended.*; -import com.oracle.graal.nodes.spi.*; -import com.oracle.graal.nodes.util.*; - -@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) { - for (BeginNode begin : GraphUtil.predecessorIterable(from).filter(BeginNode.class)) { - return begin; - } - return null; - } - - private void evacuateGuards(FixedNode evacuateFrom) { - if (!hasNoUsages()) { - 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 NodeIterable<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 Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/BeginStateSplitNode.java Wed Jan 28 00:50:31 2015 +0100 @@ -26,14 +26,14 @@ import com.oracle.graal.nodeinfo.*; /** - * Base class for {@link BeginNode}s that are associated with a frame state. + * Base class for {@link AbstractBeginNode}s that are associated with a frame state. * - * TODO (dnsimon) this not needed until {@link BeginNode} no longer implements {@link StateSplit} + * TODO (dnsimon) this not needed until {@link AbstractBeginNode} no longer implements {@link StateSplit} * which is not possible until loop peeling works without requiring begin nodes to have frames * states. */ @NodeInfo -public abstract class BeginStateSplitNode extends BeginNode implements StateSplit { +public abstract class BeginStateSplitNode extends AbstractBeginNode implements StateSplit { @OptionalInput(InputType.State) protected FrameState stateAfter;
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/ControlSplitNode.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/ControlSplitNode.java Wed Jan 28 00:50:31 2015 +0100 @@ -37,5 +37,5 @@ super(stamp); } - public abstract double probability(BeginNode successor); + public abstract double probability(AbstractBeginNode successor); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/GuardProxyNode.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/GuardProxyNode.java Wed Jan 28 00:50:31 2015 +0100 @@ -33,7 +33,7 @@ @Input(InputType.Guard) GuardingNode value; - public GuardProxyNode(GuardingNode value, BeginNode proxyPoint) { + public GuardProxyNode(GuardingNode value, AbstractBeginNode proxyPoint) { super(StampFactory.forVoid(), proxyPoint); this.value = value; }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/IfNode.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/IfNode.java Wed Jan 28 00:50:31 2015 +0100 @@ -51,8 +51,8 @@ private static final DebugMetric CORRECTED_PROBABILITIES = Debug.metric("CorrectedProbabilities"); - @Successor BeginNode trueSuccessor; - @Successor BeginNode falseSuccessor; + @Successor AbstractBeginNode trueSuccessor; + @Successor AbstractBeginNode falseSuccessor; @Input(InputType.Condition) LogicNode condition; protected double trueSuccessorProbability; @@ -66,10 +66,10 @@ } public IfNode(LogicNode condition, FixedNode trueSuccessor, FixedNode falseSuccessor, double trueSuccessorProbability) { - this(condition, BeginNode.begin(trueSuccessor), BeginNode.begin(falseSuccessor), trueSuccessorProbability); + this(condition, AbstractBeginNode.begin(trueSuccessor), AbstractBeginNode.begin(falseSuccessor), trueSuccessorProbability); } - public IfNode(LogicNode condition, BeginNode trueSuccessor, BeginNode falseSuccessor, double trueSuccessorProbability) { + public IfNode(LogicNode condition, AbstractBeginNode trueSuccessor, AbstractBeginNode falseSuccessor, double trueSuccessorProbability) { super(StampFactory.forVoid()); this.condition = condition; this.falseSuccessor = falseSuccessor; @@ -82,7 +82,7 @@ * * @return the true successor */ - public BeginNode trueSuccessor() { + public AbstractBeginNode trueSuccessor() { return trueSuccessor; } @@ -91,16 +91,16 @@ * * @return the false successor */ - public BeginNode falseSuccessor() { + public AbstractBeginNode falseSuccessor() { return falseSuccessor; } - public void setTrueSuccessor(BeginNode node) { + public void setTrueSuccessor(AbstractBeginNode node) { updatePredecessor(trueSuccessor, node); trueSuccessor = node; } - public void setFalseSuccessor(BeginNode node) { + public void setFalseSuccessor(AbstractBeginNode node) { updatePredecessor(falseSuccessor, node); falseSuccessor = node; } @@ -111,7 +111,7 @@ * @param istrue {@code true} if the true successor is requested, {@code false} otherwise * @return the corresponding successor */ - public BeginNode successor(boolean istrue) { + public AbstractBeginNode successor(boolean istrue) { return istrue ? trueSuccessor : falseSuccessor; } @@ -121,7 +121,7 @@ } @Override - public double probability(BeginNode successor) { + public double probability(AbstractBeginNode successor) { return successor == trueSuccessor ? trueSuccessorProbability : 1 - trueSuccessorProbability; } @@ -153,8 +153,8 @@ } if (condition() instanceof LogicNegationNode) { - BeginNode trueSucc = trueSuccessor(); - BeginNode falseSucc = falseSuccessor(); + AbstractBeginNode trueSucc = trueSuccessor(); + AbstractBeginNode falseSucc = falseSuccessor(); setTrueSuccessor(null); setFalseSuccessor(null); LogicNegationNode negation = (LogicNegationNode) condition(); @@ -190,7 +190,7 @@ } if (falseSuccessor().hasNoUsages() && (!(falseSuccessor() instanceof LoopExitNode)) && falseSuccessor().next() instanceof IfNode) { - BeginNode intermediateBegin = falseSuccessor(); + AbstractBeginNode intermediateBegin = falseSuccessor(); IfNode nextIf = (IfNode) intermediateBegin.next(); double probabilityB = (1.0 - this.trueSuccessorProbability) * nextIf.trueSuccessorProbability; if (this.trueSuccessorProbability < probabilityB) { @@ -199,7 +199,7 @@ if (prepareForSwap(tool.getConstantReflection(), condition(), nextIf.condition(), this.trueSuccessorProbability, probabilityB)) { // Reordering is allowed from (if1 => begin => if2) to (if2 => begin => if1). assert intermediateBegin.next() == nextIf; - BeginNode bothFalseBegin = nextIf.falseSuccessor(); + AbstractBeginNode bothFalseBegin = nextIf.falseSuccessor(); nextIf.setFalseSuccessor(null); intermediateBegin.setNext(null); this.setFalseSuccessor(null); @@ -225,9 +225,9 @@ assert trueSuccessor().hasNoUsages() && falseSuccessor().hasNoUsages(); // push similar nodes upwards through the if, thereby deduplicating them do { - BeginNode trueSucc = trueSuccessor(); - BeginNode falseSucc = falseSuccessor(); - if (trueSucc.getClass() == BeginNode.class && falseSucc.getClass() == BeginNode.class && trueSucc.next() instanceof FixedWithNextNode && falseSucc.next() instanceof FixedWithNextNode) { + AbstractBeginNode trueSucc = trueSuccessor(); + AbstractBeginNode falseSucc = falseSuccessor(); + if (trueSucc.getClass() == AbstractBeginNode.class && falseSucc.getClass() == AbstractBeginNode.class && trueSucc.next() instanceof FixedWithNextNode && falseSucc.next() instanceof FixedWithNextNode) { FixedWithNextNode trueNext = (FixedWithNextNode) trueSucc.next(); FixedWithNextNode falseNext = (FixedWithNextNode) falseSucc.next(); NodeClass nodeClass = trueNext.getNodeClass(); @@ -275,8 +275,8 @@ IfNode ifNode2 = (IfNode) falseSuccessor().next(); if (ifNode2.condition() instanceof IntegerLessThanNode) { IntegerLessThanNode lessThan2 = (IntegerLessThanNode) ifNode2.condition(); - BeginNode falseSucc = ifNode2.falseSuccessor(); - BeginNode trueSucc = ifNode2.trueSuccessor(); + AbstractBeginNode falseSucc = ifNode2.falseSuccessor(); + AbstractBeginNode trueSucc = ifNode2.trueSuccessor(); IntegerBelowNode below = null; /* * Convert x >= 0 && x < positive which is represented as !(x < 0) && x < @@ -286,7 +286,7 @@ sameDestination(trueSuccessor(), ifNode2.falseSuccessor)) { below = graph().unique(new IntegerBelowNode(lessThan2.getX(), lessThan2.getY())); // swap direction - BeginNode tmp = falseSucc; + AbstractBeginNode tmp = falseSucc; falseSucc = trueSucc; trueSucc = tmp; } else if (lessThan2.getY() == lessThan.getX() && sameDestination(trueSuccessor(), ifNode2.trueSuccessor)) { @@ -326,7 +326,7 @@ * Check it these two blocks end up at the same place. Meeting at the same merge, or * deoptimizing in the same way. */ - private static boolean sameDestination(BeginNode succ1, BeginNode succ2) { + private static boolean sameDestination(AbstractBeginNode succ1, AbstractBeginNode succ2) { Node next1 = succ1.next(); Node next2 = succ2.next(); if (next1 instanceof EndNode && next2 instanceof EndNode) { @@ -552,7 +552,7 @@ } protected void removeThroughFalseBranch(SimplifierTool tool) { - BeginNode trueBegin = trueSuccessor(); + AbstractBeginNode trueBegin = trueSuccessor(); graph().removeSplitPropagate(this, trueBegin, tool); tool.addToWorkList(trueBegin); } @@ -702,8 +702,8 @@ List<AbstractEndNode> trueEnds = new ArrayList<>(mergePredecessors.size()); Map<AbstractEndNode, ValueNode> phiValues = CollectionsFactory.newMap(mergePredecessors.size()); - BeginNode oldFalseSuccessor = falseSuccessor(); - BeginNode oldTrueSuccessor = trueSuccessor(); + AbstractBeginNode oldFalseSuccessor = falseSuccessor(); + AbstractBeginNode oldTrueSuccessor = trueSuccessor(); setFalseSuccessor(null); setTrueSuccessor(null); @@ -840,7 +840,7 @@ * @param oldMerge the merge being removed * @param phiValues the values of the phi at the merge, keyed by the merge ends */ - private void connectEnds(List<AbstractEndNode> ends, Map<AbstractEndNode, ValueNode> phiValues, BeginNode successor, MergeNode oldMerge, SimplifierTool tool) { + private void connectEnds(List<AbstractEndNode> ends, Map<AbstractEndNode, ValueNode> phiValues, AbstractBeginNode successor, MergeNode oldMerge, SimplifierTool tool) { if (!ends.isEmpty()) { if (ends.size() == 1) { AbstractEndNode end = ends.get(0);
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/InvokeWithExceptionNode.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/InvokeWithExceptionNode.java Wed Jan 28 00:50:31 2015 +0100 @@ -37,8 +37,8 @@ private static final double EXCEPTION_PROBA = 1e-5; - @Successor BeginNode next; - @Successor BeginNode exceptionEdge; + @Successor AbstractBeginNode next; + @Successor AbstractBeginNode exceptionEdge; @Input(InputType.Extension) CallTargetNode callTarget; @OptionalInput(InputType.State) FrameState stateDuring; @OptionalInput(InputType.State) FrameState stateAfter; @@ -48,7 +48,7 @@ protected boolean useForInlining; protected double exceptionProbability; - public InvokeWithExceptionNode(CallTargetNode callTarget, BeginNode exceptionEdge, int bci) { + public InvokeWithExceptionNode(CallTargetNode callTarget, AbstractBeginNode exceptionEdge, int bci) { super(callTarget.returnStamp()); this.exceptionEdge = exceptionEdge; this.bci = bci; @@ -58,20 +58,20 @@ this.exceptionProbability = EXCEPTION_PROBA; } - public BeginNode exceptionEdge() { + public AbstractBeginNode exceptionEdge() { return exceptionEdge; } - public void setExceptionEdge(BeginNode x) { + public void setExceptionEdge(AbstractBeginNode x) { updatePredecessor(exceptionEdge, x); exceptionEdge = x; } - public BeginNode next() { + public AbstractBeginNode next() { return next; } - public void setNext(BeginNode x) { + public void setNext(AbstractBeginNode x) { updatePredecessor(next, x); next = x; } @@ -164,7 +164,7 @@ } public void killExceptionEdge() { - BeginNode edge = exceptionEdge(); + AbstractBeginNode edge = exceptionEdge(); setExceptionEdge(null); GraphUtil.killCFG(edge); } @@ -201,7 +201,7 @@ } @Override - public double probability(BeginNode successor) { + public double probability(AbstractBeginNode successor) { return successor == next ? 1 - exceptionProbability : exceptionProbability; }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/KillingBeginNode.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/KillingBeginNode.java Wed Jan 28 00:50:31 2015 +0100 @@ -27,7 +27,7 @@ import com.oracle.graal.nodes.extended.*; @NodeInfo(allowedUsageTypes = {InputType.Memory}) -public class KillingBeginNode extends BeginNode implements MemoryCheckpoint.Single { +public class KillingBeginNode extends AbstractBeginNode implements MemoryCheckpoint.Single { protected LocationIdentity locationIdentity;
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/LoopBeginNode.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/LoopBeginNode.java Wed Jan 28 00:50:31 2015 +0100 @@ -183,7 +183,7 @@ canonicalizePhis(tool); } - public boolean isLoopExit(BeginNode begin) { + public boolean isLoopExit(AbstractBeginNode begin) { return begin instanceof LoopExitNode && ((LoopExitNode) begin).loopBegin() == this; } @@ -191,7 +191,7 @@ for (LoopExitNode loopexit : loopExits().snapshot()) { loopexit.removeProxies(); FrameState loopStateAfter = loopexit.stateAfter(); - graph().replaceFixedWithFixed(loopexit, graph().add(new BeginNode())); + graph().replaceFixedWithFixed(loopexit, graph().add(new AbstractBeginNode())); if (loopStateAfter != null && loopStateAfter.isAlive() && loopStateAfter.hasNoUsages()) { GraphUtil.killWithUnusedFloatingInputs(loopStateAfter); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/LoopExitNode.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/LoopExitNode.java Wed Jan 28 00:50:31 2015 +0100 @@ -43,8 +43,8 @@ @Override public void simplify(SimplifierTool tool) { Node prev = this.predecessor(); - while (prev.getClass() == BeginNode.class && prev.hasNoUsages()) { - BeginNode begin = (BeginNode) prev; + while (prev.getClass() == AbstractBeginNode.class && prev.hasNoUsages()) { + AbstractBeginNode begin = (AbstractBeginNode) prev; prev = prev.predecessor(); graph().removeFixed(begin); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/ProxyNode.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/ProxyNode.java Wed Jan 28 00:50:31 2015 +0100 @@ -36,9 +36,9 @@ @NodeInfo public abstract class ProxyNode extends FloatingNode implements IterableNodeType, ValueNumberable { - @Input(InputType.Association) BeginNode proxyPoint; + @Input(InputType.Association) AbstractBeginNode proxyPoint; - public ProxyNode(Stamp stamp, BeginNode proxyPoint) { + public ProxyNode(Stamp stamp, AbstractBeginNode proxyPoint) { super(stamp); assert proxyPoint != null; this.proxyPoint = proxyPoint; @@ -46,7 +46,7 @@ public abstract ValueNode value(); - public BeginNode proxyPoint() { + public AbstractBeginNode proxyPoint() { return proxyPoint; } @@ -58,11 +58,11 @@ return super.verify(); } - public static ValueProxyNode forValue(ValueNode value, BeginNode exit, StructuredGraph graph) { + public static ValueProxyNode forValue(ValueNode value, AbstractBeginNode exit, StructuredGraph graph) { return graph.unique(new ValueProxyNode(value, exit)); } - public static GuardProxyNode forGuard(GuardingNode value, BeginNode exit, StructuredGraph graph) { + public static GuardProxyNode forGuard(GuardingNode value, AbstractBeginNode exit, StructuredGraph graph) { return graph.unique(new GuardProxyNode(value, exit)); } }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/StructuredGraph.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/StructuredGraph.java Wed Jan 28 00:50:31 2015 +0100 @@ -94,14 +94,14 @@ private boolean hasValueProxies = true; /** - * Creates a new Graph containing a single {@link BeginNode} as the {@link #start() start} node. + * Creates a new Graph containing a single {@link AbstractBeginNode} as the {@link #start() start} node. */ public StructuredGraph() { this(null, null); } /** - * Creates a new Graph containing a single {@link BeginNode} as the {@link #start() start} node. + * Creates a new Graph containing a single {@link AbstractBeginNode} as the {@link #start() start} node. */ public StructuredGraph(String name, ResolvedJavaMethod method) { this(name, method, uniqueGraphIds.incrementAndGet(), INVOCATION_ENTRY_BCI); @@ -285,8 +285,8 @@ */ public void removeFixed(FixedWithNextNode node) { assert node != null; - if (node instanceof BeginNode) { - ((BeginNode) node).prepareDelete(); + if (node instanceof AbstractBeginNode) { + ((AbstractBeginNode) node).prepareDelete(); } assert node.hasNoUsages() : node + " " + node.usages(); GraphUtil.unlinkFixedNode(node); @@ -321,7 +321,7 @@ node.safeDelete(); } - public void removeSplit(ControlSplitNode node, BeginNode survivingSuccessor) { + public void removeSplit(ControlSplitNode node, AbstractBeginNode survivingSuccessor) { assert node != null; assert node.hasNoUsages(); assert survivingSuccessor != null; @@ -330,11 +330,11 @@ node.safeDelete(); } - public void removeSplitPropagate(ControlSplitNode node, BeginNode survivingSuccessor) { + public void removeSplitPropagate(ControlSplitNode node, AbstractBeginNode survivingSuccessor) { removeSplitPropagate(node, survivingSuccessor, null); } - public void removeSplitPropagate(ControlSplitNode node, BeginNode survivingSuccessor, SimplifierTool tool) { + public void removeSplitPropagate(ControlSplitNode node, AbstractBeginNode survivingSuccessor, SimplifierTool tool) { assert node != null; assert node.hasNoUsages(); assert survivingSuccessor != null; @@ -351,7 +351,7 @@ } } - public void replaceSplit(ControlSplitNode node, Node replacement, BeginNode survivingSuccessor) { + public void replaceSplit(ControlSplitNode node, Node replacement, AbstractBeginNode survivingSuccessor) { if (replacement instanceof FixedWithNextNode) { replaceSplitWithFixed(node, (FixedWithNextNode) replacement, survivingSuccessor); } else { @@ -361,7 +361,7 @@ } } - public void replaceSplitWithFixed(ControlSplitNode node, FixedWithNextNode replacement, BeginNode survivingSuccessor) { + public void replaceSplitWithFixed(ControlSplitNode node, FixedWithNextNode replacement, AbstractBeginNode survivingSuccessor) { assert node != null && replacement != null && node.isAlive() && replacement.isAlive() : "cannot replace " + node + " with " + replacement; assert survivingSuccessor != null; node.clearSuccessors(); @@ -369,7 +369,7 @@ node.replaceAndDelete(replacement); } - public void replaceSplitWithFloating(ControlSplitNode node, FloatingNode replacement, BeginNode survivingSuccessor) { + public void replaceSplitWithFloating(ControlSplitNode node, FloatingNode replacement, AbstractBeginNode survivingSuccessor) { assert node != null && replacement != null && node.isAlive() && replacement.isAlive() : "cannot replace " + node + " with " + replacement; assert survivingSuccessor != null; node.clearSuccessors();
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/ValueProxyNode.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/ValueProxyNode.java Wed Jan 28 00:50:31 2015 +0100 @@ -32,7 +32,7 @@ @Input ValueNode value; - public ValueProxyNode(ValueNode value, BeginNode proxyPoint) { + public ValueProxyNode(ValueNode value, AbstractBeginNode proxyPoint) { super(value.stamp(), proxyPoint); this.value = value; }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/cfg/Block.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/cfg/Block.java Wed Jan 28 00:50:31 2015 +0100 @@ -30,7 +30,7 @@ public final class Block extends AbstractBlockBase<Block> { - protected final BeginNode beginNode; + protected final AbstractBeginNode beginNode; protected FixedNode endNode; @@ -39,11 +39,11 @@ protected Block postdominator; - protected Block(BeginNode node) { + protected Block(AbstractBeginNode node) { this.beginNode = node; } - public BeginNode getBeginNode() { + public AbstractBeginNode getBeginNode() { return beginNode; } @@ -122,7 +122,7 @@ } else { cur = ((FixedWithNextNode) cur).next(); } - assert !(cur instanceof BeginNode); + assert !(cur instanceof AbstractBeginNode); return result; }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/cfg/ControlFlowGraph.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/cfg/ControlFlowGraph.java Wed Jan 28 00:50:31 2015 +0100 @@ -130,7 +130,7 @@ Node last; // assign proxies of a loop exit to this block - if (cur instanceof BeginNode) { + if (cur instanceof AbstractBeginNode) { for (Node usage : cur.usages()) { if (usage instanceof ProxyNode) { nodeToBlock.set(usage, block); @@ -151,7 +151,7 @@ last = cur; cur = cur.successors().first(); - } while (cur != null && !(cur instanceof BeginNode)); + } while (cur != null && !(cur instanceof AbstractBeginNode)); block.endNode = (FixedNode) last; } @@ -159,7 +159,7 @@ private void identifyBlocks() { // Find all block headers int numBlocks = 0; - for (BeginNode begin : graph.getNodes(BeginNode.class)) { + for (AbstractBeginNode begin : graph.getNodes(AbstractBeginNode.class)) { Block block = new Block(begin); numBlocks++; identifyBlock(block); @@ -273,7 +273,7 @@ for (Block b : loop.getBlocks()) { for (Block sux : b.getSuccessors()) { if (sux.loop != loop) { - BeginNode begin = sux.getBeginNode(); + AbstractBeginNode begin = sux.getBeginNode(); if (!(begin instanceof LoopExitNode && ((LoopExitNode) begin).loopBegin() == loopBegin)) { Debug.log("Unexpected loop exit with %s, including whole branch in the loop", sux); unexpected.add(sux);
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/extended/IntegerSwitchNode.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/extended/IntegerSwitchNode.java Wed Jan 28 00:50:31 2015 +0100 @@ -41,7 +41,7 @@ protected final int[] keys; - public IntegerSwitchNode(ValueNode value, BeginNode[] successors, int[] keys, double[] keyProbabilities, int[] keySuccessors) { + public IntegerSwitchNode(ValueNode value, AbstractBeginNode[] successors, int[] keys, double[] keyProbabilities, int[] keySuccessors) { super(value, successors, keySuccessors, keyProbabilities); assert keySuccessors.length == keys.length + 1; assert keySuccessors.length == keyProbabilities.length; @@ -58,7 +58,7 @@ } public IntegerSwitchNode(ValueNode value, int successorCount, int[] keys, double[] keyProbabilities, int[] keySuccessors) { - this(value, new BeginNode[successorCount], keys, keyProbabilities, keySuccessors); + this(value, new AbstractBeginNode[successorCount], keys, keyProbabilities, keySuccessors); } @Override @@ -130,7 +130,7 @@ tool.addToWorkList(defaultSuccessor()); graph().removeSplitPropagate(this, defaultSuccessor()); } else if (validKeys != keys.length) { - ArrayList<BeginNode> newSuccessors = new ArrayList<>(blockSuccessorCount()); + ArrayList<AbstractBeginNode> newSuccessors = new ArrayList<>(blockSuccessorCount()); int[] newKeys = new int[validKeys]; int[] newKeySuccessors = new int[validKeys + 1]; double[] newKeyProbabilities = new double[validKeys + 1]; @@ -163,14 +163,14 @@ } for (int i = 0; i < blockSuccessorCount(); i++) { - BeginNode successor = blockSuccessor(i); + AbstractBeginNode successor = blockSuccessor(i); if (!newSuccessors.contains(successor)) { tool.deleteBranch(successor); } setBlockSuccessor(i, null); } - BeginNode[] successorsArray = newSuccessors.toArray(new BeginNode[newSuccessors.size()]); + AbstractBeginNode[] successorsArray = newSuccessors.toArray(new AbstractBeginNode[newSuccessors.size()]); IntegerSwitchNode newSwitch = graph().add(new IntegerSwitchNode(value(), successorsArray, newKeys, newKeyProbabilities, newKeySuccessors)); ((FixedWithNextNode) predecessor()).setNext(newSwitch); GraphUtil.killWithUnusedFloatingInputs(this);
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/extended/SwitchNode.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/extended/SwitchNode.java Wed Jan 28 00:50:31 2015 +0100 @@ -37,7 +37,7 @@ @NodeInfo public abstract class SwitchNode extends ControlSplitNode { - @Successor protected NodeSuccessorList<BeginNode> successors; + @Successor protected NodeSuccessorList<AbstractBeginNode> successors; @Input protected ValueNode value; // do not change the contents of these arrays: @@ -50,7 +50,7 @@ * @param value the instruction that provides the value to be switched over * @param successors the list of successors of this switch */ - public SwitchNode(ValueNode value, BeginNode[] successors, int[] keySuccessors, double[] keyProbabilities) { + public SwitchNode(ValueNode value, AbstractBeginNode[] successors, int[] keySuccessors, double[] keyProbabilities) { super(StampFactory.forVoid()); assert value.stamp().getStackKind().isNumericInteger() || value.stamp() instanceof AbstractPointerStamp : value.stamp() + " key not supported by SwitchNode"; assert keySuccessors.length == keyProbabilities.length; @@ -72,7 +72,7 @@ } @Override - public double probability(BeginNode successor) { + public double probability(AbstractBeginNode successor) { double sum = 0; for (int i = 0; i < keySuccessors.length; i++) { if (successors.get(keySuccessors[i]) == successor) { @@ -117,7 +117,7 @@ /** * Returns the successor for the key at the given index. */ - public BeginNode keySuccessor(int i) { + public AbstractBeginNode keySuccessor(int i) { return successors.get(keySuccessors[i]); } @@ -135,11 +135,11 @@ return keySuccessors[keySuccessors.length - 1]; } - public BeginNode blockSuccessor(int i) { + public AbstractBeginNode blockSuccessor(int i) { return successors.get(i); } - public void setBlockSuccessor(int i, BeginNode s) { + public void setBlockSuccessor(int i, AbstractBeginNode s) { successors.set(i, s); } @@ -152,7 +152,7 @@ * * @return the default successor */ - public BeginNode defaultSuccessor() { + public AbstractBeginNode defaultSuccessor() { if (defaultSuccessorIndex() == -1) { throw new GraalInternalError("unexpected"); }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/extended/ValueAnchorNode.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/extended/ValueAnchorNode.java Wed Jan 28 00:50:31 2015 +0100 @@ -91,7 +91,7 @@ @Override public void virtualize(VirtualizerTool tool) { - if (anchored != null && !(anchored instanceof BeginNode)) { + if (anchored != null && !(anchored instanceof AbstractBeginNode)) { 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/ExceptionObjectNode.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/java/ExceptionObjectNode.java Wed Jan 28 00:50:31 2015 +0100 @@ -53,7 +53,7 @@ * deopts can float in between the begin node and the load exception node. */ LocationIdentity locationsKilledByInvoke = ((InvokeWithExceptionNode) predecessor()).getLocationIdentity(); - BeginNode entry = graph().add(new KillingBeginNode(locationsKilledByInvoke)); + AbstractBeginNode entry = graph().add(new KillingBeginNode(locationsKilledByInvoke)); LoadExceptionObjectNode loadException = graph().add(new LoadExceptionObjectNode(stamp())); loadException.setStateAfter(stateAfter());
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/java/MethodCallTargetNode.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/java/MethodCallTargetNode.java Wed Jan 28 00:50:31 2015 +0100 @@ -185,7 +185,7 @@ */ LogicNode condition = graph().unique(new InstanceOfNode(singleImplementor, receiver, getProfile())); GuardNode guard = graph().unique( - new GuardNode(condition, BeginNode.prevBegin(invoke().asNode()), DeoptimizationReason.OptimizedTypeCheckViolated, DeoptimizationAction.InvalidateRecompile, false, + new GuardNode(condition, AbstractBeginNode.prevBegin(invoke().asNode()), DeoptimizationReason.OptimizedTypeCheckViolated, DeoptimizationAction.InvalidateRecompile, false, JavaConstant.NULL_POINTER)); PiNode piNode = graph().unique(new PiNode(receiver, StampFactory.declaredNonNull(singleImplementor), guard)); arguments().set(0, piNode);
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/java/TypeSwitchNode.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/java/TypeSwitchNode.java Wed Jan 28 00:50:31 2015 +0100 @@ -42,7 +42,7 @@ protected final ResolvedJavaType[] keys; - public TypeSwitchNode(ValueNode value, BeginNode[] successors, ResolvedJavaType[] keys, double[] keyProbabilities, int[] keySuccessors) { + public TypeSwitchNode(ValueNode value, AbstractBeginNode[] successors, ResolvedJavaType[] keys, double[] keyProbabilities, int[] keySuccessors) { super(value, successors, keySuccessors, keyProbabilities); assert successors.length <= keys.length + 1; assert keySuccessors.length == keyProbabilities.length; @@ -150,7 +150,7 @@ tool.addToWorkList(defaultSuccessor()); graph().removeSplitPropagate(this, defaultSuccessor()); } else if (validKeys != keys.length) { - ArrayList<BeginNode> newSuccessors = new ArrayList<>(blockSuccessorCount()); + ArrayList<AbstractBeginNode> newSuccessors = new ArrayList<>(blockSuccessorCount()); ResolvedJavaType[] newKeys = new ResolvedJavaType[validKeys]; int[] newKeySuccessors = new int[validKeys + 1]; double[] newKeyProbabilities = new double[validKeys + 1]; @@ -183,14 +183,14 @@ } for (int i = 0; i < blockSuccessorCount(); i++) { - BeginNode successor = blockSuccessor(i); + AbstractBeginNode successor = blockSuccessor(i); if (!newSuccessors.contains(successor)) { tool.deleteBranch(successor); } setBlockSuccessor(i, null); } - BeginNode[] successorsArray = newSuccessors.toArray(new BeginNode[newSuccessors.size()]); + AbstractBeginNode[] successorsArray = newSuccessors.toArray(new AbstractBeginNode[newSuccessors.size()]); TypeSwitchNode newSwitch = graph().add(new TypeSwitchNode(value(), successorsArray, newKeys, newKeyProbabilities, newKeySuccessors)); ((FixedWithNextNode) predecessor()).setNext(newSwitch); GraphUtil.killWithUnusedFloatingInputs(this);
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/spi/NodeLIRBuilderTool.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/spi/NodeLIRBuilderTool.java Wed Jan 28 00:50:31 2015 +0100 @@ -67,7 +67,7 @@ LIRGeneratorTool getLIRGeneratorTool(); - void emitOverflowCheckBranch(BeginNode overflowSuccessor, BeginNode next, Stamp compareStamp, double probability); + void emitOverflowCheckBranch(AbstractBeginNode overflowSuccessor, AbstractBeginNode next, Stamp compareStamp, double probability); Value[] visitInvokeArguments(CallingConvention cc, Collection<ValueNode> arguments);
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/util/GraphUtil.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/util/GraphUtil.java Wed Jan 28 00:50:31 2015 +0100 @@ -187,7 +187,7 @@ if (vpn.isDeleted()) { return; } - BeginNode proxyPoint = vpn.proxyPoint(); + AbstractBeginNode proxyPoint = vpn.proxyPoint(); if (proxyPoint instanceof LoopExitNode) { LoopExitNode exit = (LoopExitNode) proxyPoint; LoopBeginNode loopBegin = exit.loopBegin();
--- a/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/ConditionalEliminationPhase.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/ConditionalEliminationPhase.java Wed Jan 28 00:50:31 2015 +0100 @@ -405,7 +405,7 @@ } } - private void registerControlSplitInfo(Node pred, BeginNode begin) { + private void registerControlSplitInfo(Node pred, AbstractBeginNode begin) { assert pred != null && begin != null; /* * We does not create value proxies for values it may connect accross loop exit node so @@ -640,8 +640,8 @@ @Override protected void node(FixedNode node) { - if (node instanceof BeginNode) { - BeginNode begin = (BeginNode) node; + if (node instanceof AbstractBeginNode) { + AbstractBeginNode begin = (AbstractBeginNode) node; Node pred = node.predecessor(); if (pred != null) { @@ -694,7 +694,7 @@ replacementAnchor = searchAnchor(GraphUtil.unproxify(object), type); } if (replacementAnchor == null) { - replacementAnchor = BeginNode.prevBegin(checkCast); + replacementAnchor = AbstractBeginNode.prevBegin(checkCast); } PiNode piNode; if (isNull) { @@ -730,7 +730,7 @@ LogicNode replacement = null; GuardingNode replacementAnchor = null; - BeginNode survivingSuccessor = null; + AbstractBeginNode survivingSuccessor = null; if (state.trueConditions.containsKey(compare)) { replacement = trueConstant; replacementAnchor = state.trueConditions.get(compare); @@ -752,7 +752,7 @@ } if (replacement != null) { - if (replacementAnchor != null && !(replacementAnchor instanceof BeginNode)) { + if (replacementAnchor != null && !(replacementAnchor instanceof AbstractBeginNode)) { ValueAnchorNode anchor = graph.add(new ValueAnchorNode(replacementAnchor.asNode())); graph.addBeforeFixed(ifNode, anchor); }
--- a/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/ConvertDeoptimizeToGuardPhase.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/ConvertDeoptimizeToGuardPhase.java Wed Jan 28 00:50:31 2015 +0100 @@ -51,8 +51,8 @@ public class ConvertDeoptimizeToGuardPhase extends Phase { private SimplifierTool simplifierTool = GraphUtil.getDefaultSimplifier(null, null, null, false); - private static BeginNode findBeginNode(FixedNode startNode) { - return GraphUtil.predecessorIterable(startNode).filter(BeginNode.class).first(); + private static AbstractBeginNode findBeginNode(FixedNode startNode) { + return GraphUtil.predecessorIterable(startNode).filter(AbstractBeginNode.class).first(); } @Override @@ -63,12 +63,12 @@ } for (DeoptimizeNode d : graph.getNodes(DeoptimizeNode.class)) { assert d.isAlive(); - visitDeoptBegin(BeginNode.prevBegin(d), d.action(), d.reason(), graph); + visitDeoptBegin(AbstractBeginNode.prevBegin(d), d.action(), d.reason(), graph); } for (FixedGuardNode fixedGuard : graph.getNodes(FixedGuardNode.class)) { - BeginNode pred = BeginNode.prevBegin(fixedGuard); + AbstractBeginNode pred = AbstractBeginNode.prevBegin(fixedGuard); if (pred instanceof MergeNode) { MergeNode merge = (MergeNode) pred; if (fixedGuard.condition() instanceof CompareNode) { @@ -96,7 +96,7 @@ } if (xs[i] instanceof PrimitiveConstant && ys[i] instanceof PrimitiveConstant && compare.condition().foldCondition(xs[i], ys[i], null, compare.unorderedIsTrue()) == fixedGuard.isNegated()) { - visitDeoptBegin(BeginNode.prevBegin(mergePredecessor), fixedGuard.getAction(), fixedGuard.getReason(), graph); + visitDeoptBegin(AbstractBeginNode.prevBegin(mergePredecessor), fixedGuard.getAction(), fixedGuard.getReason(), graph); } } } @@ -106,27 +106,27 @@ new DeadCodeEliminationPhase(Optional).apply(graph); } - private void visitDeoptBegin(BeginNode deoptBegin, DeoptimizationAction deoptAction, DeoptimizationReason deoptReason, StructuredGraph graph) { + private void visitDeoptBegin(AbstractBeginNode deoptBegin, DeoptimizationAction deoptAction, DeoptimizationReason deoptReason, StructuredGraph graph) { if (deoptBegin instanceof MergeNode) { MergeNode mergeNode = (MergeNode) deoptBegin; Debug.log("Visiting %s", mergeNode); FixedNode next = mergeNode.next(); while (mergeNode.isAlive()) { AbstractEndNode end = mergeNode.forwardEnds().first(); - BeginNode newBeginNode = findBeginNode(end); + AbstractBeginNode newBeginNode = findBeginNode(end); visitDeoptBegin(newBeginNode, deoptAction, deoptReason, graph); } assert next.isAlive(); - BeginNode newBeginNode = findBeginNode(next); + AbstractBeginNode newBeginNode = findBeginNode(next); visitDeoptBegin(newBeginNode, deoptAction, deoptReason, graph); return; } else if (deoptBegin.predecessor() instanceof IfNode) { IfNode ifNode = (IfNode) deoptBegin.predecessor(); - BeginNode otherBegin = ifNode.trueSuccessor(); + AbstractBeginNode otherBegin = ifNode.trueSuccessor(); LogicNode conditionNode = ifNode.condition(); FixedGuardNode guard = graph.add(new FixedGuardNode(conditionNode, deoptReason, deoptAction, deoptBegin == ifNode.trueSuccessor())); FixedWithNextNode pred = (FixedWithNextNode) ifNode.predecessor(); - BeginNode survivingSuccessor; + AbstractBeginNode survivingSuccessor; if (deoptBegin == ifNode.trueSuccessor()) { survivingSuccessor = ifNode.falseSuccessor(); } else {
--- a/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/ExpandLogicPhase.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/ExpandLogicPhase.java Wed Jan 28 00:50:31 2015 +0100 @@ -55,8 +55,8 @@ } private static void processIf(LogicNode x, boolean xNegated, LogicNode y, boolean yNegated, IfNode ifNode, double shortCircuitProbability) { - BeginNode trueTarget = ifNode.trueSuccessor(); - BeginNode falseTarget = ifNode.falseSuccessor(); + AbstractBeginNode trueTarget = ifNode.trueSuccessor(); + AbstractBeginNode 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)) @@ -78,9 +78,9 @@ EndNode secondTrueEnd = graph.add(new EndNode()); trueTargetMerge.addForwardEnd(firstTrueEnd); trueTargetMerge.addForwardEnd(secondTrueEnd); - 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))); + 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))); 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 Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/FloatingReadPhase.java Wed Jan 28 00:50:31 2015 +0100 @@ -246,7 +246,7 @@ } @Override - protected Set<LocationIdentity> afterSplit(BeginNode node, Set<LocationIdentity> oldState) { + protected Set<LocationIdentity> afterSplit(AbstractBeginNode node, Set<LocationIdentity> oldState) { return CollectionsFactory.newSet(oldState); } @@ -351,7 +351,7 @@ } @Override - protected MemoryMapImpl afterSplit(BeginNode node, MemoryMapImpl oldState) { + protected MemoryMapImpl afterSplit(AbstractBeginNode 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 Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/FrameStateAssignmentPhase.java Wed Jan 28 00:50:31 2015 +0100 @@ -94,7 +94,7 @@ } @Override - protected FrameState afterSplit(BeginNode node, FrameState oldState) { + protected FrameState afterSplit(AbstractBeginNode node, FrameState oldState) { return oldState; }
--- a/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/GuardLoweringPhase.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/GuardLoweringPhase.java Wed Jan 28 00:50:31 2015 +0100 @@ -161,12 +161,12 @@ private void lowerToIf(GuardNode guard) { StructuredGraph graph = guard.graph(); - BeginNode fastPath = graph.add(new BeginNode()); + AbstractBeginNode fastPath = graph.add(new AbstractBeginNode()); @SuppressWarnings("deprecation") DeoptimizeNode deopt = graph.add(new DeoptimizeNode(guard.action(), guard.reason(), useGuardIdAsDebugId ? guard.getId() : 0, guard.getSpeculation(), null)); - BeginNode deoptBranch = BeginNode.begin(deopt); - BeginNode trueSuccessor; - BeginNode falseSuccessor; + AbstractBeginNode deoptBranch = AbstractBeginNode.begin(deopt); + AbstractBeginNode trueSuccessor; + AbstractBeginNode falseSuccessor; insertLoopExits(deopt); if (guard.isNegated()) { trueSuccessor = deoptBranch;
--- a/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/LoweringPhase.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/LoweringPhase.java Wed Jan 28 00:50:31 2015 +0100 @@ -319,7 +319,7 @@ if (loweringTool.guardAnchor.asNode().isDeleted()) { // TODO nextNode could be deleted but this is not currently supported assert nextNode.isAlive(); - loweringTool.guardAnchor = BeginNode.prevBegin(nextNode); + loweringTool.guardAnchor = AbstractBeginNode.prevBegin(nextNode); } assert checkPostNodeLowering(node, loweringTool, preLoweringMark, unscheduledUsages); } @@ -336,7 +336,7 @@ // FixedWithNextNode is followed by some kind of BeginNode. // For example the when a FixedGuard followed by a loop exit is lowered to a // control-split + deopt. - BeginNode begin = node.graph().add(new BeginNode()); + AbstractBeginNode begin = node.graph().add(new AbstractBeginNode()); nextLastFixed.replaceFirstSuccessor(nextNode, begin); begin.setNext(nextNode); nextLastFixed = begin;
--- a/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/OptimizeGuardAnchorsPhase.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/OptimizeGuardAnchorsPhase.java Wed Jan 28 00:50:31 2015 +0100 @@ -55,11 +55,11 @@ @Override protected void run(StructuredGraph graph) { LazyCFG cfg = new LazyCFG(graph); - for (BeginNode begin : graph.getNodes(BeginNode.class)) { + for (AbstractBeginNode begin : graph.getNodes(AbstractBeginNode.class)) { if (!(begin instanceof StartNode || begin.predecessor() instanceof ControlSplitNode)) { NodeIterable<GuardNode> guards = begin.guards(); if (guards.isNotEmpty()) { - BeginNode newAnchor = computeOptimalAnchor(cfg.get(), begin); + AbstractBeginNode 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 BeginNode getOptimalAnchor(LazyCFG cfg, BeginNode begin) { + public static AbstractBeginNode getOptimalAnchor(LazyCFG cfg, AbstractBeginNode begin) { if (begin instanceof StartNode || begin.predecessor() instanceof ControlSplitNode) { return begin; } return computeOptimalAnchor(cfg.get(), begin); } - private static BeginNode computeOptimalAnchor(ControlFlowGraph cfg, BeginNode begin) { + private static AbstractBeginNode computeOptimalAnchor(ControlFlowGraph cfg, AbstractBeginNode 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) { - BeginNode successor = findMinimumUsagesSuccessor(controlSplit); + AbstractBeginNode 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) { - BeginNode anchor = computeOptimalAnchor(cfg.get(), BeginNode.prevBegin(controlSplit)); + AbstractBeginNode anchor = computeOptimalAnchor(cfg.get(), AbstractBeginNode.prevBegin(controlSplit)); GuardNode newGuard = controlSplit.graph().unique(new GuardNode(guard.condition(), anchor, guard.reason(), guard.action(), guard.isNegated(), guard.getSpeculation())); for (GuardNode otherGuard : otherGuards) { otherGuard.replaceAndDelete(newGuard); @@ -126,12 +126,12 @@ conditonGuard.getSpeculation().equals(guard.getSpeculation()); } - private static BeginNode findMinimumUsagesSuccessor(ControlSplitNode controlSplit) { + private static AbstractBeginNode findMinimumUsagesSuccessor(ControlSplitNode controlSplit) { NodePosIterator successors = controlSplit.successors().iterator(); - BeginNode min = (BeginNode) successors.next(); + AbstractBeginNode min = (AbstractBeginNode) successors.next(); int minUsages = min.getUsageCount(); while (successors.hasNext()) { - BeginNode successor = (BeginNode) successors.next(); + AbstractBeginNode successor = (AbstractBeginNode) successors.next(); int count = successor.getUsageCount(); if (count < minUsages) { minUsages = count;
--- a/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/ProfileCompiledMethodsPhase.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/ProfileCompiledMethodsPhase.java Wed Jan 28 00:50:31 2015 +0100 @@ -127,7 +127,7 @@ private static double getNodeWeight(ValueNode node) { if (node instanceof MergeNode) { return ((MergeNode) node).phiPredecessorCount(); - } else if (node instanceof BeginNode || node instanceof AbstractEndNode || node instanceof MonitorIdNode || node instanceof ConstantNode || node instanceof ParameterNode || + } else if (node instanceof AbstractBeginNode || 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 Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/TailDuplicationPhase.java Wed Jan 28 00:50:31 2015 +0100 @@ -298,7 +298,7 @@ // EndNode FixedWithNextNode anchorDuplicate = (FixedWithNextNode) duplicates.get(anchor); // move dependencies on the ValueAnchorNode to the previous BeginNode - BeginNode prevBegin = BeginNode.prevBegin(forwardEnd); + AbstractBeginNode prevBegin = AbstractBeginNode.prevBegin(forwardEnd); anchorDuplicate.replaceAtUsages(InputType.Guard, prevBegin); anchorDuplicate.replaceAtUsages(InputType.Anchor, prevBegin); assert anchorDuplicate.hasNoUsages();
--- a/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/UseTrappingNullChecksPhase.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/UseTrappingNullChecksPhase.java Wed Jan 28 00:50:31 2015 +0100 @@ -122,16 +122,16 @@ checkPredecessor(deopt, end.predecessor(), deoptimizationReason); } } - } else if (predecessor instanceof BeginNode) { + } else if (predecessor instanceof AbstractBeginNode) { checkPredecessor(deopt, predecessor, deoptimizationReason); } } private static void checkPredecessor(AbstractDeoptimizeNode deopt, Node predecessor, DeoptimizationReason deoptimizationReason) { Node current = predecessor; - BeginNode branch = null; - while (current instanceof BeginNode) { - branch = (BeginNode) current; + AbstractBeginNode branch = null; + while (current instanceof AbstractBeginNode) { + branch = (AbstractBeginNode) current; if (branch.anchored().isNotEmpty()) { // some input of the deopt framestate is anchored to this branch return; @@ -159,8 +159,8 @@ metricTrappingNullCheckUnreached.increment(); } IsNullNode isNullNode = (IsNullNode) condition; - BeginNode nonTrappingContinuation = ifNode.falseSuccessor(); - BeginNode trappingContinuation = ifNode.trueSuccessor(); + AbstractBeginNode nonTrappingContinuation = ifNode.falseSuccessor(); + AbstractBeginNode trappingContinuation = ifNode.trueSuccessor(); NullCheckNode trappingNullCheck = deopt.graph().add(new NullCheckNode(isNullNode.getValue())); trappingNullCheck.setStateBefore(deopt.stateBefore()); deopt.graph().replaceSplit(ifNode, trappingNullCheck, nonTrappingContinuation); @@ -171,7 +171,7 @@ * then remove the Begin from the graph. */ nonTrappingContinuation.replaceAtUsages(InputType.Guard, trappingNullCheck); - if (nonTrappingContinuation.getClass() == BeginNode.class) { + if (nonTrappingContinuation.getClass() == AbstractBeginNode.class) { FixedNode next = nonTrappingContinuation.next(); nonTrappingContinuation.clearSuccessors(); trappingNullCheck.setNext(next);
--- a/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/inlining/InliningUtil.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/inlining/InliningUtil.java Wed Jan 28 00:50:31 2015 +0100 @@ -265,7 +265,7 @@ } } - final BeginNode prevBegin = BeginNode.prevBegin(invokeNode); + final AbstractBeginNode prevBegin = AbstractBeginNode.prevBegin(invokeNode); DuplicationReplacement localReplacement = new DuplicationReplacement() { public Node replacement(Node node) { @@ -303,9 +303,9 @@ } // get rid of memory kill - BeginNode begin = invokeWithException.next(); + AbstractBeginNode begin = invokeWithException.next(); if (begin instanceof KillingBeginNode) { - BeginNode newBegin = new BeginNode(); + AbstractBeginNode newBegin = new AbstractBeginNode(); graph.addAfterFixed(begin, graph.add(newBegin)); begin.replaceAtUsages(newBegin); graph.removeFixed(begin); @@ -458,8 +458,8 @@ } } else { FixedNode deoptimizeNode = graph.add(new DeoptimizeNode(DeoptimizationAction.InvalidateRecompile, DeoptimizationReason.NotCompiledExceptionHandler)); - if (fixedStateSplit instanceof BeginNode) { - deoptimizeNode = BeginNode.begin(deoptimizeNode); + if (fixedStateSplit instanceof AbstractBeginNode) { + deoptimizeNode = AbstractBeginNode.begin(deoptimizeNode); } fixedStateSplit.replaceAtPredecessor(deoptimizeNode); GraphUtil.killCFG(fixedStateSplit);
--- a/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/inlining/info/MultiTypeGuardInlineInfo.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/inlining/info/MultiTypeGuardInlineInfo.java Wed Jan 28 00:50:31 2015 +0100 @@ -196,7 +196,7 @@ } // create one separate block for each invoked method - BeginNode[] successors = new BeginNode[numberOfMethods + 1]; + AbstractBeginNode[] successors = new AbstractBeginNode[numberOfMethods + 1]; for (int i = 0; i < numberOfMethods; i++) { successors[i] = createInvocationBlock(graph, invoke, returnMerge, returnValuePhi, exceptionMerge, exceptionObjectPhi, true); } @@ -208,7 +208,7 @@ } else { unknownTypeSux = graph.add(new DeoptimizeNode(DeoptimizationAction.InvalidateReprofile, DeoptimizationReason.TypeCheckedInliningViolated)); } - successors[successors.length - 1] = BeginNode.begin(unknownTypeSux); + successors[successors.length - 1] = AbstractBeginNode.begin(unknownTypeSux); // replace the invoke exception edge if (invoke instanceof InvokeWithExceptionNode) { @@ -234,7 +234,7 @@ // prepare the anchors for the invokes for (int i = 0; i < numberOfMethods; i++) { - BeginNode node = successors[i]; + AbstractBeginNode node = successors[i]; Invoke invokeForInlining = (Invoke) node.next(); ResolvedJavaType commonType; @@ -330,10 +330,10 @@ private Collection<Node> inlineSingleMethod(StructuredGraph graph, MetaAccessProvider metaAccess, Assumptions assumptions, StampProvider stampProvider) { assert concretes.size() == 1 && inlineableElements.length == 1 && ptypes.size() > 1 && !shouldFallbackToInvoke() && notRecordedTypeProbability == 0; - BeginNode calleeEntryNode = graph.add(new BeginNode()); + AbstractBeginNode calleeEntryNode = graph.add(new AbstractBeginNode()); - BeginNode unknownTypeSux = createUnknownTypeSuccessor(graph); - BeginNode[] successors = new BeginNode[]{calleeEntryNode, unknownTypeSux}; + AbstractBeginNode unknownTypeSux = createUnknownTypeSuccessor(graph); + AbstractBeginNode[] successors = new AbstractBeginNode[]{calleeEntryNode, unknownTypeSux}; createDispatchOnTypeBeforeInvoke(graph, successors, false, metaAccess, stampProvider); calleeEntryNode.setNext(invoke.asNode()); @@ -341,7 +341,7 @@ return inline(invoke, methodAt(0), inlineableElementAt(0), assumptions, false); } - private boolean createDispatchOnTypeBeforeInvoke(StructuredGraph graph, BeginNode[] successors, boolean invokeIsOnlySuccessor, MetaAccessProvider metaAccess, StampProvider stampProvider) { + private boolean createDispatchOnTypeBeforeInvoke(StructuredGraph graph, AbstractBeginNode[] successors, boolean invokeIsOnlySuccessor, MetaAccessProvider metaAccess, StampProvider stampProvider) { assert ptypes.size() >= 1; ValueNode nonNullReceiver = InliningUtil.nonNullReceiver(invoke); LoadHubNode hub = graph.unique(new LoadHubNode(stampProvider, nonNullReceiver)); @@ -459,10 +459,10 @@ return costEstimateMethodDispatch < costEstimateTypeDispatch; } - private static BeginNode createInvocationBlock(StructuredGraph graph, Invoke invoke, MergeNode returnMerge, PhiNode returnValuePhi, MergeNode exceptionMerge, PhiNode exceptionObjectPhi, + private static AbstractBeginNode createInvocationBlock(StructuredGraph graph, Invoke invoke, MergeNode returnMerge, PhiNode returnValuePhi, MergeNode exceptionMerge, PhiNode exceptionObjectPhi, boolean useForInlining) { Invoke duplicatedInvoke = duplicateInvokeForInlining(graph, invoke, exceptionMerge, exceptionObjectPhi, useForInlining); - BeginNode calleeEntryNode = graph.add(new BeginNode()); + AbstractBeginNode calleeEntryNode = graph.add(new AbstractBeginNode()); calleeEntryNode.setNext(duplicatedInvoke.asNode()); AbstractEndNode endNode = graph.add(new EndNode()); @@ -538,9 +538,9 @@ } private void devirtualizeWithTypeSwitch(StructuredGraph graph, InvokeKind kind, ResolvedJavaMethod target, MetaAccessProvider metaAccess, StampProvider stampProvider) { - BeginNode invocationEntry = graph.add(new BeginNode()); - BeginNode unknownTypeSux = createUnknownTypeSuccessor(graph); - BeginNode[] successors = new BeginNode[]{invocationEntry, unknownTypeSux}; + AbstractBeginNode invocationEntry = graph.add(new AbstractBeginNode()); + AbstractBeginNode unknownTypeSux = createUnknownTypeSuccessor(graph); + AbstractBeginNode[] successors = new AbstractBeginNode[]{invocationEntry, unknownTypeSux}; createDispatchOnTypeBeforeInvoke(graph, successors, true, metaAccess, stampProvider); invocationEntry.setNext(invoke.asNode()); @@ -550,8 +550,8 @@ InliningUtil.replaceInvokeCallTarget(invoke, graph, kind, target); } - private static BeginNode createUnknownTypeSuccessor(StructuredGraph graph) { - return BeginNode.begin(graph.add(new DeoptimizeNode(DeoptimizationAction.InvalidateReprofile, DeoptimizationReason.TypeCheckedInliningViolated))); + private static AbstractBeginNode createUnknownTypeSuccessor(StructuredGraph graph) { + return AbstractBeginNode.begin(graph.add(new DeoptimizeNode(DeoptimizationAction.InvalidateReprofile, DeoptimizationReason.TypeCheckedInliningViolated))); } @Override
--- a/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/inlining/walker/ComputeInliningRelevance.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/inlining/walker/ComputeInliningRelevance.java Wed Jan 28 00:50:31 2015 +0100 @@ -278,7 +278,7 @@ int pathBeginCount = pathBeginNodes.size(); for (Node sux : controlSplit.successors()) { - double probability = controlSplit.probability((BeginNode) sux); + double probability = controlSplit.probability((AbstractBeginNode) sux); if (probability > maxProbability) { maxProbability = probability; maxSux = sux;
--- a/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/graph/FixedNodeProbabilityCache.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/graph/FixedNodeProbabilityCache.java Wed Jan 28 00:50:31 2015 +0100 @@ -30,7 +30,7 @@ import com.oracle.graal.nodes.*; /** - * Compute probabilities for fixed nodes on the fly and cache them at {@link BeginNode}s. + * Compute probabilities for fixed nodes on the fly and cache them at {@link AbstractBeginNode}s. */ public class FixedNodeProbabilityCache implements ToDoubleFunction<FixedNode> { @@ -40,7 +40,7 @@ /** * <p> - * Given a {@link FixedNode} this method finds the most immediate {@link BeginNode} preceding it + * Given a {@link FixedNode} this method finds the most immediate {@link AbstractBeginNode} preceding it * that either: * <ul> * <li>has no predecessor (ie, the begin-node is a merge, in particular a loop-begin, or the @@ -50,7 +50,7 @@ * </p> * * <p> - * The thus found {@link BeginNode} is equi-probable with the {@link FixedNode} it was obtained + * The thus found {@link AbstractBeginNode} is equi-probable with the {@link FixedNode} it was obtained * from. When computed for the first time (afterwards a cache lookup returns it) that * probability is computed as follows, again depending on the begin-node's predecessor: * <ul> @@ -77,7 +77,7 @@ while (true) { assert current != null; Node predecessor = current.predecessor(); - if (current instanceof BeginNode) { + if (current instanceof AbstractBeginNode) { if (predecessor == null) { break; } else if (predecessor.successors().count() != 1) { @@ -91,7 +91,7 @@ current = (FixedNode) predecessor; } - assert current instanceof BeginNode; + assert current instanceof AbstractBeginNode; Double cachedValue = cache.get(current); if (cachedValue != null) { return cachedValue; @@ -119,7 +119,7 @@ } } else { ControlSplitNode split = (ControlSplitNode) current.predecessor(); - probability = split.probability((BeginNode) current) * applyAsDouble(split); + probability = split.probability((AbstractBeginNode) current) * applyAsDouble(split); } assert !Double.isNaN(probability) && !Double.isInfinite(probability) : current + " " + probability; cache.put(current, probability);
--- a/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/graph/MergeableState.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/graph/MergeableState.java Wed Jan 28 00:50:31 2015 +0100 @@ -65,7 +65,7 @@ * * @param node the successor of the control split that is about to be visited */ - public void afterSplit(BeginNode node) { + public void afterSplit(AbstractBeginNode node) { // empty default implementation } }
--- a/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/graph/PostOrderNodeIterator.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/graph/PostOrderNodeIterator.java Wed Jan 28 00:50:31 2015 +0100 @@ -43,7 +43,7 @@ public abstract class PostOrderNodeIterator<T extends MergeableState<T>> { private final NodeBitMap visitedEnds; - private final Deque<BeginNode> nodeQueue; + private final Deque<AbstractBeginNode> nodeQueue; private final Map<FixedNode, T> nodeStates; private final FixedNode start; @@ -110,13 +110,13 @@ for (Node node : successors) { if (node != null) { nodeStates.put((FixedNode) node.predecessor(), state); - nodeQueue.addFirst((BeginNode) node); + nodeQueue.addFirst((AbstractBeginNode) node); } } } else { for (Node node : x.successors()) { if (node != null) { - nodeQueue.addFirst((BeginNode) node); + nodeQueue.addFirst((AbstractBeginNode) node); } } } @@ -125,7 +125,7 @@ private FixedNode nextQueuedNode() { int maxIterations = nodeQueue.size(); while (maxIterations-- > 0) { - BeginNode node = nodeQueue.removeFirst(); + AbstractBeginNode node = nodeQueue.removeFirst(); if (node instanceof MergeNode) { MergeNode merge = (MergeNode) node; state = nodeStates.get(merge.forwardEndAt(0)).clone();
--- a/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/graph/ReentrantNodeIterator.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/graph/ReentrantNodeIterator.java Wed Jan 28 00:50:31 2015 +0100 @@ -46,7 +46,7 @@ protected abstract StateT merge(MergeNode merge, List<StateT> states); - protected abstract StateT afterSplit(BeginNode node, StateT oldState); + protected abstract StateT afterSplit(AbstractBeginNode node, StateT oldState); protected abstract Map<LoopExitNode, StateT> processLoop(LoopBeginNode loop, StateT initialState); @@ -87,7 +87,7 @@ private static <StateT> Map<FixedNode, StateT> apply(NodeIteratorClosure<StateT> closure, FixedNode start, StateT initialState, LoopBeginNode boundary) { assert start != null; - Deque<BeginNode> nodeQueue = new ArrayDeque<>(); + Deque<AbstractBeginNode> nodeQueue = new ArrayDeque<>(); Map<FixedNode, StateT> blockEndStates = Node.newIdentityMap(); StateT state = initialState; @@ -153,7 +153,7 @@ continue; } else { do { - BeginNode successor = (BeginNode) successors.next(); + AbstractBeginNode successor = (AbstractBeginNode) successors.next(); StateT successorState = closure.afterSplit(successor, state); if (closure.continueIteration(successorState)) { blockEndStates.put(successor, successorState); @@ -161,7 +161,7 @@ } } while (successors.hasNext()); - state = closure.afterSplit((BeginNode) firstSuccessor, state); + state = closure.afterSplit((AbstractBeginNode) firstSuccessor, state); current = closure.continueIteration(state) ? firstSuccessor : null; continue; } @@ -176,7 +176,7 @@ current = nodeQueue.removeFirst(); assert blockEndStates.containsKey(current); state = blockEndStates.remove(current); - assert !(current instanceof MergeNode) && current instanceof BeginNode; + assert !(current instanceof MergeNode) && current instanceof AbstractBeginNode; } } while (true); }
--- a/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/graph/SinglePassNodeIterator.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/graph/SinglePassNodeIterator.java Wed Jan 28 00:50:31 2015 +0100 @@ -109,10 +109,10 @@ * </p> */ private static final class PathStart<U> { - private final BeginNode node; + private final AbstractBeginNode node; private final U stateOnEntry; - private PathStart(BeginNode node, U stateOnEntry) { + private PathStart(AbstractBeginNode node, U stateOnEntry) { this.node = node; this.stateOnEntry = stateOnEntry; assert repOK(); @@ -210,13 +210,13 @@ private void queueSuccessors(FixedNode x) { Iterator<Node> iter = x.successors().nonNull().iterator(); if (iter.hasNext()) { - BeginNode begin = (BeginNode) iter.next(); + AbstractBeginNode begin = (AbstractBeginNode) iter.next(); // the current state isn't cloned for the first successor // conceptually, the state is handed over to it nodeQueue.addFirst(new PathStart<>(begin, state)); } while (iter.hasNext()) { - BeginNode begin = (BeginNode) iter.next(); + AbstractBeginNode begin = (AbstractBeginNode) iter.next(); // for all other successors it is cloned nodeQueue.addFirst(new PathStart<>(begin, state.clone())); } @@ -249,7 +249,7 @@ assert ready : "Not a single-pass iterator after all"; return merge; } else { - BeginNode begin = elem.node; + AbstractBeginNode begin = elem.node; assert begin.predecessor() != null; state = elem.stateOnEntry; state.afterSplit(begin);
--- a/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/graph/StatelessPostOrderNodeIterator.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/graph/StatelessPostOrderNodeIterator.java Wed Jan 28 00:50:31 2015 +0100 @@ -36,7 +36,7 @@ public abstract class StatelessPostOrderNodeIterator { private final NodeBitMap visitedEnds; - private final Deque<BeginNode> nodeQueue; + private final Deque<AbstractBeginNode> 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((BeginNode) node); + nodeQueue.addFirst((AbstractBeginNode) node); } } current = nodeQueue.pollFirst();
--- a/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/schedule/SchedulePhase.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/schedule/SchedulePhase.java Wed Jan 28 00:50:31 2015 +0100 @@ -251,7 +251,7 @@ } } - BeginNode startNode = cfg.getStartBlock().getBeginNode(); + AbstractBeginNode startNode = cfg.getStartBlock().getBeginNode(); assert startNode instanceof StartNode; LocationSet accm = foundExcludeNode ? set : excludedLocations; @@ -771,7 +771,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 BeginNode) { + } else if (unscheduledUsage instanceof AbstractBeginNode) { // Only FrameStates can be connected to BeginNodes. if (!(usage instanceof FrameState)) { throw new SchedulingError(usage.toString()); @@ -1137,7 +1137,7 @@ } } - if (instruction instanceof BeginNode) { + if (instruction instanceof AbstractBeginNode) { for (ValueNode inBlock : blockToNodesMap.get(b)) { if (!visited.isMarked(inBlock)) { addToEarliestSorting(b, inBlock, sortedInstructions, visited);
--- a/graal/com.oracle.graal.printer/src/com/oracle/graal/printer/CFGPrinter.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.printer/src/com/oracle/graal/printer/CFGPrinter.java Wed Jan 28 00:50:31 2015 +0100 @@ -484,7 +484,7 @@ return "-"; } String prefix; - if (node instanceof BeginNode && (lir == null && schedule == null)) { + if (node instanceof AbstractBeginNode && (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 Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.printer/src/com/oracle/graal/printer/IdealGraphPrinter.java Wed Jan 28 00:50:31 2015 +0100 @@ -173,7 +173,7 @@ printProperty(bit, "true"); } } - if (node.getClass() == BeginNode.class) { + if (node.getClass() == AbstractBeginNode.class) { printProperty("shortName", "B"); } else if (node.getClass() == EndNode.class) { printProperty("shortName", "E");
--- a/graal/com.oracle.graal.replacements/src/com/oracle/graal/replacements/CollapseFrameForSingleSideEffectPhase.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.replacements/src/com/oracle/graal/replacements/CollapseFrameForSingleSideEffectPhase.java Wed Jan 28 00:50:31 2015 +0100 @@ -68,7 +68,7 @@ return new IterationState(this, sideEffect.asNode(), null, true); } - public IterationState addBranch(BeginNode begin) { + public IterationState addBranch(AbstractBeginNode begin) { return new IterationState(this, begin, null, this.invalid); } @@ -191,7 +191,7 @@ } @Override - protected IterationState afterSplit(BeginNode node, IterationState oldState) { + protected IterationState afterSplit(AbstractBeginNode node, IterationState oldState) { return oldState.addBranch(node); }
--- a/graal/com.oracle.graal.replacements/src/com/oracle/graal/replacements/DefaultJavaLoweringProvider.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.replacements/src/com/oracle/graal/replacements/DefaultJavaLoweringProvider.java Wed Jan 28 00:50:31 2015 +0100 @@ -275,7 +275,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(BeginNode.prevBegin(load)); + memoryRead.setGuard(AbstractBeginNode.prevBegin(load)); graph.replaceFixedWithFixed(load, memoryRead); } }
--- a/graal/com.oracle.graal.replacements/src/com/oracle/graal/replacements/GraphKit.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.replacements/src/com/oracle/graal/replacements/GraphKit.java Wed Jan 28 00:50:31 2015 +0100 @@ -246,8 +246,8 @@ * @param trueProbability The estimated probability the the condition is true */ public void startIf(LogicNode condition, double trueProbability) { - BeginNode thenSuccessor = graph.add(new BeginNode()); - BeginNode elseSuccessor = graph.add(new BeginNode()); + AbstractBeginNode thenSuccessor = graph.add(new AbstractBeginNode()); + AbstractBeginNode elseSuccessor = graph.add(new AbstractBeginNode()); append(new IfNode(condition, thenSuccessor, elseSuccessor, trueProbability)); lastFixedNode = null;
--- a/graal/com.oracle.graal.replacements/src/com/oracle/graal/replacements/SnippetTemplate.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.replacements/src/com/oracle/graal/replacements/SnippetTemplate.java Wed Jan 28 00:50:31 2015 +0100 @@ -1100,7 +1100,7 @@ FixedNode firstCFGNode = entryPointNode.next(); StructuredGraph replaceeGraph = replacee.graph(); Map<Node, Node> replacements = bind(replaceeGraph, metaAccess, args); - replacements.put(entryPointNode, BeginNode.prevBegin(replacee)); + replacements.put(entryPointNode, AbstractBeginNode.prevBegin(replacee)); Map<Node, Node> duplicates = replaceeGraph.addDuplicates(nodes, snippet, snippet.getNodeCount(), replacements); Debug.dump(replaceeGraph, "After inlining snippet %s", snippet.method());
--- a/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/nodes/arithmetic/IntegerAddExactNode.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/nodes/arithmetic/IntegerAddExactNode.java Wed Jan 28 00:50:31 2015 +0100 @@ -83,7 +83,7 @@ } @Override - public IntegerExactArithmeticSplitNode createSplit(BeginNode next, BeginNode deopt) { + public IntegerExactArithmeticSplitNode createSplit(AbstractBeginNode next, AbstractBeginNode deopt) { return graph().add(new IntegerAddExactSplitNode(stamp(), getX(), getY(), next, deopt)); }
--- a/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/nodes/arithmetic/IntegerAddExactSplitNode.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/nodes/arithmetic/IntegerAddExactSplitNode.java Wed Jan 28 00:50:31 2015 +0100 @@ -31,7 +31,7 @@ @NodeInfo public class IntegerAddExactSplitNode extends IntegerExactArithmeticSplitNode { - public IntegerAddExactSplitNode(Stamp stamp, ValueNode x, ValueNode y, BeginNode next, BeginNode overflowSuccessor) { + public IntegerAddExactSplitNode(Stamp stamp, ValueNode x, ValueNode y, AbstractBeginNode next, AbstractBeginNode overflowSuccessor) { super(stamp, x, y, next, overflowSuccessor); }
--- a/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/nodes/arithmetic/IntegerExactArithmeticNode.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/nodes/arithmetic/IntegerExactArithmeticNode.java Wed Jan 28 00:50:31 2015 +0100 @@ -27,5 +27,5 @@ interface IntegerExactArithmeticNode extends Lowerable { - IntegerExactArithmeticSplitNode createSplit(BeginNode next, BeginNode deopt); + IntegerExactArithmeticSplitNode createSplit(AbstractBeginNode next, AbstractBeginNode deopt); }
--- a/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/nodes/arithmetic/IntegerExactArithmeticSplitNode.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/nodes/arithmetic/IntegerExactArithmeticSplitNode.java Wed Jan 28 00:50:31 2015 +0100 @@ -32,12 +32,12 @@ @NodeInfo public abstract class IntegerExactArithmeticSplitNode extends ControlSplitNode implements LIRLowerable { - @Successor BeginNode overflowSuccessor; - @Successor BeginNode next; + @Successor AbstractBeginNode overflowSuccessor; + @Successor AbstractBeginNode next; @Input ValueNode x; @Input ValueNode y; - public IntegerExactArithmeticSplitNode(Stamp stamp, ValueNode x, ValueNode y, BeginNode next, BeginNode overflowSuccessor) { + public IntegerExactArithmeticSplitNode(Stamp stamp, ValueNode x, ValueNode y, AbstractBeginNode next, AbstractBeginNode overflowSuccessor) { super(stamp); this.x = x; this.y = y; @@ -46,15 +46,15 @@ } @Override - public double probability(BeginNode successor) { + public double probability(AbstractBeginNode successor) { return successor == next ? 1 : 0; } - public BeginNode getNext() { + public AbstractBeginNode getNext() { return next; } - public BeginNode getOverflowSuccessor() { + public AbstractBeginNode getOverflowSuccessor() { return overflowSuccessor; } @@ -81,9 +81,9 @@ FixedNode next = previous.next(); previous.setNext(null); DeoptimizeNode deopt = floatingNode.graph().add(new DeoptimizeNode(DeoptimizationAction.InvalidateReprofile, DeoptimizationReason.ArithmeticException)); - BeginNode normalBegin = floatingNode.graph().add(new BeginNode()); + AbstractBeginNode normalBegin = floatingNode.graph().add(new AbstractBeginNode()); normalBegin.setNext(next); - IntegerExactArithmeticSplitNode split = node.createSplit(normalBegin, BeginNode.begin(deopt)); + IntegerExactArithmeticSplitNode split = node.createSplit(normalBegin, AbstractBeginNode.begin(deopt)); previous.setNext(split); floatingNode.replaceAndDelete(split); }
--- a/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/nodes/arithmetic/IntegerMulExactNode.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/nodes/arithmetic/IntegerMulExactNode.java Wed Jan 28 00:50:31 2015 +0100 @@ -80,7 +80,7 @@ } @Override - public IntegerExactArithmeticSplitNode createSplit(BeginNode next, BeginNode deopt) { + public IntegerExactArithmeticSplitNode createSplit(AbstractBeginNode next, AbstractBeginNode deopt) { return graph().add(new IntegerMulExactSplitNode(stamp(), getX(), getY(), next, deopt)); }
--- a/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/nodes/arithmetic/IntegerMulExactSplitNode.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/nodes/arithmetic/IntegerMulExactSplitNode.java Wed Jan 28 00:50:31 2015 +0100 @@ -31,7 +31,7 @@ @NodeInfo public class IntegerMulExactSplitNode extends IntegerExactArithmeticSplitNode { - public IntegerMulExactSplitNode(Stamp stamp, ValueNode x, ValueNode y, BeginNode next, BeginNode overflowSuccessor) { + public IntegerMulExactSplitNode(Stamp stamp, ValueNode x, ValueNode y, AbstractBeginNode next, AbstractBeginNode overflowSuccessor) { super(stamp, x, y, next, overflowSuccessor); }
--- a/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/nodes/arithmetic/IntegerSubExactNode.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/nodes/arithmetic/IntegerSubExactNode.java Wed Jan 28 00:50:31 2015 +0100 @@ -84,7 +84,7 @@ } @Override - public IntegerExactArithmeticSplitNode createSplit(BeginNode next, BeginNode deopt) { + public IntegerExactArithmeticSplitNode createSplit(AbstractBeginNode next, AbstractBeginNode deopt) { return graph().add(new IntegerSubExactSplitNode(stamp(), getX(), getY(), next, deopt)); }
--- a/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/nodes/arithmetic/IntegerSubExactSplitNode.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/nodes/arithmetic/IntegerSubExactSplitNode.java Wed Jan 28 00:50:31 2015 +0100 @@ -31,7 +31,7 @@ @NodeInfo public class IntegerSubExactSplitNode extends IntegerExactArithmeticSplitNode { - public IntegerSubExactSplitNode(Stamp stamp, ValueNode x, ValueNode y, BeginNode next, BeginNode overflowSuccessor) { + public IntegerSubExactSplitNode(Stamp stamp, ValueNode x, ValueNode y, AbstractBeginNode next, AbstractBeginNode overflowSuccessor) { super(stamp, x, y, next, overflowSuccessor); }
--- a/graal/com.oracle.graal.word/src/com/oracle/graal/word/phases/WordTypeRewriterPhase.java Tue Jan 27 23:52:31 2015 +0100 +++ b/graal/com.oracle.graal.word/src/com/oracle/graal/word/phases/WordTypeRewriterPhase.java Wed Jan 28 00:50:31 2015 +0100 @@ -405,7 +405,7 @@ * The read must not float outside its block otherwise it may float above an explicit zero * check on its base address. */ - read.setGuard(BeginNode.prevBegin(invoke.asNode())); + read.setGuard(AbstractBeginNode.prevBegin(invoke.asNode())); return read; }