private static void killEnd(AbstractEndNode end) {
MergeNode merge = end.merge();
if (merge != null) {
merge.removeEnd(end);
StructuredGraph graph = end.graph();
if (merge instanceof LoopBeginNode && merge.forwardEndCount() == 0) { // dead loop
for (PhiNode phi : merge.phis().snapshot()) {
propagateKill(phi);
}
LoopBeginNode begin = (LoopBeginNode) merge;
// disconnect and delete loop ends & loop exits
for (LoopEndNode loopend : begin.loopEnds().snapshot()) {
loopend.predecessor().replaceFirstSuccessor(loopend, null);
loopend.safeDelete();
}
begin.removeExits();
FixedNode loopBody = begin.next();
if (loopBody != null) { // for small infinite loops, the body may be killed while
// killing the loop ends
killCFG(loopBody);
}
begin.safeDelete();
} else if (merge instanceof LoopBeginNode
&& ((LoopBeginNode) merge).loopEnds().isEmpty()) { // not
// a
// loop
// anymore
graph.reduceDegenerateLoopBegin((LoopBeginNode) merge);
} else if (merge.phiPredecessorCount() == 1) { // not a merge anymore
graph.reduceTrivialMerge(merge);
}
}
}
public void removeSplitPropagate(
ControlSplitNode node, AbstractBeginNode survivingSuccessor, SimplifierTool tool) {
assert node != null;
assert node.hasNoUsages();
assert survivingSuccessor != null;
List<Node> snapshot = node.successors().snapshot();
node.clearSuccessors();
node.replaceAtPredecessor(survivingSuccessor);
node.safeDelete();
for (Node successor : snapshot) {
if (successor != null && successor.isAlive()) {
if (successor != survivingSuccessor) {
GraphUtil.killCFG(successor, tool);
}
}
}
}
public static void killCFG(FixedNode node) {
assert node.isAlive();
if (node instanceof AbstractEndNode) {
// We reached a control flow end.
AbstractEndNode end = (AbstractEndNode) node;
killEnd(end);
} else {
// Normal control flow node.
/*
* We do not take a successor snapshot because this iterator supports concurrent
* modifications as long as they do not change the size of the successor list. Not
* taking a snapshot allows us to see modifications to other branches that may happen
* while processing one branch.
*/
for (Node successor : node.successors()) {
killCFG((FixedNode) successor);
}
}
propagateKill(node);
}
private void visitDeoptBegin(
AbstractBeginNode deoptBegin,
DeoptimizationAction deoptAction,
DeoptimizationReason deoptReason,
JavaConstant speculation,
StructuredGraph graph) {
if (deoptBegin.predecessor() instanceof AbstractBeginNode) {
/* Walk up chains of LoopExitNodes to the "real" BeginNode that leads to deoptimization. */
visitDeoptBegin(
(AbstractBeginNode) deoptBegin.predecessor(),
deoptAction,
deoptReason,
speculation,
graph);
return;
}
if (deoptBegin instanceof AbstractMergeNode) {
AbstractMergeNode mergeNode = (AbstractMergeNode) deoptBegin;
Debug.log("Visiting %s", mergeNode);
FixedNode next = mergeNode.next();
while (mergeNode.isAlive()) {
AbstractEndNode end = mergeNode.forwardEnds().first();
AbstractBeginNode newBeginNode = findBeginNode(end);
visitDeoptBegin(newBeginNode, deoptAction, deoptReason, speculation, graph);
}
assert next.isAlive();
AbstractBeginNode newBeginNode = findBeginNode(next);
visitDeoptBegin(newBeginNode, deoptAction, deoptReason, speculation, graph);
return;
} else if (deoptBegin.predecessor() instanceof IfNode) {
IfNode ifNode = (IfNode) deoptBegin.predecessor();
AbstractBeginNode otherBegin = ifNode.trueSuccessor();
LogicNode conditionNode = ifNode.condition();
FixedGuardNode guard =
graph.add(
new FixedGuardNode(
conditionNode,
deoptReason,
deoptAction,
speculation,
deoptBegin == ifNode.trueSuccessor()));
FixedWithNextNode pred = (FixedWithNextNode) ifNode.predecessor();
AbstractBeginNode survivingSuccessor;
if (deoptBegin == ifNode.trueSuccessor()) {
survivingSuccessor = ifNode.falseSuccessor();
} else {
survivingSuccessor = ifNode.trueSuccessor();
}
graph.removeSplitPropagate(ifNode, survivingSuccessor);
Node newGuard = guard;
if (survivingSuccessor instanceof LoopExitNode) {
newGuard = ProxyNode.forGuard(guard, (LoopExitNode) survivingSuccessor, graph);
}
survivingSuccessor.replaceAtUsages(InputType.Guard, newGuard);
Debug.log(
"Converting deopt on %-5s branch of %s to guard for remaining branch %s.",
deoptBegin == ifNode.trueSuccessor() ? "true" : "false", ifNode, otherBegin);
FixedNode next = pred.next();
pred.setNext(guard);
guard.setNext(next);
survivingSuccessor.simplify(simplifierTool);
return;
}
// We could not convert the control split - at least cut off control flow after the split.
FixedWithNextNode deoptPred = deoptBegin;
FixedNode next = deoptPred.next();
if (!(next instanceof DeoptimizeNode)) {
DeoptimizeNode newDeoptNode =
graph.add(new DeoptimizeNode(deoptAction, deoptReason, speculation));
deoptPred.setNext(newDeoptNode);
assert deoptPred == newDeoptNode.predecessor();
GraphUtil.killCFG(next);
}
}
public static void killCFG(Node node) {
killCFG(node, null);
}
public void deleteBranch(Node branch) {
branch.predecessor().replaceFirstSuccessor(branch, null);
GraphUtil.killCFG(branch, this);
}