Java Code Examples for org.apache.bcel.Const#JSR

/**
 * Computes stack usage of an instruction list by performing control flow analysis.
 *
 * @return maximum stack depth used by method
 */
public static int getMaxStack( final ConstantPoolGen cp, final InstructionList il, final CodeExceptionGen[] et ) {
    final BranchStack branchTargets = new BranchStack();
    /* Initially, populate the branch stack with the exception
     * handlers, because these aren't (necessarily) branched to
     * explicitly. in each case, the stack will have depth 1,
     * containing the exception object.
     */
    for (final CodeExceptionGen element : et) {
        final InstructionHandle handler_pc = element.getHandlerPC();
        if (handler_pc != null) {
            branchTargets.push(handler_pc, 1);
        }
    }
    int stackDepth = 0;
    int maxStackDepth = 0;
    InstructionHandle ih = il.getStart();
    while (ih != null) {
        final Instruction instruction = ih.getInstruction();
        final short opcode = instruction.getOpcode();
        final int delta = instruction.produceStack(cp) - instruction.consumeStack(cp);
        stackDepth += delta;
        if (stackDepth > maxStackDepth) {
            maxStackDepth = stackDepth;
        }
        // choose the next instruction based on whether current is a branch.
        if (instruction instanceof BranchInstruction) {
            final BranchInstruction branch = (BranchInstruction) instruction;
            if (instruction instanceof Select) {
                // explore all of the select's targets. the default target is handled below.
                final Select select = (Select) branch;
                final InstructionHandle[] targets = select.getTargets();
                for (final InstructionHandle target : targets) {
                    branchTargets.push(target, stackDepth);
                }
                // nothing to fall through to.
                ih = null;
            } else if (!(branch instanceof IfInstruction)) {
                // if an instruction that comes back to following PC,
                // push next instruction, with stack depth reduced by 1.
                if (opcode == Const.JSR || opcode == Const.JSR_W) {
                    branchTargets.push(ih.getNext(), stackDepth - 1);
                }
                ih = null;
            }
            // for all branches, the target of the branch is pushed on the branch stack.
            // conditional branches have a fall through case, selects don't, and
            // jsr/jsr_w return to the next instruction.
            branchTargets.push(branch.getTarget(), stackDepth);
        } else {
            // check for instructions that terminate the method.
            if (opcode == Const.ATHROW || opcode == Const.RET
                    || (opcode >= Const.IRETURN && opcode <= Const.RETURN)) {
                ih = null;
            }
        }
        // normal case, go to the next instruction.
        if (ih != null) {
            ih = ih.getNext();
        }
        // if we have no more instructions, see if there are any deferred branches to explore.
        if (ih == null) {
            final BranchTarget bt = branchTargets.pop();
            if (bt != null) {
                ih = bt.target;
                stackDepth = bt.stackDepth;
            }
        }
    }
    return maxStackDepth;
}
 

/** Create branch instruction by given opcode, except LOOKUPSWITCH and TABLESWITCH.
 * For those you should use the SWITCH compound instruction.
 */
public static BranchInstruction createBranchInstruction( final short opcode, final InstructionHandle target ) {
    switch (opcode) {
        case Const.IFEQ:
            return new IFEQ(target);
        case Const.IFNE:
            return new IFNE(target);
        case Const.IFLT:
            return new IFLT(target);
        case Const.IFGE:
            return new IFGE(target);
        case Const.IFGT:
            return new IFGT(target);
        case Const.IFLE:
            return new IFLE(target);
        case Const.IF_ICMPEQ:
            return new IF_ICMPEQ(target);
        case Const.IF_ICMPNE:
            return new IF_ICMPNE(target);
        case Const.IF_ICMPLT:
            return new IF_ICMPLT(target);
        case Const.IF_ICMPGE:
            return new IF_ICMPGE(target);
        case Const.IF_ICMPGT:
            return new IF_ICMPGT(target);
        case Const.IF_ICMPLE:
            return new IF_ICMPLE(target);
        case Const.IF_ACMPEQ:
            return new IF_ACMPEQ(target);
        case Const.IF_ACMPNE:
            return new IF_ACMPNE(target);
        case Const.GOTO:
            return new GOTO(target);
        case Const.JSR:
            return new JSR(target);
        case Const.IFNULL:
            return new IFNULL(target);
        case Const.IFNONNULL:
            return new IFNONNULL(target);
        case Const.GOTO_W:
            return new GOTO_W(target);
        case Const.JSR_W:
            return new JSR_W(target);
        default:
            throw new IllegalArgumentException("Invalid opcode: " + opcode);
    }
}