graal-jvmci-8: graal/GraalCompiler/src/com/sun/c1x/ir/BlockBegin.java comparison

comparison graal/GraalCompiler/src/com/sun/c1x/ir/BlockBegin.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	0ea5f12e873a
children	4272b7af2d17

comparison

equal deleted inserted replaced

-:0ea5f12e873a
+:7ed72769d51a
 return false;
 }
 public void setEnd(BlockEnd end) {
 assert end != null;
-BlockEnd old = this.end();
+successors().set(super.successorCount() + SUCCESSOR_END, end);
-if (old != end) {
-if (old != null) {
-// disconnect this block from its current successors
-for (BlockBegin s : old.blockSuccessors()) {
-s.blockPredecessors().remove(this.end());
-}
-}
-successors().set(super.successorCount() + SUCCESSOR_END, end);
-for (BlockBegin s : end.blockSuccessors()) {
-s.addPredecessor(end);
-}
-}
 }
 private static final List<BlockBegin> NO_HANDLERS = Collections.emptyList();
 /**
 * An enumeration of flags for block entries indicating various things.
 */
 public enum BlockFlag {
 StandardEntry,
-ExceptionEntry,
 SubroutineEntry,
 BackwardBranchTarget,
 IsOnWorkList,
 WasVisited,
 DefaultExceptionHandler,
 /**
 * Denotes the current set of {@link BlockBegin.BlockFlag} settings.
 */
 private int blockFlags;
-/**
-* The {@link BlockBegin} nodes for which this node is a successor.
-*/
-private final List<BlockEnd> predecessors;
 private int depthFirstNumber;
 private int linearScanNumber;
 private int loopDepth;
 private int loopIndex;
 private BlockBegin dominator;
-private List<BlockBegin> exceptionHandlerBlocks;
-private List<FrameState> exceptionHandlerStates;
 // LIR block
 public LIRBlock lirBlock;
 /**
 public BlockBegin(int bci, int blockID, Graph graph) {
 super(CiKind.Illegal, INPUT_COUNT, SUCCESSOR_COUNT, graph);
 this.blockID = blockID;
 depthFirstNumber = -1;
 linearScanNumber = -1;
-predecessors = new ArrayList<BlockEnd>(2);
 loopIndex = -1;
 setBCI(bci);
 }
 /**
 * Gets the list of predecessors of this block.
 * @return the predecessor list
 */
-public List<BlockEnd> blockPredecessors() {
+@SuppressWarnings({ "unchecked", "rawtypes" })
-//      return Collections.unmodifiableList(predecessors);
+public List<Instruction> blockPredecessors() {
-return predecessors;
+if (predecessors().size() == 1 && predecessors().get(0) == graph().root()) {
+return Collections.EMPTY_LIST;
+} else {
+return (List) Collections.unmodifiableList(predecessors());
+}
 }
 /**
 * Gets the dominator of this block.
 * @return the dominator block
 * Gets the loop index of this block.
 * @return the loop index
 */
 public int loopIndex() {
 return loopIndex;
-}
-/**
-* Gets the exception handlers that cover one or more instructions of this basic block.
-*
-* @return the exception handlers
-*/
-public List<BlockBegin> exceptionHandlerBlocks() {
-return exceptionHandlerBlocks == null ? NO_HANDLERS : exceptionHandlerBlocks;
-}
-public List<FrameState> exceptionHandlerStates() {
-return exceptionHandlerStates;
 }
 public void setDepthFirstNumber(int depthFirstNumber) {
 assert depthFirstNumber >= 0;
 this.depthFirstNumber = depthFirstNumber;
 queue.offer(this);
 mark.put(this, this);
 BlockBegin block;
 while ((block = queue.poll()) != null) {
 closure.apply(block);
-queueBlocks(queue, block.exceptionHandlerBlocks(), mark);
+Instruction inst = block;
+ArrayList<BlockBegin> excBlocks = new ArrayList<BlockBegin>();
+while (inst != null) {
+if (inst instanceof Invoke) {
+excBlocks.add(((Invoke) inst).exceptionEdge());
+} else if (inst instanceof Throw) {
+excBlocks.add(((Throw) inst).exceptionEdge());
+}
+inst = inst.next();
+}
+while (excBlocks.remove(null)) {
+// nothing
+}
+if (excBlocks.size() > 0) {
+queueBlocks(queue, excBlocks, mark);
+}
 queueBlocks(queue, block.end().blockSuccessors(), mark);
 if (predecessors) {
-queueBlockEnds(queue, block.predecessors, mark);
+queueBlockEnds(queue, block.blockPredecessors(), mark);
 }
 }
 }
 private void queueBlocks(LinkedList<BlockBegin> queue, List<BlockBegin> list, IdentityHashMap<BlockBegin, BlockBegin> mark) {
 }
 }
 }
 }
