import org.jf.dexlib2.iface.instruction.formats.PackedSwitchPayload; //导入依赖的package包/类
@Nonnull
private BuilderPackedSwitchPayload newBuilderPackedSwitchPayload(@Nonnull MethodLocation location,
                                                                 @Nonnull int[] codeAddressToIndex,
                                                                 @Nonnull PackedSwitchPayload instruction) {
    List<? extends SwitchElement> switchElements = instruction.getSwitchElements();
    if (switchElements.size() == 0) {
        return new BuilderPackedSwitchPayload(0, null);
    }

    MethodLocation switchLocation = findSwitchForPayload(location);
    int baseAddress;
    if (switchLocation == null) {
        baseAddress = 0;
    } else {
        baseAddress = switchLocation.codeAddress;
    }

    List<Label> labels = Lists.newArrayList();
    for (SwitchElement element : switchElements) {
        labels.add(newLabel(codeAddressToIndex, element.getOffset() + baseAddress));
    }

    return new BuilderPackedSwitchPayload(switchElements.get(0).getKey(), labels);
}
 

import org.jf.dexlib2.iface.instruction.formats.PackedSwitchPayload; //导入依赖的package包/类
public static InstructionMethodItem makeInstructionFormatMethodItem(
        MethodDefinition methodDef, int codeAddress, Instruction instruction) {

    if (instruction instanceof OffsetInstruction) {
        return new OffsetInstructionFormatMethodItem(methodDef.classDef.options, methodDef, codeAddress,
                (OffsetInstruction)instruction);
    }

    if (instruction instanceof UnresolvedOdexInstruction) {
        return new UnresolvedOdexInstructionMethodItem(methodDef, codeAddress,
                (UnresolvedOdexInstruction)instruction);
    }

    switch (instruction.getOpcode().format) {
        case ArrayPayload:
            return new ArrayDataMethodItem(methodDef, codeAddress, (ArrayPayload)instruction);
        case PackedSwitchPayload:
            return new PackedSwitchMethodItem(methodDef, codeAddress, (PackedSwitchPayload)instruction);
        case SparseSwitchPayload:
            return new SparseSwitchMethodItem(methodDef, codeAddress, (SparseSwitchPayload)instruction);
        default:
            return new InstructionMethodItem<Instruction>(methodDef, codeAddress, instruction);
    }
}
 

import org.jf.dexlib2.iface.instruction.formats.PackedSwitchPayload; //导入依赖的package包/类
protected Stmt switchStatement(DexBody body, Instruction targetData, Local key) {
     PackedSwitchPayload i = (PackedSwitchPayload) targetData;
     List<? extends SwitchElement> seList = i.getSwitchElements();

     // the default target always follows the switch statement
     int defaultTargetAddress = codeAddress + instruction.getCodeUnits();
     Unit defaultTarget = body.instructionAtAddress(defaultTargetAddress).getUnit();

     List<IntConstant> lookupValues = new ArrayList<IntConstant>();
     List<Unit> targets = new ArrayList<Unit>();
     for(SwitchElement se: seList) {
       lookupValues.add(IntConstant.v(se.getKey()));
       int offset = se.getOffset();
       targets.add(body.instructionAtAddress(codeAddress + offset).getUnit());
     }
     switchStmt = Jimple.v().newLookupSwitchStmt(key, lookupValues, targets, defaultTarget);
     setUnit(switchStmt);
     
     if (IDalvikTyper.ENABLE_DVKTYPER) {
Debug.printDbg(IDalvikTyper.DEBUG, "constraint: "+ switchStmt);
         DalvikTyper.v().setType(switchStmt.getKeyBox(), IntType.v(), true);
     }
     
     return switchStmt;
 }
 

import org.jf.dexlib2.iface.instruction.formats.PackedSwitchPayload; //导入依赖的package包/类
public void write(@Nonnull PackedSwitchPayload instruction) {
    try {
        writer.writeUbyte(0);
        writer.writeUbyte(instruction.getOpcode().value >> 8);
        List<? extends SwitchElement> elements = instruction.getSwitchElements();
        writer.writeUshort(elements.size());
        if (elements.size() == 0) {
            writer.writeInt(0);
        } else {
            writer.writeInt(elements.get(0).getKey());
            for (SwitchElement element : elements) {
                writer.writeInt(element.getOffset());
            }
        }
    } catch (IOException ex) {
        throw new RuntimeException(ex);
    }
}
 

import org.jf.dexlib2.iface.instruction.formats.PackedSwitchPayload; //导入依赖的package包/类
@Nonnull
public static ImmutablePackedSwitchPayload of(PackedSwitchPayload instruction) {
    if (instruction instanceof ImmutablePackedSwitchPayload) {
        return (ImmutablePackedSwitchPayload)instruction;
    }
    return new ImmutablePackedSwitchPayload(
            instruction.getSwitchElements());
}
 

import org.jf.dexlib2.iface.instruction.formats.PackedSwitchPayload; //导入依赖的package包/类
public static ImmutablePackedSwitchPayload of(PackedSwitchPayload instruction) {
    if (instruction instanceof ImmutablePackedSwitchPayload) {
        return (ImmutablePackedSwitchPayload)instruction;
    }
    return new ImmutablePackedSwitchPayload(
            instruction.getSwitchElements());
}
 

import org.jf.dexlib2.iface.instruction.formats.PackedSwitchPayload; //导入依赖的package包/类
@Nonnull
public static ImmutablePackedSwitchPayload of(PackedSwitchPayload instruction) {
    if (instruction instanceof ImmutablePackedSwitchPayload) {
        return (ImmutablePackedSwitchPayload) instruction;
    }
    return new ImmutablePackedSwitchPayload(
            instruction.getSwitchElements());
}
 

import org.jf.dexlib2.iface.instruction.formats.PackedSwitchPayload; //导入依赖的package包/类
private static int calculateComplexity(@Nonnull DexBackedMethodImplementation implementation) {
    // Cyclomatic complexity = <branches> - <exits> + 2
    int branches = 0;
    int exits = 0;
    for (Instruction instruction : implementation.getInstructions()) {
        switch (instruction.getOpcode()) {
            case IF_EQ:
            case IF_EQZ:
            case IF_GE:
            case IF_GEZ:
            case IF_GT:
            case IF_GTZ:
            case IF_LE:
            case IF_LEZ:
            case IF_LT:
            case IF_LTZ:
            case IF_NE:
            case IF_NEZ:
                branches += 2;
                break;
            case PACKED_SWITCH_PAYLOAD:
                branches += ((PackedSwitchPayload) instruction).getSwitchElements().size();
                break;
            case RETURN:
            case RETURN_OBJECT:
            case RETURN_VOID:
            case RETURN_VOID_BARRIER:
            case RETURN_VOID_NO_BARRIER:
            case RETURN_WIDE:
                exits += 1;
                break;
            case SPARSE_SWITCH_PAYLOAD:
                branches += ((SparseSwitchPayload) instruction).getSwitchElements().size();
                break;
            case THROW:
            case THROW_VERIFICATION_ERROR:
                exits += 1;
                break;
        }
    }
    return branches - exits + 2;
}