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

@Override
public void sawOpcode(int seen) {
    if (skip) {
        return;
    }
    if (isBranch(seen) || seen == Const.ATHROW || isReturn(seen)) {
        skip = true;
    }
    if (seen == Const.PUTFIELD) {
        XField xField = getXFieldOperand();
        if (xField != null && xField.getClassDescriptor().getClassName().equals(getClassName())) {
            Item val = getStack().getStackItem(0);
            if (val.isInitialParameter()) {
                reporter.reportBug(new BugInstance("ME_ENUM_FIELD_SETTER", NORMAL_PRIORITY).addClassAndMethod(this).addField(xField)
                        .addSourceLine(this));
            }
        }
    }
}
 

private boolean markedAsNotUsable(Method obj) {
    for (Attribute a : obj.getAttributes()) {
        if (a instanceof Deprecated) {
            return true;
        }
    }
    Code code = obj.getCode();
    if (code == null) {
        return false;
    }
    byte[] codeBytes = code.getCode();
    if (codeBytes.length > 1 && codeBytes.length < 10) {
        int lastOpcode = codeBytes[codeBytes.length - 1] & 0xff;
        if (lastOpcode != Const.ATHROW) {
            return false;
        }
        for (int b : codeBytes) {
            if ((b & 0xff) == Const.RETURN) {
                return false;
            }
        }
        return true;
    }
    return false;
}
 

@Override
public void sawOpcode(int seen) {
    if (!allowedFields.isEmpty() && seen == Const.PUTFIELD) {
        Item objItem = getStack().getStackItem(1);
        if (objItem.getRegisterNumber() == 0) {
            if (allowedFields.contains(getFieldDescriptorOperand())) {
                Item valueItem = getStack().getStackItem(0);
                if (!isNew(valueItem) && !valueItem.isNull()) {
                    allowedFields.remove(getFieldDescriptorOperand());
                }
            }
        }
    }
    if (status == SideEffectStatus.SIDE_EFFECT && allowedFields.isEmpty()) {
        // Nothing to do: skip the rest of the method
        throw new EarlyExitException();
    }
    if (status == SideEffectStatus.SIDE_EFFECT) {
        return;
    }
    switch (seen) {
    case Const.ASTORE:
    case Const.ASTORE_0:
    case Const.ASTORE_1:
    case Const.ASTORE_2:
    case Const.ASTORE_3:
        if (finallyTargets.contains(getPC())) {
            finallyExceptionRegisters.add(getRegisterOperand());
        }
        break;
    case Const.ATHROW: {
        Item exceptionItem = getStack().getStackItem(0);
        if (!finallyExceptionRegisters.remove(exceptionItem.getRegisterNumber())) {
            uselessVoidCandidate = false;
            try {
                JavaClass javaClass = exceptionItem.getJavaClass();
                if (javaClass != null && ALLOWED_EXCEPTIONS.contains(javaClass.getClassName())) {
                    break;
                }
            } catch (ClassNotFoundException e) {
            }
            status = SideEffectStatus.SIDE_EFFECT;
        }
        break;
    }
    case Const.PUTSTATIC:
        if (classInit) {
            if (getClassConstantOperand().equals(getClassName())) {
                break;
            }
        }
        status = SideEffectStatus.SIDE_EFFECT;
        break;
    case Const.INVOKEDYNAMIC:
        status = SideEffectStatus.SIDE_EFFECT;
        break;
    case Const.PUTFIELD:
        sawCall(getMethodCall(FIELD_STORE_STUB_METHOD), false);
        break;
    case Const.AASTORE:
    case Const.DASTORE:
    case Const.CASTORE:
    case Const.BASTORE:
    case Const.IASTORE:
    case Const.LASTORE:
    case Const.FASTORE:
    case Const.SASTORE:
        sawCall(getMethodCall(ARRAY_STORE_STUB_METHOD), false);
        break;
    case Const.INVOKESTATIC:
        if (changesOnlyNewObjects(getMethodDescriptorOperand())) {
            break;
        }
        sawCall(new MethodCall(getMethodDescriptorOperand(), TARGET_OTHER), false);
        break;
    case Const.INVOKESPECIAL:
    case Const.INVOKEINTERFACE:
    case Const.INVOKEVIRTUAL: {
        XMethod xMethodOperand = getXMethodOperand();
        MethodDescriptor methodDescriptorOperand = xMethodOperand == null ? getMethodDescriptorOperand()
                : xMethodOperand
                        .getMethodDescriptor();
        if (changesOnlyNewObjects(getMethodDescriptorOperand())) {
            break;
        }
        MethodCall methodCall = getMethodCall(methodDescriptorOperand);
        sawCall(methodCall, false);
        break;
    }
    default:
        break;
    }
}
 

/**
 * 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;
}