graal-jvmci-8: graal/GraalCompiler/src/com/sun/c1x/graph/GraphBuilder.java comparison

comparison graal/GraalCompiler/src/com/sun/c1x/graph/GraphBuilder.java @ 2823:ac4b086cbd72

Merge

author	Gilles Duboscq <gilles.duboscq@oracle.com>
date	Mon, 30 May 2011 16:35:08 +0200
parents	530366123e46 c3f64b66fc78
children	244921d7cf50

comparison

equal deleted inserted replaced

-:530366123e46
+:ac4b086cbd72
 appendGoto(target);
 }
 public void mergeOrClone(Block target, FrameStateAccess newState) {
 Instruction first = target.firstInstruction;
+if (target.isLoopHeader && isVisited(target)) {
+first = ((LoopBegin) first).loopEnd();
+}
 assert first instanceof StateSplit;
 int bci = target.startBci;
 FrameState existingState = ((StateSplit) first).stateBefore();
 if (existingState == null) {
-assert first instanceof Merge ^ !target.isLoopHeader : "isLoopHeader: " + target.isLoopHeader;
+//            assert first instanceof Merge ^ !target.isLoopHeader : "isLoopHeader: " + target.isLoopHeader;
 // copy state because it is modified
 FrameState duplicate = newState.duplicate(bci);
 // if the block is a loop header, insert all necessary phis
-if (target.isLoopHeader) {
+if (first instanceof LoopBegin && target.isLoopHeader) {
 assert first instanceof Merge;
 insertLoopPhis((Merge) first, duplicate);
 ((Merge) first).setStateBefore(duplicate);
 } else {
 ((StateSplit) first).setStateBefore(duplicate);
 }
 assert existingState.localsSize() == newState.localsSize();
 assert existingState.stackSize() == newState.stackSize();
 if (first instanceof Placeholder) {
-Merge merge = new Merge(existingState.bci, target.isLoopHeader, graph);
+assert !target.isLoopHeader;
+Merge merge = new Merge(graph);
 Placeholder p = (Placeholder) first;
 assert p.next() == null;
 p.replace(merge);
 target.firstInstruction = merge;
 merge.setStateBefore(existingState);
-}
+first = merge;
+}
-existingState.merge((Merge) target.firstInstruction, newState);
+existingState.merge((Merge) first, newState);
 }
 for (int j = 0; j < frameState.localsSize() + frameState.stackSize(); ++j) {
 if (frameState.valueAt(j) != null) {
 assert !frameState.valueAt(j).isDeleted();
 }
 append(lookupSwitch);
 }
 private Value appendConstant(CiConstant constant) {
-return appendWithBCI(new Constant(constant, graph));
+return append(new Constant(constant, graph));
 }
 private Value append(Instruction x) {
 return appendWithBCI(x);
+}
+private Value append(Value v) {
+return v;
 }
 private Value appendWithBCI(Instruction x) {
 if (x.isAppended()) {
 // the instruction has already been added
 private Instruction createTargetAt(int bci, FrameStateAccess stateAfter) {
 return createTarget(blockFromBci[bci], stateAfter);
 }
 private Instruction createTarget(Block block, FrameStateAccess stateAfter) {
 assert block != null && stateAfter != null;
 assert block.isLoopHeader || block.firstInstruction == null || block.firstInstruction.next() == null : "non-loop block must be iterated after all its predecessors";
 if (block.isExceptionEntry) {
 assert stateAfter.stackSize() == 1;
 }
 if (block.firstInstruction == null) {
 if (block.isLoopHeader) {
-block.firstInstruction = new Merge(block.startBci, block.isLoopHeader, graph);
+//                block.firstInstruction = new Merge(block.startBci, graph);
+LoopBegin loopBegin = new LoopBegin(graph);
+LoopEnd loopEnd = new LoopEnd(graph);
+loopEnd.setLoopBegin(loopBegin);
+block.firstInstruction = loopBegin;
 } else {
 block.firstInstruction = new Placeholder(graph);
 }
 }
 mergeOrClone(block, stateAfter);
 addToWorkList(block);
-return block.firstInstruction;
+if (block.firstInstruction instanceof LoopBegin && isVisited(block)) {
+return ((LoopBegin) block.firstInstruction).loopEnd();
+} else {
+return block.firstInstruction;
+}
 }
 private Value synchronizedObject(FrameStateAccess state, RiMethod target) {
 if (isStatic(target.accessFlags())) {
 Constant classConstant = new Constant(target.holder().getEncoding(Representation.JavaClass), graph);
-return appendWithBCI(classConstant);
+return append(classConstant);
 } else {
 return state.localAt(0);
 }
 }
 if (block instanceof ExceptionBlock) {
 createExceptionDispatch((ExceptionBlock) block);
 } else {
 iterateBytecodesForBlock(block);
+}
+}
+}
+for (Block b : blocksVisited) {
+if (b.isLoopHeader) {
+LoopBegin begin = (LoopBegin) b.firstInstruction;
+LoopEnd end = begin.loopEnd();
+//              This can happen with degenerated loops like this one:
+//                for (;;) {
+//                    try {
+//                        break;
+//                    } catch (UnresolvedException iioe) {
+//                    }
+//                }
+if (end.stateBefore() != null) {
+begin.stateBefore().merge(begin, end.stateBefore());
+} else {
+end.delete();
+Merge merge = new Merge(graph);
+merge.successors().setAndClear(merge.nextIndex(), begin, begin.nextIndex());
+begin.replace(merge);
 }
 }
 }
 }

Mercurial > hg > graal-jvmci-8

comparison graal/GraalCompiler/src/com/sun/c1x/graph/GraphBuilder.java @ 2823:ac4b086cbd72