graal-compiler: graal/GraalCompiler/src/com/sun/c1x/ir/ComputeLinearScanOrder.java comparison

comparison graal/GraalCompiler/src/com/sun/c1x/ir/ComputeLinearScanOrder.java @ 2707:7ed72769d51a

exception handling related changes: * changed blockPredecessors to list of Instructions, instead of Blocks * removed explicit predecessor management in BlockBegin, now using predecessors from Graph structure * replaced generated LIR exception entries with exception dispatch chains in IR * added Unwind and ExceptionDispatch instructions * removed ExceptionEntry flag in BlockBegin and all code depending on it * removed exceptionHandler list from Instruction, replaced by exception Edge on Invoke and Throw * replaced list of ExceptionHandlers with single exception edge in debug info misc: * changed GraphvizPrinter layout (smaller ports on large nodes) * removed defunct run config

author	Lukas Stadler <lukas.stadler@jku.at>
date	Wed, 18 May 2011 18:09:20 +0200
parents	6ab73784566a
children	4272b7af2d17

comparison

equal deleted inserted replaced

-:0ea5f12e873a
+:7ed72769d51a
 * 1. Count of total number of blocks.
 * 2. Count of all incoming edges and backward incoming edges.
 * 3. Number loop header blocks.
 * 4. Create a list with all loop end blocks.
 */
