/// <summary>
/// Compute a pre order (ignoring back edges) of the CFG reachable from the entry node
///
/// As a side effect, assigns each block its DF finishing number.
/// </summary>
public static FList/*<BasicBlocks>*/ Compute(ControlFlowGraph cfg) {
// depth-first search
bool[] markBit = new bool[cfg.BlockCount];
FList result = null;
int DFTime = 0;
// Use a stack to represent the state of the search.
// Each stack element consists of a basic block and the
// the index of the next successor of that block to process.
Stack stack = new Stack();
CfgBlock[] blocks = cfg.Blocks();
CfgBlock start = cfg.Entry;
// invariant: all blocks pushed on the stack are marked.
markBit[start.Index] = true;
stack.Push(new StackElem(start));
while (stack.Count > 0) {
StackElem elem = (StackElem) stack.Peek();
CfgBlock b = elem.node;
int nextChild = elem.nextChild;
CfgBlock[] normalNodes = cfg.NormalSucc(b);
CfgBlock[] exnNodes = cfg.ExcpSucc(b);
int normalNodesCount = normalNodes.Length;
int exnNodesCount = exnNodes.Length;
// Is there another child to process?
if (nextChild < normalNodesCount + exnNodesCount) {
// Figure out the actual block.
CfgBlock child;
if (nextChild < normalNodesCount) {
child = normalNodes[nextChild];
} else {
child = exnNodes[nextChild-normalNodesCount];
}
elem.nextChild = nextChild+1;
// push the child block on to the stack.
if (!markBit[child.Index]) {
markBit[child.Index]=true;
stack.Push(new StackElem(child));
}
} else {
// After all children are processed, place the block
// on the result.
stack.Pop();
b.priority = ++DFTime;
result = FList.Cons(b, result);
}
}
return result;
}
