private static void processStackProxy(NodeStack stack, ProxyNode proxyNode) {
LoopExitNode proxyPoint = proxyNode.proxyPoint();
for (Node input : proxyNode.inputs()) {
if (input != proxyPoint) {
stack.push(input);
}
}
}
private static void processStackPhi(NodeStack stack, PhiNode phiNode) {
AbstractMergeNode merge = phiNode.merge();
for (int i = 0; i < merge.forwardEndCount(); ++i) {
Node input = phiNode.valueAt(i);
if (input != null) {
stack.push(input);
}
}
}
private static void processStackFrameState(NodeStack stack, Node current) {
for (Node input : current.inputs()) {
if (input instanceof StateSplit && ((StateSplit) input).stateAfter() == current) {
// Ignore the cycle.
} else {
stack.push(input);
}
}
}
private static void processStack(
ControlFlowGraph cfg,
BlockMap<List<Node>> blockToNodes,
NodeMap<Block> nodeToBlock,
NodeBitMap visited,
BitSet floatingReads,
NodeStack stack) {
Block startBlock = cfg.getStartBlock();
while (!stack.isEmpty()) {
Node current = stack.peek();
if (visited.checkAndMarkInc(current)) {
// Push inputs and predecessor.
Node predecessor = current.predecessor();
if (predecessor != null) {
stack.push(predecessor);
}
if (current instanceof PhiNode) {
processStackPhi(stack, (PhiNode) current);
} else if (current instanceof ProxyNode) {
processStackProxy(stack, (ProxyNode) current);
} else if (current instanceof FrameState) {
processStackFrameState(stack, current);
} else {
current.pushInputs(stack);
}
} else {
stack.pop();
if (nodeToBlock.get(current) == null) {
Block curBlock = cfg.blockFor(current);
if (curBlock == null) {
assert current.predecessor() == null && !(current instanceof FixedNode)
: "The assignment of blocks to fixed nodes is already done when constructing the cfg.";
Block earliest = startBlock;
for (Node input : current.inputs()) {
Block inputEarliest = nodeToBlock.get(input);
if (inputEarliest == null) {
assert current instanceof FrameState
&& input instanceof StateSplit
&& ((StateSplit) input).stateAfter() == current
: current;
} else {
assert inputEarliest != null;
if (inputEarliest.getEndNode() == input) {
// This is the last node of the block.
if (current instanceof FrameState
&& input instanceof StateSplit
&& ((StateSplit) input).stateAfter() == current) {
// Keep regular inputEarliest.
} else if (input instanceof ControlSplitNode) {
inputEarliest =
nodeToBlock.get(((ControlSplitNode) input).getPrimarySuccessor());
} else {
assert inputEarliest.getSuccessorCount() == 1;
assert !(input instanceof AbstractEndNode);
// Keep regular inputEarliest
}
}
if (earliest.getDominatorDepth() < inputEarliest.getDominatorDepth()) {
earliest = inputEarliest;
}
}
}
curBlock = earliest;
}
assert curBlock != null;
addNode(blockToNodes, curBlock, current);
nodeToBlock.set(current, curBlock);
if (current instanceof FloatingReadNode) {
FloatingReadNode floatingReadNode = (FloatingReadNode) current;
if (curBlock.canKill(floatingReadNode.getLocationIdentity())) {
floatingReads.set(curBlock.getId());
}
}
}
}
}
}
private void scheduleEarliestIterative(
BlockMap<List<Node>> blockToNodes,
NodeMap<Block> nodeToBlock,
NodeBitMap visited,
StructuredGraph graph,
boolean immutableGraph) {
BitSet floatingReads = new BitSet(cfg.getBlocks().length);
// Add begin nodes as the first entry and set the block for phi nodes.
for (Block b : cfg.getBlocks()) {
AbstractBeginNode beginNode = b.getBeginNode();
ArrayList<Node> nodes = new ArrayList<>();
nodeToBlock.set(beginNode, b);
nodes.add(beginNode);
blockToNodes.put(b, nodes);
if (beginNode instanceof AbstractMergeNode) {
AbstractMergeNode mergeNode = (AbstractMergeNode) beginNode;
for (PhiNode phi : mergeNode.phis()) {
nodeToBlock.set(phi, b);
}
} else if (beginNode instanceof LoopExitNode) {
LoopExitNode loopExitNode = (LoopExitNode) beginNode;
for (ProxyNode proxy : loopExitNode.proxies()) {
nodeToBlock.set(proxy, b);
}
}
}
NodeStack stack = new NodeStack();
// Start analysis with control flow ends.
Block[] reversePostOrder = cfg.reversePostOrder();
for (int j = reversePostOrder.length - 1; j >= 0; --j) {
Block b = reversePostOrder[j];
FixedNode endNode = b.getEndNode();
if (isFixedEnd(endNode)) {
stack.push(endNode);
nodeToBlock.set(endNode, b);
}
}
processStack(cfg, blockToNodes, nodeToBlock, visited, floatingReads, stack);
// Visit back input edges of loop phis.
boolean changed;
boolean unmarkedPhi;
do {
changed = false;
unmarkedPhi = false;
for (LoopBeginNode loopBegin : graph.getNodes(LoopBeginNode.TYPE)) {
for (PhiNode phi : loopBegin.phis()) {
if (visited.isMarked(phi)) {
for (int i = 0; i < loopBegin.getLoopEndCount(); ++i) {
Node node = phi.valueAt(i + loopBegin.forwardEndCount());
if (node != null && !visited.isMarked(node)) {
changed = true;
stack.push(node);
processStack(cfg, blockToNodes, nodeToBlock, visited, floatingReads, stack);
}
}
} else {
unmarkedPhi = true;
}
}
}
/*
* the processing of one loop phi could have marked a previously checked loop phi,
* therefore this needs to be iterative.
*/
} while (unmarkedPhi && changed);
// Check for dead nodes.
if (!immutableGraph && visited.getCounter() < graph.getNodeCount()) {
for (Node n : graph.getNodes()) {
if (!visited.isMarked(n)) {
n.clearInputs();
n.markDeleted();
}
}
}
// Add end nodes as the last nodes in each block.
for (Block b : cfg.getBlocks()) {
FixedNode endNode = b.getEndNode();
if (isFixedEnd(endNode)) {
if (endNode != b.getBeginNode()) {
addNode(blockToNodes, b, endNode);
}
}
}
if (!floatingReads.isEmpty()) {
for (Block b : cfg.getBlocks()) {
if (floatingReads.get(b.getId())) {
resortEarliestWithinBlock(b, blockToNodes, nodeToBlock, visited);
}
}
}
assert MemoryScheduleVerification.check(cfg.getStartBlock(), blockToNodes);
}
