truffle: graal/GraalCompiler/src/com/sun/c1x/graph/BlockMap.java comparison

comparison graal/GraalCompiler/src/com/sun/c1x/graph/BlockMap.java @ 2773:27512ea6bbcb

exception dispatch simplification: * BlockMap creates exception dispatch blocks (so they're iterated in the right order) * GraphBuilder uses exception dispatch blocks, simplified handleException, removed updateDispatchChain * simplified mergeOrClone * removed successor & predecessor methods from BlockBegin

author	Lukas Stadler <lukas.stadler@jku.at>
date	Tue, 24 May 2011 12:07:17 +0200
parents	49a8790b85a2
children	706047ee5f2e

comparison

equal deleted inserted replaced

-:3e3338a1abb9
+:27512ea6bbcb
 public boolean isLoopHeader;
 public int blockID;
 public Instruction firstInstruction;
-private Block[] successors;
+final HashSet<Block> successors = new HashSet<Block>();
 private boolean visited;
 private boolean active;
 private int loops;
+}
+public static class ExceptionBlock  extends Block {
+public RiExceptionHandler handler;
+public Block next;
+public Block handlerBlock;
 }
 private static final Block[] NO_SUCCESSORS = new Block[0];
 /**
 private Block makeBlock(int startBci) {
 Block oldBlock = blockMap[startBci];
 if (oldBlock == null) {
 Block newBlock = new Block();
 newBlock.startBci = startBci;
-newBlock.successors = NO_SUCCESSORS;
 blockMap[startBci] = newBlock;
 return newBlock;
 } else if (oldBlock.startBci != startBci) {
 // Backward branch into the middle of an already processed block.
 // Add the correct fall-through successor.
 Block newBlock = new Block();
 newBlock.startBci = startBci;
 newBlock.endBci = oldBlock.endBci;
-newBlock.successors = oldBlock.successors;
+newBlock.successors.addAll(oldBlock.successors);
 oldBlock.endBci = startBci - 1;
-oldBlock.successors = new Block[] {newBlock };
+oldBlock.successors.clear();
+oldBlock.successors.add(newBlock);
 for (int i = startBci; i <= newBlock.endBci; i++) {
 blockMap[i] = newBlock;
 }
 return newBlock;
 if (sux.isExceptionEntry) {
 throw new CiBailout("Exception handler can be reached by both normal and exceptional control flow");
 }
 }
 Block predecessor = blockMap[predBci];
-assert predecessor.successors.length == 0;
+assert predecessor.successors.size() == 0;
-predecessor.successors = successors;
+predecessor.successors.addAll(Arrays.asList(successors));
+}
+private HashMap<RiExceptionHandler, ExceptionBlock> exceptionDispatch = new HashMap<RiExceptionHandler, ExceptionBlock>();
+private ExceptionBlock unwindBlock;
+private ExceptionBlock makeUnwind() {
+if (unwindBlock == null) {
+unwindBlock = new ExceptionBlock();
+unwindBlock.startBci = -1;
+unwindBlock.endBci = -1;
+}
+return unwindBlock;
+}
+private Block makeExceptionDispatch(List<RiExceptionHandler> handlers, int index) {
+RiExceptionHandler handler = handlers.get(index);
+if (handler.isCatchAll()) {
+return blockMap[handler.handlerBCI()];
+}
+ExceptionBlock block = exceptionDispatch.get(handler);
+if (block == null) {
+block = new ExceptionBlock();
+block.startBci = -1;
+block.endBci = -1;
+block.handler = handler;
+block.successors.add(blockMap[handler.handlerBCI()]);
+block.handlerBlock = blockMap[handler.handlerBCI()];
+Block next;
+if (index < handlers.size() - 1) {
+next = makeExceptionDispatch(handlers, index + 1);
+} else {
+next = makeUnwind();
+}
+block.successors.add(next);
+block.next = next;
+exceptionDispatch.put(handler, block);
+}
+return block;
 }
 private void addExceptionEdges() {
 if (canTrap == null) {
 return;
 }
-Block block = null;
-HashSet<Block> newSuccessorsOfBlock = new HashSet<Block>();
 for (int bci = canTrap.nextSetBit(0); bci >= 0; bci = canTrap.nextSetBit(bci + 1)) {
-Block newBlock = blockMap[bci];
+Block block = blockMap[bci];
-if (newBlock != block) {
-if (block != null) {
+ArrayList<RiExceptionHandler> handlers = null;
-block.successors = newSuccessorsOfBlock.toArray(new Block[newSuccessorsOfBlock.size()]);
-newSuccessorsOfBlock.clear();
-}
-Collections.addAll(newSuccessorsOfBlock, newBlock.successors);
-}
-block = newBlock;
 for (RiExceptionHandler h : method.exceptionHandlers()) {
 if (h.startBCI() <= bci && bci < h.endBCI()) {
-newSuccessorsOfBlock.add(blockMap[h.handlerBCI()]);
+if (handlers == null) {
+handlers = new ArrayList<RiExceptionHandler>();
+}
+handlers.add(h);
 if (h.isCatchAll()) {
 break;
 }
 }
 }
-}
+if (handlers != null) {
-if (block != null) {
+Block dispatch = makeExceptionDispatch(handlers, 0);
-block.successors = newSuccessorsOfBlock.toArray(new Block[newSuccessorsOfBlock.size()]);
+block.successors.add(dispatch);
+}
 }
 }
 private void computeBlockOrder() {
 int loop = computeBlockOrder(blockMap[0]);
 private void processLoopBlock(Block block) {
 // process all the stores in this block
 byte[] code = method.code();
 int bci = block.startBci;
-while (bci <= block.endBci) {
+if (bci >= 0) {
-int opcode = Bytes.beU1(code, bci);
+while (bci <= block.endBci) {
-if (isStore(opcode)) {
+int opcode = Bytes.beU1(code, bci);
-processStore(opcode, Bytes.beU1(code, bci + 1));
-} else if (opcode == WIDE) {
-opcode = Bytes.beU1(code, bci + 1);
 if (isStore(opcode)) {
-processStore(opcode, Bytes.beU2(code, bci + 2));
+processStore(opcode, Bytes.beU1(code, bci + 1));
-}
-}
+} else if (opcode == WIDE) {
-bci += lengthOf(code, bci);
+opcode = Bytes.beU1(code, bci + 1);
+if (isStore(opcode)) {
+processStore(opcode, Bytes.beU2(code, bci + 2));
+}
+}
+bci += lengthOf(code, bci);
+}
 }
 }
 private void processStore(int opcode, int local) {
 switch (opcode) {

Mercurial > hg > truffle

comparison graal/GraalCompiler/src/com/sun/c1x/graph/BlockMap.java @ 2773:27512ea6bbcb