Java CodeExceptionGen.getHandlerPC方法代码示例

import org.apache.bcel.generic.CodeExceptionGen; //导入方法依赖的package包/类
private SpawnableCall getSpawnableCallWithException(InstructionHandle invokeInstruction, 
    ArrayList<CodeExceptionGen> exceptionHandlers) {

ArrayList<LocalVariableGen> resultIndices = new ArrayList<LocalVariableGen>();
for (CodeExceptionGen exceptionHandler : exceptionHandlers) {
    InstructionHandle start = exceptionHandler.getHandlerPC(); 
    InstructionHandle end = getEndExceptionHandler(exceptionHandler);
    getIndicesStores(start, end, resultIndices);
}

LocalVariableGen[] dummy = new LocalVariableGen[resultIndices.size()];

return new SpawnableCall(invokeInstruction,
	getObjectReferenceLoadInstruction(invokeInstruction),
	resultIndices.toArray(dummy));
   }
 

import org.apache.bcel.generic.CodeExceptionGen; //导入方法依赖的package包/类
/** Returns the end of an exception handler.
    *
    * @param codeException The codeException which end is returned.
    * @return The instructionHandle that is the end of the exception handler.
    */
   public InstructionHandle getEndExceptionHandler(CodeExceptionGen codeException) {
LocalVariableGen[] localVars = getLocalVariables();
InstructionHandle startHandler = codeException.getHandlerPC();

for (LocalVariableGen localVar : localVars) {
    InstructionHandle startScope = localVar.getStart();
    InstructionHandle endScope = localVar.getEnd();

    if (startScope == startHandler || startScope == startHandler.getNext() || 
	    startScope == startHandler.getNext().getNext() &&
	    localVar.getType().equals(codeException.getCatchType()))
	return endScope.getPrev();
}
throw new Error("no end exceptionhandler...");
   }
 

import org.apache.bcel.generic.CodeExceptionGen; //导入方法依赖的package包/类
public static CodeExceptionGen merge(@CheckForNull TypeMerger m, CodeExceptionGen e1, CodeExceptionGen e2) {
    if (e1 == null) return e2;
    if (e2 == null) return e1;
    if (m == null)
        return e1;
    if ( ! e1.getHandlerPC().equals( e2.getHandlerPC() ) ){
        // log error
                    return e1;
    }
    try {
        Type t = m.mergeTypes(e1.getCatchType(), e2.getCatchType());
        return new CodeExceptionGen(e1.getStartPC(), e1.getEndPC(), e1.getHandlerPC(), (ObjectType) t);
    } catch (DataflowAnalysisException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
        return e1;
    }
}
 

import org.apache.bcel.generic.CodeExceptionGen; //导入方法依赖的package包/类
/**
 * Constructor. Creates a new ExceptionHandlers instance.
 * @param mg
 */
public ExceptionHandlers(MethodGen mg) {
    exceptionhandlers = new Hashtable<InstructionHandle, HashSet>();
    CodeExceptionGen[] cegs = mg.getExceptionHandlers();
    for (CodeExceptionGen ceg : cegs) {
        ExceptionHandler eh = new ExceptionHandler(ceg.getCatchType(), ceg.getHandlerPC());
        for (InstructionHandle ih = ceg.getStartPC(); ih != ceg.getEndPC().getNext(); ih = ih.getNext()) {
            HashSet<ExceptionHandler> hs;
            hs = exceptionhandlers.get(ih);
            if (hs == null) {
                hs = new HashSet<ExceptionHandler>();
                exceptionhandlers.put(ih, hs);
            }
            hs.add(eh);
        }
    }
}
 

import org.apache.bcel.generic.CodeExceptionGen; //导入方法依赖的package包/类
static InstructionHandle getEndOfCatchBlock(MethodGen m,
    CodeExceptionGen catchBlock) {

if (catchBlock.getCatchType() == null) {
    // finally clause, no local variable!
    return null;
}

LocalVariableGen[] lt = m.getLocalVariables();

InstructionHandle handler = catchBlock.getHandlerPC();

for (int i = 0; i < lt.length; i++) {
    InstructionHandle start = lt[i].getStart();
    InstructionHandle end = lt[i].getEnd();

    // dangerous, javac is one instruction further...
    if ((start == handler || start == handler.getNext() || start == handler
	    .getNext().getNext())
	    && lt[i].getType().equals(catchBlock.getCatchType())) {
	// System.out.println("found range of catch block: "
	// + handler + " - " + end);
	return end.getPrev();
    }
}

System.err
	.println("Could not find end of catch block, did you compile "
		+ "with the '-g' option?");
System.exit(1);
return null;
   }
 

