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

comparison graal/GraalCompiler/src/com/sun/c1x/graph/GraphBuilder.java @ 2746:05c92e53a50d

merge and clone before connecting blocks

author	Lukas Stadler <lukas.stadler@jku.at>
date	Fri, 20 May 2011 13:20:21 +0200
parents	a3cd5eb68837
children	84f4c7dceb14

comparison

equal deleted inserted replaced

-:55f1db570dfa
+:05c92e53a50d
 // Exception handler list
 private List<ExceptionHandler> exceptionHandlers;
 private final FrameStateBuilder frameState;          // the current execution state
 private Instruction lastInstr;                 // the last instruction added
-private Instruction placeholder;
 private final LogStream log;
 private Value rootMethodSynchronizedObject;
 }
 }
 flags |= Flag.HasHandler.mask;
 }
-assert !loopHeaders.contains(startBlock);
 mergeOrClone(startBlockBegin, frameState, false);
 // 3. setup internal state for appending instructions
 lastInstr = startBlockBegin;
 lastInstr.appendNext(null);
-Instruction entryBlock = blockAt(0);
 BlockBegin syncHandler = null;
 Block syncBlock = null;
 if (isSynchronized(rootMethod.accessFlags())) {
 // 4A.1 add a monitor enter to the start block
 rootMethodSynchronizedObject = synchronizedObject(frameState, compilation.method);
 genMonitorEnter(rootMethodSynchronizedObject, Instruction.SYNCHRONIZATION_ENTRY_BCI);
 // 4A.2 finish the start block
-finishStartBlock(startBlockBegin, entryBlock);
+finishStartBlock(startBlock);
 // 4A.3 setup an exception handler to unlock the root method synchronized object
 syncBlock = nextBlock(Instruction.SYNCHRONIZATION_ENTRY_BCI);
 syncHandler = new BlockBegin(Instruction.SYNCHRONIZATION_ENTRY_BCI, syncBlock.blockID, graph);
 syncBlock.firstInstruction = syncHandler;
 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
-finishStartBlock(startBlockBegin, entryBlock);
+finishStartBlock(startBlock);
 }
 // 5. SKIPPED: look for intrinsics
 // 6B.1 do the normal parsing
 private boolean isVisited(Block block) {
 return blocksVisited.contains(block);
 }
-private void finishStartBlock(BlockBegin startBlock, Instruction stdEntry) {
+private void finishStartBlock(Block startBlock) {
 assert bci() == 0;
 FrameState stateAfter = frameState.create(bci());
-Goto base = new Goto((BlockBegin) stdEntry, stateAfter, graph);
+Instruction target = createTargetAt(0, stateAfter);
+Goto base = new Goto((BlockBegin) target, stateAfter, graph);
 appendWithBCI(base);
-startBlock.setEnd(base);
+((BlockBegin) startBlock.firstInstruction).setEnd(base);
-//        assert stdEntry instanceof Placeholder;
+}
-assert ((BlockBegin) stdEntry).stateBefore() == null;
-prepareTarget(0);
-mergeOrClone(stdEntry, stateAfter, loopHeaders.contains(stdEntry));
-}
-private void prepareTarget(int bci) {
-}
 public void mergeOrClone(Block target, FrameStateAccess newState) {
+assert target.firstInstruction instanceof BlockBegin;
 if (target.isLoopHeader) {
-assert target.firstInstruction instanceof BlockBegin;
 mergeOrClone(target.firstInstruction, newState, true);
+} else {
+mergeOrClone(target.firstInstruction, newState, false);
 }
 }
 private void mergeOrClone(Instruction first, FrameStateAccess stateAfter, boolean loopHeader) {
 ExceptionHandler newHandler = new ExceptionHandler(handler);
 // fill in exception handler subgraph lazily
 if (!isVisited(entry)) {
 if (handler.handlerBCI() != Instruction.SYNCHRONIZATION_ENTRY_BCI) {
-addToWorkList(blockList[handler.handlerBCI()]);
+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:
 private Instruction createTargetAt(int bci, FrameStateAccess stateAfter) {
 return createTarget(blockList[bci], stateAfter);
 }
 private Instruction createTarget(Block block, FrameStateAccess stateAfter) {
+mergeOrClone(block, stateAfter);
+addToWorkList(block);
 return block.firstInstruction;
 }
 private void genLookupswitch() {
 int bci = bci();
 }
 assert x.next() == null : "instruction should not have been appended yet";
 assert lastInstr.next() == null : "cannot append instruction to instruction which isn't end (" + lastInstr + "->" + lastInstr.next() + ")";
-if (placeholder != null) {
-placeholder = null;
-}
 lastInstr = lastInstr.appendNext(x);
 if (++stats.nodeCount >= C1XOptions.MaximumInstructionCount) {
 // bailout if we've exceeded the maximum inlining size
 throw new CiBailout("Method and/or inlining is too large");
 }
 }
 if (!isVisited(block)) {
 markVisited(block);
 // now parse the block
-if (block.firstInstruction instanceof Placeholder) {
+frameState.initializeFrom(((BlockBegin) block.firstInstruction).stateBefore());
-assert false;
+lastInstr = block.firstInstruction;
-placeholder = block.firstInstruction;
-frameState.initializeFrom(((Placeholder) placeholder).stateBefore());
-lastInstr = null;
-} else {
-assert block.firstInstruction instanceof BlockBegin;
-placeholder = null;
-frameState.initializeFrom(((BlockBegin) block.firstInstruction).stateBefore());
-lastInstr = block.firstInstruction;
-}
 assert block.firstInstruction.next() == null;
 iterateBytecodesForBlock(block);
 }
 }
 assert end != null : "end should exist after iterating over bytecodes";
 FrameState stateAtEnd = frameState.create(bci());
 end.setStateAfter(stateAtEnd);
 if (block.firstInstruction instanceof BlockBegin) {
 ((BlockBegin) block.firstInstruction).setEnd(end);
-}
-// propagate the state
-for (BlockBegin succ : end.blockSuccessors()) {
-assert succ.blockPredecessors().contains(end);
-mergeOrClone(succ, stateAtEnd, loopHeaders.contains(succ));
-addToWorkList(blockList[succ.bci()]);
 }
 return end;
 }
 private void traceState() {

Mercurial > hg > truffle

comparison graal/GraalCompiler/src/com/sun/c1x/graph/GraphBuilder.java @ 2746:05c92e53a50d