-private void queueBlockEnds(LinkedList<BlockBegin> queue, List<BlockEnd> list, IdentityHashMap<BlockBegin, BlockBegin> mark) {
+private void queueBlockEnds(LinkedList<BlockBegin> queue, List<Instruction> list, IdentityHashMap<BlockBegin, BlockBegin> mark) {
 if (list != null) {
-for (BlockEnd end : list) {
+for (Instruction end : list) {
-BlockBegin b = end.begin();
+BlockBegin b = end.block();
 if (!mark.containsKey(b)) {
 queue.offer(b);
 mark.put(b, b);
 }
 }
 private void iterate(IdentityHashMap<BlockBegin, BlockBegin> mark, BlockClosure closure) {
 if (!mark.containsKey(this)) {
 mark.put(this, this);
 closure.apply(this);
 BlockEnd e = end();
-if (exceptionHandlerBlocks != null) {
-iterateReverse(mark, closure, exceptionHandlerBlocks);
+Instruction inst = this;
-}
+ArrayList<BlockBegin> excBlocks = new ArrayList<BlockBegin>();
+while (inst != null) {
+if (inst instanceof Invoke) {
+excBlocks.add(((Invoke) inst).exceptionEdge());
+} else if (inst instanceof Throw) {
+excBlocks.add(((Throw) inst).exceptionEdge());
+}
+inst = inst.next();
+}
+while (excBlocks.remove(null)) {
+// nothing
+}
+if (excBlocks.size() > 0) {
+iterateReverse(mark, closure, excBlocks);
+}
+//            if (exceptionHandlerBlocks != null) {
+//                iterateReverse(mark, closure, exceptionHandlerBlocks);
+//            }
 assert e != null : "block must have block end";
 iterateReverse(mark, closure, e.blockSuccessors());
 }
 }
 private void iterateReverse(IdentityHashMap<BlockBegin, BlockBegin> mark, BlockClosure closure, List<BlockBegin> list) {
 for (int i = list.size() - 1; i >= 0; i--) {
 list.get(i).iterate(mark, closure);
-}
-}
-/**
-* Adds an exception handler that covers one or more instructions in this block.
-*
-* @param handler the entry block for the exception handler to add
-*/
-public void addExceptionHandler(BlockBegin handler) {
-assert handler != null && handler.checkBlockFlag(BlockBegin.BlockFlag.ExceptionEntry);
-if (exceptionHandlerBlocks == null) {
-exceptionHandlerBlocks = new ArrayList<BlockBegin>(3);
-exceptionHandlerBlocks.add(handler);
-} else if (!exceptionHandlerBlocks.contains(handler)) {
-exceptionHandlerBlocks.add(handler);
-}
-}
-/**
-* Adds a frame state that merges into the exception handler whose entry is this block.
-*
-* @param state the frame state at an instruction that raises an exception that can be caught by the exception
-*            handler represented by this block
-* @return the index of {@code state} in the list of frame states merging at this block (i.e. the frames states for
-*         all instruction throwing an exception caught by this exception handler)
-*/
-public int addExceptionState(FrameState state) {
-assert checkBlockFlag(BlockBegin.BlockFlag.ExceptionEntry);
-if (exceptionHandlerStates == null) {
-exceptionHandlerStates = new ArrayList<FrameState>(4);
-}
-exceptionHandlerStates.add(state);
-return exceptionHandlerStates.size() - 1;
-}
-/**
-* Add a predecessor to this block.
-* @param pred the predecessor to add
-*/
-public void addPredecessor(BlockEnd pred) {
-assert pred != null;
-predecessors.add(pred);
-}
-/**
-* Removes all occurrences of the specified block from the predecessor list of this block.
-* @param pred the predecessor to remove
-*/
-public void removePredecessor(BlockEnd pred) {
-while (predecessors.remove(pred)) {
-// the block may appear multiple times in the list
-// XXX: this is not very efficient, consider Util.removeAllFromList
 }
 }
 @Override
 public void accept(ValueVisitor v) {
 // copy state because it is modified
 FrameState duplicate = newState.duplicate(bci());
 assert duplicate.bci == bci() : "duplicate.bci=" + duplicate.bci + " my bci=" + bci();
-if (C1XOptions.UseStackMapTableLiveness) {
+if (C1XOptions.UseStackMapTableLiveness && method != null) {
 // if a liveness map is available, use it to invalidate dead locals
 CiBitMap[] livenessMap = method.livenessMap();
 if (livenessMap != null && bci() >= 0) {
 assert bci() < livenessMap.length;
 CiBitMap liveness = livenessMap[bci()];
 public void setCriticalEdgeSplit(boolean value) {
 setBlockFlag(BlockFlag.CriticalEdgeSplit, value);
 }
-public boolean isExceptionEntry() {
-return checkBlockFlag(BlockFlag.ExceptionEntry);
-}
-public void setExceptionEntry() {
-setBlockFlag(BlockFlag.ExceptionEntry);
-}
 public boolean isSubroutineEntry() {
 return checkBlockFlag(BlockFlag.SubroutineEntry);
 }
 public void setSubroutineEntry() {
 }
 public void copyBlockFlags(BlockBegin other) {
 copyBlockFlag(other, BlockBegin.BlockFlag.ParserLoopHeader);
 copyBlockFlag(other, BlockBegin.BlockFlag.SubroutineEntry);
-copyBlockFlag(other, BlockBegin.BlockFlag.ExceptionEntry);
 copyBlockFlag(other, BlockBegin.BlockFlag.WasVisited);
 }
 @Override
 public String toString() {
 /**
 * Get the number of predecessors.
 * @return the number of predecessors
 */
 public int numberOfPreds() {
-//        assert predecessors.size() == predecessors().size();
+// ignore the graph root
-return predecessors.size();
+if (predecessors().size() == 1 && predecessors().get(0) == graph().root()) {
+return 0;
+} else {
+return predecessors().size();
+}
 }
 /**
 * @return the label associated with the block, used by the LIR
 */
 lirBlock = new LIRBlock();
 }
 return lirBlock;
 }
-public int exceptionHandlerPco() {
+public int blockEntryPco() {
-return lirBlock == null ? 0 : lirBlock.exceptionHandlerPCO;
+return lirBlock == null ? 0 : lirBlock.blockEntryPco;
 }
-public void setExceptionHandlerPco(int codeOffset) {
+public void setBlockEntryPco(int codeOffset) {
-lirBlock().exceptionHandlerPCO = codeOffset;
+lirBlock().blockEntryPco = codeOffset;
 }
-public int numberOfExceptionHandlers() {
+public Instruction predAt(int j) {
-return exceptionHandlerBlocks == null ? 0 : exceptionHandlerBlocks.size();
+return (Instruction) predecessors().get(j);
-}
-public BlockBegin exceptionHandlerAt(int i) {
-return exceptionHandlerBlocks.get(i);
-}
-public BlockEnd predAt(int j) {
-//        assert predecessors.get(j) == predecessors().get(j);
-return predecessors.get(j);
 }
 public int firstLirInstructionId() {
 return lirBlock.firstLirInstructionID;
 }
 public void setLastLirInstructionId(int lastLirInstructionId) {
 lirBlock.lastLirInstructionID = lastLirInstructionId;
 }
-public boolean isPredecessor(BlockEnd block) {
+public boolean isPredecessor(Instruction block) {
-//        assert predecessors.contains(block) == predecessors().contains(block);
+return predecessors().contains(block);
-return predecessors.contains(block);
 }
 public void printWithoutPhis(LogStream out) {
 // print block id
 BlockEnd end = end();
 out.print("B").print(blockID).print(" ");
 // print flags
 StringBuilder sb = new StringBuilder(8);
-if (isExceptionEntry()) {
-sb.append('E');
-}
 if (isSubroutineEntry()) {
 sb.append('s');
 }
 if (isParserLoopHeader()) {
 sb.append("LH");
 out.print(" .");
 for (BlockBegin successor : end.blockSuccessors()) {
 out.print(" B").print(successor.blockID);
 }
 }
-// print exception handlers
-if (!exceptionHandlers().isEmpty()) {
-out.print(" (xhandlers");
-for (BlockBegin handler : exceptionHandlerBlocks()) {
-out.print(" B").print(handler.blockID);
-}
-out.print(')');
-}
 // print dominator block
 if (dominator() != null) {
 out.print(" dom B").print(dominator().blockID);
 }
 // print predecessors
 if (!blockPredecessors().isEmpty()) {
 out.print(" pred:");
-for (BlockEnd pred : blockPredecessors()) {
+for (Instruction pred : blockPredecessors()) {
-out.print(" B").print(pred.begin().blockID);
+out.print(" B").print(pred.block().blockID);
 }
 }
 }
 @Override
 @Override
 public String shortName() {
 return "BlockBegin #" + blockID;
 }
+/**
+* Iterates over all successors of this block: successors of the end node and exception handler.
+*/
+public void allSuccessorsDo(boolean backwards, BlockClosure closure) {
+if (backwards) {
+for (int i = numberOfSux() - 1; i >= 0; i--) {
+closure.apply(suxAt(i));
+}
+} else {
+for (int i = 0; i < numberOfSux(); i++) {
+closure.apply(suxAt(i));
+}
+}
+for (Instruction x = next(); x != null; x = x.next()) {
+if (x instanceof Invoke && ((Invoke) x).exceptionEdge() != null) {
+closure.apply(((Invoke) x).exceptionEdge());
+} else if (x instanceof Throw && ((Throw) x).exceptionEdge() != null) {
+closure.apply(((Throw) x).exceptionEdge());
+}
+}
+}
+public void verifyPredecessors() {
+for (int i = 0; i < numberOfPreds(); i++) {
+predAt(i);
+}
+}
 }

Mercurial > hg > graal-jvmci-8

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