import org.apache.bcel.generic.CodeExceptionGen; //导入方法依赖的package包/类
InstructionHandle insertTypecheckCode(MethodGen m, InstructionList il,
    InstructionHandle pos, int spawnId, int exceptionPos) {
    ArrayList<CodeExceptionGen> catches = mtab.getCatchTypes(m, spawnId);

    InstructionHandle[] jumpTargets = new InstructionHandle[catches.size() + 1];

    BranchHandle[] jumps = new BranchHandle[catches.size()];

    for (int i = 0; i < catches.size(); i++) {
        CodeExceptionGen e = catches.get(i);
        ObjectType type = e.getCatchType();
        InstructionHandle catchTarget = e.getHandlerPC();

        jumpTargets[i] = il.insert(pos, new ALOAD(exceptionPos));
        il.insert(pos, new INSTANCEOF(cpg.addClass(type)));
        il.insert(pos, new BIPUSH((byte) 1));
        jumps[i] = il.insert(pos, new IF_ICMPNE(null));
        il.insert(pos, new ALOAD(exceptionPos));
        il.insert(pos, ins_f.createCheckCast(type));
        il.insert(pos, new GOTO(catchTarget));
    }

    InstructionHandle t = il.insert(pos, new ALOAD(exceptionPos));
    il.insert(pos, new ATHROW());

    jumpTargets[catches.size()] = t;

    for (int i = 0; i < catches.size(); i++) {
        jumps[i].setTarget(jumpTargets[i + 1]);
    }

    return pos;
}
 

import org.apache.bcel.generic.CodeExceptionGen; //导入方法依赖的package包/类
/**
 * Add exception edges for given instruction.
 *
 * @param subroutine
 *            the subroutine containing the instruction
 * @param pei
 *            the instruction which throws an exception
 * @param etb
 *            the exception thrower block (ETB) for the instruction
 */
private void handleExceptions(Subroutine subroutine, InstructionHandle pei, BasicBlock etb) {
    etb.setExceptionThrower(pei);

    // Remember whether or not a universal exception handler
    // is reachable. If so, then we know that exceptions raised
    // at this instruction cannot propagate out of the method.
    boolean sawUniversalExceptionHandler = false;

    List<CodeExceptionGen> exceptionHandlerList = exceptionHandlerMap.getHandlerList(pei);
    if (exceptionHandlerList != null) {
        for (CodeExceptionGen exceptionHandler : exceptionHandlerList) {
            InstructionHandle handlerStart = exceptionHandler.getHandlerPC();
            subroutine.addEdgeAndExplore(etb, handlerStart, HANDLED_EXCEPTION_EDGE);

            if (Hierarchy.isUniversalExceptionHandler(exceptionHandler.getCatchType()))
                sawUniversalExceptionHandler = true;
        }
    }

    // If required, mark this block as throwing an unhandled exception.
    // For now, we assume that if there is no reachable handler that handles
    // ANY exception type, then the exception can be thrown out of the
    // method.
    if (!sawUniversalExceptionHandler) {
        if (DEBUG)
            System.out.println("Adding unhandled exception edge from " + pei);
        subroutine.setUnhandledExceptionBlock(etb);
    }
}
 

import org.apache.bcel.generic.CodeExceptionGen; //导入方法依赖的package包/类
private void addExceptionHandler(CodeExceptionGen exceptionHandler) {
    InstructionHandle handlerPC = exceptionHandler.getHandlerPC();
    CodeExceptionGen existing = startInstructionToHandlerMap.get(handlerPC);
    if (existing != null) {
        exceptionHandler = merge (this.merger, existing, exceptionHandler);
    }
    startInstructionToHandlerMap.put(handlerPC, exceptionHandler);
}