-private void countEdges(BlockBegin cur, BlockBegin parent) {
+private void countEdges(final BlockBegin cur, BlockBegin parent) {
 if (C1XOptions.TraceLinearScanLevel >= 3) {
 TTY.println("Counting edges for block B%d%s", cur.blockID, parent == null ? "" : " coming from B" + parent.blockID);
 }
 assert cur.dominator() == null : "dominator already initialized";
 cur.setBlockFlag(BlockBegin.BlockFlag.LinearScanLoopHeader);
 cur.setBlockFlag(BlockBegin.BlockFlag.BackwardBranchTarget);
 parent.setBlockFlag(BlockBegin.BlockFlag.LinearScanLoopEnd);
-// When a loop header is also the start of an exception handler, then the backward branch is
-// an exception edge. Because such edges are usually critical edges which cannot be split, the
-// loop must be excluded here from processing.
-if (cur.checkBlockFlag(BlockBegin.BlockFlag.ExceptionEntry)) {
-// Make sure that dominators are correct in this weird situation
-iterativeDominators = true;
-return;
-}
 loopEndBlocks.add(parent);
 return;
 }
 // increment number of incoming forward branches
 numBlocks++;
 setVisited(cur);
 setActive(cur);
 // recursive call for all successors
-int i;
+cur.allSuccessorsDo(true, new BlockClosure() {
-for (i = cur.numberOfSux() - 1; i >= 0; i--) {
+public void apply(BlockBegin block) {
-countEdges(cur.suxAt(i), cur);
+countEdges(block, cur);
 }
-for (i = cur.numberOfExceptionHandlers() - 1; i >= 0; i--) {
+});
-countEdges(cur.exceptionHandlerAt(i), cur);
-}
 clearActive(cur);
 // Each loop has a unique number.
 // When multiple loops are nested, assignLoopDepth assumes that the
 assert isBlockInLoop(loopIdx, cur) : "bit in loop map must be set when block is in work list";
 // recursive processing of all predecessors ends when start block of loop is reached
 if (cur != loopStart) {
 for (int j = cur.numberOfPreds() - 1; j >= 0; j--) {
-BlockBegin pred = cur.predAt(j).begin();
+BlockBegin pred = cur.predAt(j).block();
 if (!isBlockInLoop(loopIdx, pred)) {
 // this predecessor has not been processed yet, so add it to work list
 if (C1XOptions.TraceLinearScanLevel >= 3) {
 TTY.println("    pushing B%d", pred.blockID);
 }
 cur.setLoopDepth(loopDepth);
 cur.setLoopIndex(minLoopIdx);
 // append all unvisited successors to work list
-for (i = cur.numberOfSux() - 1; i >= 0; i--) {
+cur.allSuccessorsDo(true, new BlockClosure() {
-workList.add(cur.suxAt(i));
+public void apply(BlockBegin block) {
-}
+workList.add(block);
-for (i = cur.numberOfExceptionHandlers() - 1; i >= 0; i--) {
+}
-workList.add(cur.exceptionHandlerAt(i));
+});
-}
 }
 } while (!workList.isEmpty());
 }
 private BlockBegin commonDominator(BlockBegin a, BlockBegin b) {
 private void computeDominator(BlockBegin cur, BlockBegin parent) {
 if (cur.dominator() == null) {
 if (C1XOptions.TraceLinearScanLevel >= 4) {
 TTY.println("DOM: initializing dominator of B%d to B%d", cur.blockID, parent.blockID);
 }
-if (cur.isExceptionEntry()) {
+cur.setDominator(parent);
-assert parent.dominator() != null;
-cur.setDominator(parent.dominator());
-} else {
-cur.setDominator(parent);
-}
 } else if (!(cur.checkBlockFlag(BlockBegin.BlockFlag.LinearScanLoopHeader) && parent.checkBlockFlag(BlockBegin.BlockFlag.LinearScanLoopEnd))) {
 if (C1XOptions.TraceLinearScanLevel >= 4) {
 TTY.println("DOM: computing dominator of B%d: common dominator of B%d and B%d is B%d", cur.blockID, parent.blockID, cur.dominator().blockID, commonDominator(cur.dominator(), parent).blockID);
 }
 if (!(cur.end() instanceof Return) && (singleSux == null || !(singleSux.end() instanceof Return))) {
 weight |= (1 << curBit);
 }
 curBit--;
-// exceptions handlers are added as late as possible
+//        // exceptions handlers are added as late as possible
-if (!cur.checkBlockFlag(BlockBegin.BlockFlag.ExceptionEntry)) {
+//        if (!cur.checkBlockFlag(BlockBegin.BlockFlag.ExceptionEntry)) {
-weight |= (1 << curBit);
+//            weight |= (1 << curBit);
-}
+//        }
 curBit--;
 // guarantee that weight is > 0
 weight |= 1;
 } else {
 throw new CiBailout("the stdEntry must be ready for processing (otherwise, the method has no start block)");
 }
 do {
-BlockBegin cur = workList.remove(workList.size() - 1);
+final BlockBegin cur = workList.remove(workList.size() - 1);
 appendBlock(cur);
-int i;
+cur.allSuccessorsDo(false, new BlockClosure() {
-int numSux = cur.numberOfSux();
+public void apply(BlockBegin block) {
-// changed loop order to get "intuitive" order of if- and else-blocks
+computeDominator(block, cur);
-for (i = 0; i < numSux; i++) {
+if (readyForProcessing(block)) {
-BlockBegin sux = cur.suxAt(i);
+sortIntoWorkList(block);
-computeDominator(sux, cur);
+}
-if (readyForProcessing(sux)) {
+}
-sortIntoWorkList(sux);
+});
-}
-}
-numSux = cur.numberOfExceptionHandlers();
-for (i = 0; i < numSux; i++) {
-BlockBegin sux = cur.exceptionHandlerAt(i);
-computeDominator(sux, cur);
-if (readyForProcessing(sux)) {
-sortIntoWorkList(sux);
-}
-}
 } while (workList.size() > 0);
 }
 private boolean computeDominatorsIter() {
 boolean changed = false;
 assert linearScanOrder.get(0).numberOfPreds() == 0 : "must not have predecessors";
 for (int i = 1; i < numBlocks; i++) {
 BlockBegin block = linearScanOrder.get(i);
 assert block.numberOfPreds() > 0;
-BlockBegin dominator = block.predAt(0).begin();
+BlockBegin dominator = block.predAt(0).block();
-if (block.isExceptionEntry()) {
-dominator = dominator.dominator();
-}
 int numPreds = block.numberOfPreds();
 for (int j = 1; j < numPreds; j++) {
-BlockBegin curPred = block.predAt(j).begin();
+BlockBegin curPred = block.predAt(j).block();
-if (block.isExceptionEntry()) {
-curPred = curPred.dominator();
-}
 dominator = commonDominator(dominator, curPred);
 }
 if (dominator != block.dominator()) {
 if (C1XOptions.TraceLinearScanLevel >= 4) {
 if (C1XOptions.TraceLinearScanLevel >= 1) {
 TTY.println("----- linear-scan block order:");
 for (BlockBegin cur : linearScanOrder) {
 TTY.print(String.format("%4d: B%02d    loop: %2d  depth: %2d", cur.linearScanNumber(), cur.blockID, cur.loopIndex(), cur.loopDepth()));
-TTY.print(cur.isExceptionEntry() ? " ex" : "   ");
 TTY.print(cur.isCriticalEdgeSplit() ? " ce" : "   ");
 TTY.print(cur.checkBlockFlag(BlockBegin.BlockFlag.LinearScanLoopHeader) ? " lh" : "   ");
 TTY.print(cur.checkBlockFlag(BlockBegin.BlockFlag.LinearScanLoopEnd) ? " le" : "   ");
 if (cur.dominator() != null) {
 }
 if (cur.numberOfPreds() > 0) {
 TTY.print("    preds: ");
 for (int j = 0; j < cur.numberOfPreds(); j++) {
-BlockBegin pred = cur.predAt(j).begin();
+BlockBegin pred = cur.predAt(j).block();
 TTY.print("B%d ", pred.blockID);
 }
 }
 if (cur.numberOfSux() > 0) {
 TTY.print("    sux: ");
 for (int j = 0; j < cur.numberOfSux(); j++) {
 BlockBegin sux = cur.suxAt(j);
 TTY.print("B%d ", sux.blockID);
 }
 }
-if (cur.numberOfExceptionHandlers() > 0) {
-TTY.print("    ex: ");
-for (int j = 0; j < cur.numberOfExceptionHandlers(); j++) {
-BlockBegin ex = cur.exceptionHandlerAt(j);
-TTY.print("B%d ", ex.blockID);
-}
-}
 TTY.println();
 }
 }
 }
 if (cur.loopDepth() == sux.loopDepth()) {
 assert cur.loopIndex() == sux.loopIndex() || sux.checkBlockFlag(BlockBegin.BlockFlag.LinearScanLoopHeader) : "successing blocks with same loop depth must have same loop index";
 }
 }
-for (BlockEnd pred : cur.blockPredecessors()) {
+for (Instruction pred : cur.blockPredecessors()) {
-BlockBegin begin = pred.begin();
+BlockBegin begin = pred.block();
 assert begin.linearScanNumber() >= 0 && begin.linearScanNumber() == linearScanOrder.indexOf(begin) : "incorrect linearScanNumber";
 if (!cur.checkBlockFlag(BlockBegin.BlockFlag.LinearScanLoopHeader)) {
 assert cur.linearScanNumber() > begin.linearScanNumber() : "invalid order";
 }
 if (cur.loopDepth() == begin.loopDepth()) {
 if (i == 0) {
 assert cur.dominator() == null : "first block has no dominator";
 } else {
 assert cur.dominator() != null : "all but first block must have dominator";
 }
-assert cur.numberOfPreds() != 1 || cur.dominator() == cur.predAt(0).begin() || cur.isExceptionEntry() : "Single predecessor must also be dominator";
+assert cur.numberOfPreds() != 1 || cur.dominator() == cur.predAt(0).block() : "Single predecessor must also be dominator";
 }
 // check that all loops are continuous
 for (int loopIdx = 0; loopIdx < numLoops; loopIdx++) {
 int blockIdx = 0;

Mercurial > hg > graal-compiler

comparison graal/GraalCompiler/src/com/sun/c1x/ir/ComputeLinearScanOrder.java @ 2707:7ed72769d51a