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

comparison graal/GraalCompiler/src/com/sun/c1x/graph/GraphBuilder.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	056e392d63d4
children	93fd92c9f8b0

comparison

equal deleted inserted replaced

-:3e3338a1abb9
+:27512ea6bbcb
 import com.oracle.graal.graph.*;
 import com.sun.c1x.*;
 import com.sun.c1x.debug.*;
 import com.sun.c1x.graph.BlockMap.Block;
+import com.sun.c1x.graph.BlockMap.ExceptionBlock;
 import com.sun.c1x.ir.*;
 import com.sun.c1x.util.*;
 import com.sun.c1x.value.*;
 import com.sun.cri.bytecode.*;
 import com.sun.cri.ci.*;
 private final C1XCompilation compilation;
 private final CiStatistics stats;
 private final BytecodeStream stream;           // the bytecode stream
 // bci-to-block mapping
-private Block[] blockList;
+private Block[] blockFromBci;
+private ArrayList<Block> blockList;
 // the constant pool
 private final RiConstantPool constantPool;
 // the worklist of blocks, sorted by depth first number
 }
 // 2. compute the block map, setup exception handlers and get the entrypoint(s)
 BlockMap blockMap = compilation.getBlockMap(rootMethod);
-blockList = new Block[rootMethod.code().length];
+blockList = new ArrayList<Block>(blockMap.blocks);
-for (int i = 0; i < blockMap.blocks.size(); i++) {
+blockFromBci = new Block[rootMethod.code().length];
+for (int i = 0; i < blockList.size(); i++) {
 int blockID = ir.nextBlockNumber();
 assert blockID == i;
-Block block = blockMap.blocks.get(i);
+Block block = blockList.get(i);
-blockList[block.startBci] = block;
+if (block.startBci >= 0) {
+blockFromBci[block.startBci] = block;
+}
+//            System.out.println("block " + blockID + " @ " + block.startBci);
 }
 // 1. create the start block
 Block startBlock = nextBlock(Instruction.SYNCHRONIZATION_ENTRY_BCI);
 BlockBegin startBlockBegin = new BlockBegin(0, startBlock.blockID, false, graph);
 RiExceptionHandler[] handlers = rootMethod.exceptionHandlers();
 if (handlers != null && handlers.length > 0) {
 exceptionHandlers = new ArrayList<ExceptionHandler>(handlers.length);
 for (RiExceptionHandler ch : handlers) {
-Block entry = blockList[ch.handlerBCI()];
+Block entry = blockFromBci[ch.handlerBCI()];
 // entry == null means that the exception handler is unreachable according to the BlockMap conservative analysis
 if (entry != null) {
 ExceptionHandler h = new ExceptionHandler(ch);
 h.setEntryBlock(entry);
 exceptionHandlers.add(h);
 }
 }
 flags |= Flag.HasHandler.mask;
 }
-mergeOrClone(startBlockBegin, frameState, false);
+mergeOrClone(startBlock, frameState);
 // 3. setup internal state for appending instructions
 lastInstr = startBlockBegin;
 lastInstr.appendNext(null);
 syncBlock = nextBlock(Instruction.SYNCHRONIZATION_ENTRY_BCI);
 syncHandler = new BlockBegin(Instruction.SYNCHRONIZATION_ENTRY_BCI, syncBlock.blockID, false, graph);
 syncBlock.firstInstruction = syncHandler;
 markOnWorkList(syncBlock);
+ExceptionBlock excBlock = new ExceptionBlock();
+excBlock.startBci = -1;
+excBlock.endBci = -1;
+excBlock.blockID = ir.nextBlockNumber();
+blockList.add(excBlock);
 ExceptionHandler h = new ExceptionHandler(new CiExceptionHandler(0, rootMethod.code().length, -1, 0, null));
 h.setEntryBlock(syncBlock);
 addExceptionHandler(h);
 } else {
 // 4B.1 simply finish the start block
 }
 // 5. SKIPPED: look for intrinsics
 // 6B.1 do the normal parsing
