/**
* Generate handler info for exception with the generated instructions.
*
* @param insts the generated instructions.
* @return handlers of exception for classfile.
*/
public HandlerInfo[] getHandlerInfos(Instruction[] insts) {
HandlerInfo[] handlers = info.getHandlers();
for (int i = 0; i < handlers.length; ++i) {
HandlerInfo handler = handlers[i];
ExceptionHandler eh = exceptionHandlers[i];
eh.searchIndex();
handler.setStart(insts[eh.getStart()]);
handler.setEnd(insts[eh.getEnd()]);
handler.setHandler(insts[eh.getHandle()]);
}
return handlers;
}
/**
* Find the blocks protected by each ExceptionHandler. Add "exception edges" in the control flow
* graph. Add a basic block before the block which catch the exception. This last block store the
* exception in a variable.
*
* <p>Modification 02/04/2002 : add an exception edge between the blocks before the first block
* protected and the catch block.
*
* @param numBlocks an array containing the number of basic block for each instruction.
* @param insts the instructions
* @param bbs the basic blocks
*/
private void findExceptionBlocks(short[] numBlocks, Instruction[] insts, BasicBlock[] bbs) {
// shows if we had ever add a block for the catch block
boolean[] marqued = new boolean[bbs.length];
for (int i = 0; i < exceptionHandlers.length; ++i) {
ExceptionHandler handle = exceptionHandlers[i];
int numBlock = numBlocks[handle.getHandle()];
BasicBlock catchBlock = bbs[numBlock];
if (!marqued[numBlock]) {
// add a new block
// if the first instruction is the saving of the
// exception put this instruction in the
// new block else this saving will be added during
// the 3-adress code generation
BasicBlock newBlock;
Instruction first = insts[catchBlock.getStart()];
if (first instanceof LocalVarInstruction && ((LocalVarInstruction) first).isStore()) {
int instructionLine = catchBlock.getStart();
newBlock = new BasicBlock(instructionLine, instructionLine, graph);
// remove this instruction from the next block
catchBlock.setStart(instructionLine + 1);
} else {
newBlock = new BasicBlock(graph);
}
newBlock.setCatchBlock(true);
catchBlock.insertBefore(newBlock);
newBlock.addDefaultNextBlock(catchBlock);
bbs[numBlock] = newBlock;
catchBlock = newBlock;
marqued[numBlock] = true;
}
handle.setHandlerBlock(catchBlock);
}
for (int i = 0; i < exceptionHandlers.length; ++i) {
ExceptionHandler handle = exceptionHandlers[i];
BasicBlock catchBlock = handle.getHandlerBlock();
int numInst = handle.getStart();
int instEnd = handle.getEnd();
int numBlock = -1;
// MODIFICATION 02/04/2002
if (numInst <= instEnd) {
BasicBlock first = bbs[numBlocks[numInst]];
if (catchBlock != first) { // this is possible !
Iterator preds = first.getPredecessors();
while (preds.hasNext()) {
BasicBlock pred = (BasicBlock) preds.next();
pred.addExceptionNextBlock(catchBlock);
}
}
}
// END MODIFICATION 02/04/2002
numBlock = -1;
for (; numInst <= instEnd; ++numInst) {
if (numBlocks[numInst] != numBlock) {
numBlock = numBlocks[numInst];
// add blocks in exception handler.
BasicBlock bb = bbs[numBlock];
handle.addProtectedBlock(bb);
// add exception edges
bb.addExceptionNextBlock(catchBlock);
// if it's a catch block add also the next block
if (marqued[numBlock]) {
BasicBlock next = bb.getNext();
handle.addProtectedBlock(next);
next.addExceptionNextBlock(catchBlock);
}
}
}
}
}