private void processFixedGuardAndMerge(
FixedGuardNode fixedGuard,
PhaseContext context,
CompareNode compare,
ValueNode x,
ValuePhiNode xPhi,
ValueNode y,
ValuePhiNode yPhi,
AbstractMergeNode merge) {
List<EndNode> mergePredecessors = merge.cfgPredecessors().snapshot();
for (int i = 0; i < mergePredecessors.size(); ++i) {
AbstractEndNode mergePredecessor = mergePredecessors.get(i);
if (!mergePredecessor.isAlive()) {
break;
}
Constant xs;
if (xPhi == null) {
xs = x.asConstant();
} else {
xs = xPhi.valueAt(mergePredecessor).asConstant();
}
Constant ys;
if (yPhi == null) {
ys = y.asConstant();
} else {
ys = yPhi.valueAt(mergePredecessor).asConstant();
}
if (xs != null
&& ys != null
&& compare
.condition()
.foldCondition(xs, ys, context.getConstantReflection(), compare.unorderedIsTrue())
== fixedGuard.isNegated()) {
visitDeoptBegin(
AbstractBeginNode.prevBegin(mergePredecessor),
fixedGuard.getAction(),
fixedGuard.getReason(),
fixedGuard.getSpeculation(),
fixedGuard.graph());
}
}
}
@Override
protected void run(final StructuredGraph graph, PhaseContext context) {
assert graph.hasValueProxies() : "ConvertDeoptimizeToGuardPhase always creates proxies";
if (graph.getNodes(DeoptimizeNode.TYPE).isEmpty()) {
return;
}
for (DeoptimizeNode d : graph.getNodes(DeoptimizeNode.TYPE)) {
assert d.isAlive();
visitDeoptBegin(
AbstractBeginNode.prevBegin(d), d.action(), d.reason(), d.getSpeculation(), graph);
}
if (context != null) {
for (FixedGuardNode fixedGuard : graph.getNodes(FixedGuardNode.TYPE)) {
trySplitFixedGuard(fixedGuard, context);
}
}
new DeadCodeEliminationPhase(Optional).apply(graph);
}
private void processFixedGuardAndPhis(
FixedGuardNode fixedGuard,
PhaseContext context,
CompareNode compare,
ValueNode x,
ValuePhiNode xPhi,
ValueNode y,
ValuePhiNode yPhi) {
AbstractBeginNode pred = AbstractBeginNode.prevBegin(fixedGuard);
if (pred instanceof AbstractMergeNode) {
AbstractMergeNode merge = (AbstractMergeNode) pred;
if (xPhi != null && xPhi.merge() != merge) {
return;
}
if (yPhi != null && yPhi.merge() != merge) {
return;
}
processFixedGuardAndMerge(fixedGuard, context, compare, x, xPhi, y, yPhi, merge);
}
}
@SuppressWarnings("try")
private AnchoringNode process(
final Block b, final NodeBitMap activeGuards, final AnchoringNode startAnchor) {
final LoweringToolImpl loweringTool =
new LoweringToolImpl(context, startAnchor, activeGuards, b.getBeginNode());
// Lower the instructions of this block.
List<Node> nodes = schedule.nodesFor(b);
for (Node node : nodes) {
if (node.isDeleted()) {
// This case can happen when previous lowerings deleted nodes.
continue;
}
// Cache the next node to be able to reconstruct the previous of the next node
// after lowering.
FixedNode nextNode = null;
if (node instanceof FixedWithNextNode) {
nextNode = ((FixedWithNextNode) node).next();
} else {
nextNode = loweringTool.lastFixedNode().next();
}
if (node instanceof Lowerable) {
Collection<Node> unscheduledUsages = null;
assert (unscheduledUsages = getUnscheduledUsages(node)) != null;
Mark preLoweringMark = node.graph().getMark();
try (DebugCloseable s = node.graph().withNodeContext(node)) {
((Lowerable) node).lower(loweringTool);
}
if (loweringTool.guardAnchor.asNode().isDeleted()) {
// TODO nextNode could be deleted but this is not currently supported
assert nextNode.isAlive();
loweringTool.guardAnchor = AbstractBeginNode.prevBegin(nextNode);
}
assert checkPostNodeLowering(node, loweringTool, preLoweringMark, unscheduledUsages);
}
if (!nextNode.isAlive()) {
// can happen when the rest of the block is killed by lowering
// (e.g. by an unconditional deopt)
break;
} else {
Node nextLastFixed = nextNode.predecessor();
if (!(nextLastFixed instanceof FixedWithNextNode)) {
// insert begin node, to have a valid last fixed for next lowerable node.
// This is about lowering a FixedWithNextNode to a control split while this
// 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.
AbstractBeginNode begin = node.graph().add(new BeginNode());
nextLastFixed.replaceFirstSuccessor(nextNode, begin);
begin.setNext(nextNode);
nextLastFixed = begin;
}
loweringTool.setLastFixedNode((FixedWithNextNode) nextLastFixed);
}
}
return loweringTool.getCurrentGuardAnchor();
}