-addToWorkList(blockList[0]);
+addToWorkList(blockFromBci[0]);
 iterateAllBlocks();
 if (syncBlock != null && syncHandler.stateBefore() != null) {
 // generate unlocking code if the exception handler is reachable
 fillSyncHandler(rootMethodSynchronizedObject, syncBlock);
 }
+//        for (Node n : graph.getNodes()) {
+//            if (n instanceof FrameState) {
+//                boolean delete = false;
+//                if (n.usages().size() == 0 && n.predecessors().size() == 0) {
+//                    delete = true;
+//                }
+//                if (n.predecessors().size() == 0 && n.usages().size() == 1 && n.usages().get(0) instanceof BlockBegin) {
+//                    n.usages().get(0).inputs().replace(n, null);
+//                    delete = true;
+//                }
+//                if (delete) {
+//                    n.delete();
+//                    System.out.println("deleted framestate");
+//                }
+//            }
+//        }
 }
 private Block nextBlock(int bci) {
 Block block = new Block();
 block.startBci = bci;
 Goto base = new Goto(target, stateAfter, graph);
 appendWithBCI(base);
 }
 public void mergeOrClone(Block target, FrameStateAccess newState) {
-assert target.firstInstruction instanceof BlockBegin;
+Instruction first = target.firstInstruction;
-if (target.isLoopHeader) {
+int bci = target.startBci;
-mergeOrClone(target.firstInstruction, newState, true);
+boolean loopHeader = target.isLoopHeader;
-} else {
-mergeOrClone(target.firstInstruction, newState, false);
+FrameState existingState;
-}
+if (first instanceof Placeholder) {
-}
+existingState = ((Placeholder) first).stateBefore();
+} else {
+assert first instanceof BlockBegin;
-private void mergeOrClone(Instruction first, FrameStateAccess stateAfter, boolean loopHeader) {
+existingState = ((BlockBegin) first).stateBefore();
-mergeOrClone(first, stateAfter, loopHeader, false);
+}
-}
+if (existingState == null) {
-private void mergeOrClone(Instruction first, FrameStateAccess stateAfter, boolean loopHeader, boolean blockAppended) {
+// copy state because it is modified
-if (first instanceof BlockBegin) {
+FrameState duplicate = newState.duplicate(bci);
-BlockBegin block = (BlockBegin) first;
-FrameState existingState = block.stateBefore();
+// if the block is a loop header, insert all necessary phis
+if (loopHeader) {
-if (existingState == null) {
+assert first instanceof BlockBegin;
-// copy state because it is modified
+insertLoopPhis((BlockBegin) first, duplicate);
-FrameState duplicate = stateAfter.duplicate(block.bci());
+((BlockBegin) first).setStateBefore(duplicate);
+} else {
-// if the block is a loop header, insert all necessary phis
+if (first instanceof Placeholder) {
-if (loopHeader) {
+((Placeholder) first).setStateBefore(duplicate);
-insertLoopPhis(block, duplicate);
+} else {
+((BlockBegin) first).setStateBefore(duplicate);
 }
+}
-block.setStateBefore(duplicate);
+} else {
-} else {
-if (!C1XOptions.AssumeVerifiedBytecode && !existingState.isCompatibleWith(stateAfter)) {
+if (!C1XOptions.AssumeVerifiedBytecode && !existingState.isCompatibleWith(newState)) {
 // stacks or locks do not match--bytecodes would not verify
 throw new CiBailout("stack or locks do not match");
 }
-assert existingState.localsSize() == stateAfter.localsSize();
+assert existingState.localsSize() == newState.localsSize();
-assert existingState.stackSize() == stateAfter.stackSize();
+assert existingState.stackSize() == newState.stackSize();
-existingState.merge(block, stateAfter, blockAppended);
+existingState.merge((BlockBegin) first, newState);
 }
-} else {
-assert false;
-}
 for (int j = 0; j < frameState.localsSize() + frameState.stackSize(); ++j) {
 if (frameState.valueAt(j) != null) {
 assert !frameState.valueAt(j).isDeleted();
 }
 private void handleException(Instruction x, int bci) {
 if (!hasHandler()) {
 return;
 }
-ArrayList<ExceptionHandler> exceptionHandlers = new ArrayList<ExceptionHandler>();
 assert bci == Instruction.SYNCHRONIZATION_ENTRY_BCI || bci == bci() : "invalid bci";
+ExceptionHandler firstHandler = null;
 // join with all potential exception handlers
 if (this.exceptionHandlers != null) {
 for (ExceptionHandler handler : this.exceptionHandlers) {
 // if the handler covers this bytecode index, add it to the list
 if (handler.covers(bci)) {
-ExceptionHandler newHandler = addExceptionHandler(handler, frameState);
+firstHandler = new ExceptionHandler(handler);
-exceptionHandlers.add(newHandler);
+break;
+}
-// stop when reaching catch all
+}
-if (handler.isCatchAll()) {
+}
+if (firstHandler != null) {
+compilation.setHasExceptionHandlers();
+Block dispatchBlock = null;
+for (Block block : blockList) {
+if (block instanceof ExceptionBlock) {
+ExceptionBlock excBlock = (ExceptionBlock) block;
+if (excBlock.handler == firstHandler.handler) {
+dispatchBlock = block;
 break;
 }
 }
 }
-}
+// if there's no dispatch block then the catch block needs to be a catch all
+if (dispatchBlock == null) {
-if (!exceptionHandlers.isEmpty()) {
+assert firstHandler.isCatchAll();
-Instruction successor;
+dispatchBlock = firstHandler.entryBlock();
+}
-ArrayList<BlockBegin> newBlocks = new ArrayList<BlockBegin>();
-int current = exceptionHandlers.size() - 1;
-if (exceptionHandlers.get(current).isCatchAll()) {
-successor = createTarget(exceptionHandlers.get(current).entryBlock(), null);
-current--;
-} else {
-if (unwindBlock == null) {
-unwindBlock = new BlockBegin(bci, ir.nextBlockNumber(), false, graph);
-Unwind unwind = new Unwind(null, graph);
-unwindBlock.appendNext(unwind);
-}
-successor = unwindBlock;
-}
-for (; current >= 0; current--) {
-ExceptionHandler handler = exceptionHandlers.get(current);
-BlockBegin newSucc = null;
-for (Node pred : successor.predecessors()) {
-if (pred instanceof ExceptionDispatch) {
-ExceptionDispatch dispatch = (ExceptionDispatch) pred;
-if (dispatch.handler().handler == handler.handler) {
-newSucc = dispatch.begin();
-break;
-}
-}
-}
-if (newSucc != null) {
-successor = newSucc;
-} else {
-BlockBegin dispatchEntry = new BlockBegin(handler.handlerBCI(), ir.nextBlockNumber(), false, graph);
-if (handler.handler.catchType().isResolved()) {
-Instruction entry = createTarget(handler.entryBlock(), null);
-ExceptionDispatch end = new ExceptionDispatch(null, entry, null, handler, null, graph);
-end.setBlockSuccessor(0, successor);
-dispatchEntry.appendNext(end);
-} else {
-Deoptimize deopt = new Deoptimize(graph);
-dispatchEntry.appendNext(deopt);
-Goto end = new Goto(successor, null, graph);
-deopt.appendNext(end);
-}
-newBlocks.add(dispatchEntry);
-successor = dispatchEntry;
-}
-}
 FrameState entryState = frameState.duplicateWithEmptyStack(bci);
 BlockBegin entry = new BlockBegin(bci, ir.nextBlockNumber(), false, graph);
 entry.setStateBefore(entryState);
 ExceptionObject exception = new ExceptionObject(graph);
 entry.appendNext(exception);
 FrameState stateWithException = entryState.duplicateModified(bci, CiKind.Void, exception);
+Instruction successor = createTarget(dispatchBlock, stateWithException);
 BlockEnd end = new Goto(successor, stateWithException, graph);
 exception.appendNext(end);
 if (x instanceof Invoke) {
 ((Invoke) x).setExceptionEdge(entry);
 } else {
 ((Throw) x).setExceptionEdge(entry);
 }
+}
-updateDispatchChain(end.blockSuccessor(0), stateWithException, bci);
-}
-}
-private void updateDispatchChain(BlockBegin dispatchEntry, FrameStateAccess state, int bci) {
-FrameState oldState = dispatchEntry.stateBefore();
-if (oldState != null && dispatchEntry.predecessors().size() == 1) {
-dispatchEntry.setStateBefore(null);
-}
-mergeOrClone(dispatchEntry, state, false, true);
-FrameState mergedState = dispatchEntry.stateBefore();
-if (dispatchEntry.next() instanceof ExceptionDispatch) {
-// ordinary dispatch handler
-ExceptionDispatch dispatch = (ExceptionDispatch) dispatchEntry.next();
-dispatch.setStateAfter(mergedState.duplicate(bci));
-dispatch.setException(mergedState.stackAt(0));
-dispatch.catchSuccessor().setStateBefore(mergedState.duplicate(bci));
-updateDispatchChain(dispatch.otherSuccessor(), mergedState, bci);
-} else if (dispatchEntry.next() instanceof Deoptimize) {
-// deoptimizing handler
-dispatchEntry.end().setStateAfter(mergedState.duplicate(bci));
-updateDispatchChain(dispatchEntry.end().blockSuccessor(0), mergedState, bci);
-} else if (dispatchEntry.next() instanceof Unwind) {
-// unwind handler
-Unwind unwind = (Unwind) dispatchEntry.next();
-unwind.setStateAfter(mergedState.duplicate(bci));
-unwind.setException(mergedState.stackAt(0));
-} else {
-// synchronization or default exception handler, nothing to do
-}
-}
-/**
-* Adds an exception handler to the {@linkplain BlockBegin#exceptionHandlerBlocks() list}
-* of exception handlers for the {@link #curBlock current block}.
-*/
-private ExceptionHandler addExceptionHandler(ExceptionHandler handler, FrameStateAccess curState) {
-compilation.setHasExceptionHandlers();
-BlockMap.Block entry = handler.entryBlock();
-// clone exception handler
-ExceptionHandler newHandler = new ExceptionHandler(handler);
-// fill in exception handler subgraph lazily
-if (!isVisited(entry)) {
-if (handler.handlerBCI() != Instruction.SYNCHRONIZATION_ENTRY_BCI) {
-addToWorkList(entry);
-}
-} else {
-// This will occur for exception handlers that cover themselves. This code
-// pattern is generated by javac for synchronized blocks. See the following
-// for why this change to javac was made:
-//
-//   http://www.cs.arizona.edu/projects/sumatra/hallofshame/java-async-race.html
-}
-return newHandler;
 }
 private void genLoadConstant(int cpi) {
 Object con = constantPool().lookupConstant(cpi);
 }
 return x;
 }
-private Instruction blockAtOrNull(int bci) {
-return blockList[bci] != null ? blockList[bci].firstInstruction : null;
-}
-private Instruction blockAt(int bci) {
-Instruction result = blockAtOrNull(bci);
-assert result != null : "Expected a block to begin at " + bci;
-return result;
-}
 private Instruction createTargetAt(int bci, FrameStateAccess stateAfter) {
-return createTarget(blockList[bci], stateAfter);
+return createTarget(blockFromBci[bci], stateAfter);
 }
 private Instruction createTarget(Block block, FrameStateAccess stateAfter) {
+assert block != null && stateAfter != null;
 if (block.firstInstruction == null) {
-BlockBegin blockBegin = new BlockBegin(block.startBci, block.blockID, block.isLoopHeader, graph);
+//            if (block.isLoopHeader) {
-block.firstInstruction = blockBegin;
+block.firstInstruction = new BlockBegin(block.startBci, block.blockID, block.isLoopHeader, graph);
-}
+//            } else {
-if (stateAfter != null) {
+//                block.firstInstruction = new Placeholder(graph);
-mergeOrClone(block, stateAfter);
+//            }
 }
+mergeOrClone(block, stateAfter);
 addToWorkList(block);
 return block.firstInstruction;
 }
 private Value synchronizedObject(FrameStateAccess state, RiMethod target) {
 // now parse the block
 frameState.initializeFrom(((BlockBegin) block.firstInstruction).stateBefore());
 lastInstr = block.firstInstruction;
 assert block.firstInstruction.next() == null;
-iterateBytecodesForBlock(block);
+if (block instanceof ExceptionBlock) {
+createExceptionDispatch((ExceptionBlock) block);
+} else {
+iterateBytecodesForBlock(block);
+}
+}
+}
+}
+private void createExceptionDispatch(ExceptionBlock block) {
+if (block.handler == null) {
+assert frameState.stackSize() == 1 : "only exception object expected on stack, actual size: " + frameState.stackSize();
+if (Modifier.isSynchronized(method().accessFlags())) {
+// unlock before exiting the method
+int lockNumber = frameState.locksSize() - 1;
+MonitorAddress lockAddress = null;
+if (compilation.runtime.sizeOfBasicObjectLock() != 0) {
+lockAddress = new MonitorAddress(lockNumber, graph);
+append(lockAddress);
+}
+append(new MonitorExit(rootMethodSynchronizedObject, lockAddress, lockNumber, graph));
+frameState.unlock();
+}
+append(new Unwind(frameState.apop(), graph));
+} else {
+assert frameState.stackSize() == 1;
+if (block.handler.catchType().isResolved()) {
+Instruction catchSuccessor = createTarget(block.handlerBlock, frameState);
+Instruction nextDispatch = createTarget(block.next, frameState);
+append(new ExceptionDispatch(frameState.stackAt(0), catchSuccessor, nextDispatch, block.handler.catchType(), frameState.duplicate(bci()), graph));
+} else {
+Deoptimize deopt = new Deoptimize(graph);
+deopt.setMessage("unresolved " + block.handler.catchType().name());
+append(deopt);
+Instruction nextDispatch = createTarget(block.next, frameState);
+append(new Goto(nextDispatch, frameState.duplicate(bci()), graph));
 }
 }
 }
 private BlockEnd iterateBytecodesForBlock(Block block) {
 int endBCI = stream.endBCI();
 boolean blockStart = true;
 int bci = block.startBci;
 while (bci < endBCI) {
-Block nextBlock = blockList[bci];
+Block nextBlock = blockFromBci[bci];
 if (nextBlock != null && nextBlock != block) {
 // we fell through to the next block, add a goto and break
 Instruction next = createTarget(nextBlock, frameState);
 end = new Goto(next, null, graph);
 lastInstr = lastInstr.appendNext(end);
 }
 // connect to begin and set state
 // NOTE that inlining may have changed the block we are parsing
 assert end != null : "end should exist after iterating over bytecodes";
-FrameState stateAtEnd = frameState.create(bci());
+end.setStateAfter(frameState.create(bci()));
-end.setStateAfter(stateAtEnd);
 return end;
 }
 private void traceState() {
 if (C1XOptions.TraceBytecodeParserLevel >= TRACELEVEL_STATE && !TTY.isSuppressed()) {

Mercurial > hg > truffle

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