use of org.graalvm.compiler.nodes.FixedNode in project graal by oracle.
the class ScopedPostOrderNodeIterator method processScope.
public void processScope() {
FixedNode current;
queue(currentScopeStart);
while ((current = nextQueuedNode()) != null) {
assert current.isAlive();
if (current instanceof Invoke) {
invoke((Invoke) current);
queueSuccessors(current);
} else if (current instanceof LoopBeginNode) {
queueLoopBeginSuccessors((LoopBeginNode) current);
} else if (current instanceof LoopExitNode) {
queueLoopExitSuccessors((LoopExitNode) current);
} else if (current instanceof LoopEndNode) {
// nothing todo
} else if (current instanceof AbstractMergeNode) {
queueSuccessors(current);
} else if (current instanceof FixedWithNextNode) {
queueSuccessors(current);
} else if (current instanceof EndNode) {
queueMerge((EndNode) current);
} else if (current instanceof ControlSinkNode) {
// nothing todo
} else if (current instanceof ControlSplitNode) {
queueSuccessors(current);
} else {
assert false : current;
}
}
}
use of org.graalvm.compiler.nodes.FixedNode in project graal by oracle.
the class SinglePassNodeIterator method queueSuccessors.
/**
* Two methods enqueue items in {@link #nodeQueue}. Of them, only this method enqueues items
* with non-null state (the other method being {@link #queueMerge(EndNode)}).
*
* <p>
* A space optimization is made: the state is cloned for all successors except the first. Given
* that right after invoking this method, {@link #nextQueuedNode()} is invoked, that single
* non-cloned state instance is in effect "handed over" to its next owner (thus realizing an
* owner-is-mutator access protocol).
* </p>
*/
private void queueSuccessors(FixedNode x) {
T startState = state;
T curState = startState;
for (Node succ : x.successors()) {
if (succ != null) {
if (curState == null) {
// the current state isn't cloned for the first successor
// conceptually, the state is handed over to it
curState = startState.clone();
}
AbstractBeginNode begin = (AbstractBeginNode) succ;
nodeQueue.addFirst(new PathStart<>(begin, curState));
}
}
}
use of org.graalvm.compiler.nodes.FixedNode in project graal by oracle.
the class SinglePassNodeIterator method apply.
/**
* Performs a single-pass iteration.
*
* <p>
* After this method has been invoked, the {@link SinglePassNodeIterator} instance can't be used
* again. This saves clearing up fields in {@link #finished()}, the assumption being that this
* instance will be garbage-collected soon afterwards.
* </p>
*/
public void apply() {
FixedNode current = start;
do {
if (current instanceof InvokeWithExceptionNode) {
invoke((Invoke) current);
queueSuccessors(current);
current = nextQueuedNode();
} else if (current instanceof LoopBeginNode) {
state.loopBegin((LoopBeginNode) current);
keepForLater(current, state);
state = state.clone();
loopBegin((LoopBeginNode) current);
current = ((LoopBeginNode) current).next();
assert current != null;
} else if (current instanceof LoopEndNode) {
loopEnd((LoopEndNode) current);
finishLoopEnds((LoopEndNode) current);
current = nextQueuedNode();
} else if (current instanceof AbstractMergeNode) {
merge((AbstractMergeNode) current);
current = ((AbstractMergeNode) current).next();
assert current != null;
} else if (current instanceof FixedWithNextNode) {
FixedNode next = ((FixedWithNextNode) current).next();
assert next != null : current;
node(current);
current = next;
} else if (current instanceof EndNode) {
end((EndNode) current);
queueMerge((EndNode) current);
current = nextQueuedNode();
} else if (current instanceof ControlSinkNode) {
node(current);
current = nextQueuedNode();
} else if (current instanceof ControlSplitNode) {
controlSplit((ControlSplitNode) current);
queueSuccessors(current);
current = nextQueuedNode();
} else {
assert false : current;
}
} while (current != null);
finished();
}
use of org.graalvm.compiler.nodes.FixedNode in project graal by oracle.
the class StatelessPostOrderNodeIterator method apply.
public void apply() {
FixedNode current = start;
do {
if (current instanceof LoopBeginNode) {
loopBegin((LoopBeginNode) current);
current = ((LoopBeginNode) current).next();
assert current != null;
} else if (current instanceof LoopEndNode) {
loopEnd((LoopEndNode) current);
assert !visitedEnds.isMarked(current);
visitedEnds.mark(current);
current = nodeQueue.pollFirst();
} else if (current instanceof AbstractMergeNode) {
merge((AbstractMergeNode) current);
current = ((AbstractMergeNode) current).next();
assert current != null;
} else if (current instanceof FixedWithNextNode) {
node(current);
current = ((FixedWithNextNode) current).next();
} else if (current instanceof EndNode) {
end((EndNode) current);
queueMerge((EndNode) current);
current = nodeQueue.pollFirst();
} else if (current instanceof ControlSinkNode) {
node(current);
current = nodeQueue.pollFirst();
} else if (current instanceof ControlSplitNode) {
controlSplit((ControlSplitNode) current);
for (Node node : current.successors()) {
nodeQueue.addFirst((AbstractBeginNode) node);
}
current = nodeQueue.pollFirst();
} else {
assert false : current;
}
} while (current != null);
finished();
}
use of org.graalvm.compiler.nodes.FixedNode in project graal by oracle.
the class LockEliminationPhase method run.
@Override
protected void run(StructuredGraph graph) {
for (MonitorExitNode monitorExitNode : graph.getNodes(MonitorExitNode.TYPE)) {
FixedNode next = monitorExitNode.next();
if ((next instanceof MonitorEnterNode || next instanceof RawMonitorEnterNode)) {
// start
assert !(next instanceof OSRMonitorEnterNode);
AccessMonitorNode monitorEnterNode = (AccessMonitorNode) next;
if (GraphUtil.unproxify(monitorEnterNode.object()) == GraphUtil.unproxify(monitorExitNode.object())) {
/*
* We've coarsened the lock so use the same monitor id for the whole region,
* otherwise the monitor operations appear to be unrelated.
*/
MonitorIdNode enterId = monitorEnterNode.getMonitorId();
MonitorIdNode exitId = monitorExitNode.getMonitorId();
if (enterId != exitId) {
enterId.replaceAndDelete(exitId);
}
GraphUtil.removeFixedWithUnusedInputs(monitorEnterNode);
GraphUtil.removeFixedWithUnusedInputs(monitorExitNode);
}
}
}
}
Aggregations