import org.apache.bcel.generic.CHECKCAST; //导入依赖的package包/类
@Override
public void visitCHECKCAST(CHECKCAST obj) {
    // cast to a safe object type
    ObjectType objectType = obj.getLoadClassType(cpg);
    if (objectType == null) {
        return;
    }

    String objectTypeSignature = objectType.getSignature();

    if(!taintConfig.isClassTaintSafe(objectTypeSignature)) {
        return;
    }

    try {
        getFrame().popValue();
        pushSafe();
    }
    catch (DataflowAnalysisException ex) {
        throw new InvalidBytecodeException("empty stack for checkcast", ex);
    }
}
 

import org.apache.bcel.generic.CHECKCAST; //导入依赖的package包/类
public void visitCHECKCAST(CHECKCAST c) {
	Type t = c.getType(poolGen);
	log.log("         instr(checkcast)=" + t, Project.MSG_DEBUG);
	String type = t.toString();

	design.checkClass(type);
}
 

import org.apache.bcel.generic.CHECKCAST; //导入依赖的package包/类
@Override
public void visitCHECKCAST(CHECKCAST obj) {
    try {
        ResourceValueFrame frame = getFrame();
        ResourceValue topValue;

        topValue = frame.getTopValue();

        if (topValue.equals(ResourceValue.instance()))
            frame.setStatus(ResourceValueFrame.ESCAPED);
    } catch (DataflowAnalysisException e) {
        AnalysisContext.logError("Analysis error", e);
    }
}
 

import org.apache.bcel.generic.CHECKCAST; //导入依赖的package包/类
private void registerInstructionSources() throws DataflowAnalysisException {
    for (Iterator<Location> i = cfg.locationIterator(); i.hasNext();) {
        Location location = i.next();
        Instruction instruction = location.getHandle().getInstruction();
        short opcode = instruction.getOpcode();

        int produces = instruction.produceStack(cpg);
        if (instruction instanceof InvokeInstruction) {
            // Model return value
            registerReturnValueSource(location);
        } else if (opcode == Constants.GETFIELD || opcode == Constants.GETSTATIC) {
            // Model field loads
            registerFieldLoadSource(location);
        } else if (instruction instanceof LDC) {
            // Model constant values
            registerLDCValueSource(location);
        } else if (instruction instanceof LDC2_W) {
            // Model constant values
            registerLDC2ValueSource(location);
        } else if (instruction instanceof ConstantPushInstruction) {
            // Model constant values
            registerConstantPushSource(location);
        } else if (instruction instanceof ACONST_NULL) {
            // Model constant values
            registerPushNullSource(location);
        } else  if ((produces == 1 || produces == 2) && !(instruction instanceof LocalVariableInstruction) && !(instruction instanceof CHECKCAST)){
            // Model other sources
            registerOtherSource(location);
        }
    }
}
 

import org.apache.bcel.generic.CHECKCAST; //导入依赖的package包/类
/** Checks if the constraints of operands of the said instruction(s) are satisfied. */
public void visitCHECKCAST(CHECKCAST o){
	indexValid(o, o.getIndex());
	Constant c = cpg.getConstant(o.getIndex());
	if (!	(c instanceof ConstantClass)){
		constraintViolated(o, "Expecting a CONSTANT_Class operand, but found a '"+c+"'.");
	}
}
 

import org.apache.bcel.generic.CHECKCAST; //导入依赖的package包/类
/**
 * Checks that any store in this basic block to the specified variable is the
 * result of a new() or a null.
 * @param ih handle up to where to investigate.
 * @param localVarIndex the local variable index
 * @return true if all stores are OK or there are no stores.
 */
boolean noAliasesStoreWithIndexBefore(InstructionHandle ih, LocalVariableGen lg) {
    InstructionHandle prev = null;
    for (InstructionContext ic : instructions) {
        InstructionHandle current = ic.getInstruction();
        if (current.equals(ih)) {
            break;
        }

        if (methodGen.instructionStoresTo(current, lg.getIndex())) {
            LocalVariableGen l1 = methodGen.findLocalVar(current, lg.getIndex(), false);
            if (l1 != lg) {
                prev = current;
                continue;
            }
            if (prev != null) {
                Instruction i = prev.getInstruction();
                if (i instanceof INVOKESPECIAL) {
                    INVOKESPECIAL invoker = (INVOKESPECIAL) i;
                    if (invoker.getMethodName(methodGen.getConstantPool()).equals("<init>")
                        && isNonEscapingConstructor(invoker)) {
                        continue;
                    }
                }
                if (i instanceof CHECKCAST) {
            	InstructionHandle pp = prev.getPrev();
            	if (pp != null) {
            	    i = pp.getInstruction();
            	}
                }
                if (i instanceof NEWARRAY
                        || i instanceof ANEWARRAY || i instanceof MULTIANEWARRAY
                        || i instanceof ConstantPushInstruction || i instanceof ACONST_NULL) {
                     prev = current;
                     continue;
                }
            }
            return false;

        }
        prev = current;
    }
    return true;
}
 

import org.apache.bcel.generic.CHECKCAST; //导入依赖的package包/类
@SuppressWarnings("unused")
// Called using reflection
private Instruction createInstructionCheckcast(Element inst) throws IllegalXMLVMException {
    String classType = inst.getAttributeValue("type");
    return new CHECKCAST(constantPoolGen.addClass(classType));
}
 

import org.apache.bcel.generic.CHECKCAST; //导入依赖的package包/类
public boolean prescreen(ClassContext classContext, Method method) {
    BitSet bytecodeSet = classContext.getBytecodeSet(method);
    return bytecodeSet != null && (bytecodeSet.get(Constants.CHECKCAST) || bytecodeSet.get(Constants.INSTANCEOF));
}
 

import org.apache.bcel.generic.CHECKCAST; //导入依赖的package包/类
@Override
public void visitCHECKCAST(CHECKCAST obj) {
    // Do nothing
}
 

import org.apache.bcel.generic.CHECKCAST; //导入依赖的package包/类
public void visitCHECKCAST( CHECKCAST i ) {
    Type type = i.getType(_cp);
    _out.println("il.append(_factory.createCheckCast(" + BCELifier.printType(type) + "));");
}