Java Instruction类代码示例

import org.jf.dexlib2.iface.instruction.Instruction; //导入依赖的package包/类
public LinkedHashMap<String,BundleListing.BundleInfo>read(String className,String memberName) throws Exception {

        if (reader!= null) {
            Method method = (Method) reader.read(className, memberName);
            if (method!= null){
                Iterable<? extends Instruction> instructions = method.getImplementation().getInstructions();
                for (Instruction instruction:instructions){
                    if (instruction instanceof ReferenceInstruction){
                        if (((ReferenceInstruction) instruction).getReferenceType()== 0){
                            StringReference s = (StringReference) ((ReferenceInstruction) instruction).getReference();
                            return BundleListingUtil.parseArray(s.getString(), (LinkedHashMap<String, BundleListing.BundleInfo>) map);
                        }
                    }
                }
            }
        }
        return null;
    }
 

import org.jf.dexlib2.iface.instruction.Instruction; //导入依赖的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.Instruction; //导入依赖的package包/类
private void fixInstructions(@Nonnull MutableMethodImplementation methodImplementation) {
    List<? extends Instruction> instructions = methodImplementation.getInstructions();

    for (int i=0; i<instructions.size(); i++) {
        Instruction instruction = instructions.get(i);

        if (instruction.getOpcode() == Opcode.CONST_STRING) {
            if (stringSection.getItemIndex(
                    (StringRef)((ReferenceInstruction)instruction).getReference()) >= 65536) {
                methodImplementation.replaceInstruction(i, new BuilderInstruction31c(Opcode.CONST_STRING_JUMBO,
                        ((OneRegisterInstruction)instruction).getRegisterA(),
                        ((ReferenceInstruction)instruction).getReference()));
            }
        }
    }
}
 

import org.jf.dexlib2.iface.instruction.Instruction; //导入依赖的package包/类
@Nonnull @Override public Instruction rewrite(@Nonnull Instruction instruction) {
    if (instruction instanceof ReferenceInstruction) {
        switch (instruction.getOpcode().format) {
            case Format20bc:
                return new RewrittenInstruction20bc((Instruction20bc)instruction);
            case Format21c:
                return new RewrittenInstruction21c((Instruction21c)instruction);
            case Format22c:
                return new RewrittenInstruction22c((Instruction22c)instruction);
            case Format31c:
                return new RewrittenInstruction31c((Instruction31c)instruction);
            case Format35c:
                return new RewrittenInstruction35c((Instruction35c)instruction);
            case Format3rc:
                return new RewrittenInstruction3rc((Instruction3rc)instruction);
            default:
                throw new IllegalArgumentException();
        }
    }
    return instruction;
}
 

import org.jf.dexlib2.iface.instruction.Instruction; //导入依赖的package包/类
private void visitAndset(IRegion root, BitSet live) {
    ((AbstractRegion)root).remove(AFlag.REMOVE_FOR_FLAT);
    if (root.getChildren() != null) {
        List<IRegion> children = root.getChildren();
        for (int i = children.size() - 1; i >= 0; i--) {
            visitAndset(children.get(i), live);
        }
    }

    if (root instanceof Region) {
        InsnNode node = ((Region) root).getInsn();
        Instruction insn = node.getInstruction().getInstruction();
        if (insn != null) {
            if (insn.getOpcode().setsRegister()) {
                int registernum = ((OneRegisterInstruction) insn).getRegisterA();
                live.clear(registernum);
                if (insn.getOpcode().setsWideRegister())
                    live.clear(registernum + 1);
            }
            LiveVarVisitor.setUse(insn, live);
        }
    }
}
 

import org.jf.dexlib2.iface.instruction.Instruction; //导入依赖的package包/类
private void doSimplify(IRegion region, BlockNode newBlock, MulRegion newRegion) {
        if (region instanceof Region) {
            MethodLocation location = ((Region) region).getInsn().getInstruction();
            if (!((Region) region).contains(AFlag.REMOVE_FOR_FLAT)) {
                Instruction insn = location.getInstruction();
                if (insn != null) {
//                    System.out.println(insn.getOpcode().name);
                    newRegion.addChild(region);
//                    newBlock.getInstructions().add(((Region) region).getInsn().getInstruction());
                }
            } else {
                if (!remover.contains(location))
                    remover.add(location);
            }
        }

        newBlock.mergeinto(region.getBlock());

        if (region.getChildren() != null) {
            for (IRegion child : region.getChildren()) {
                doSimplify(child, newBlock, newRegion);
            }
        }
    }
 

import org.jf.dexlib2.iface.instruction.Instruction; //导入依赖的package包/类
private void visitAndset(IRegion root, BitSet live) {
    //clear flag
    ((AbstractRegion)root).remove(AFlag.REMOVE_FOR_FLAT);
    if (root.getChildren() != null) {
        List<IRegion> children = root.getChildren();
        for (int i = children.size() - 1; i >= 0; i--) {
            visitAndset(children.get(i), live);
        }
    }

    if (root instanceof Region) {
        InsnNode node = ((Region) root).getInsn();
        Instruction insn = node.getInstruction().getInstruction();
        if (insn != null) {
            if (insn.getOpcode().setsRegister()) {
                int registernum = ((OneRegisterInstruction) insn).getRegisterA();
                live.clear(registernum);
                if (insn.getOpcode().setsWideRegister())
                    live.clear(registernum + 1);
            }
            LiveVarVisitor.setUse(insn, live);
        }
    }
}
 

import org.jf.dexlib2.iface.instruction.Instruction; //导入依赖的package包/类
private void analyze(@Nonnull DexBackedMethodImplementation implementation) {
    cyclomaticComplexity = calculateComplexity(implementation);
    registerCount = implementation.getRegisterCount();
    tryCatchCount = implementation.getTryBlocks().size();
    debugItemCount = Utils.makeCollection(implementation.getDebugItems()).size();

    for (Instruction instruction : implementation.getInstructions()) {
        instructionCount++;
        Opcode op = instruction.getOpcode();
        opCounts.adjustOrPutValue(op, 1, 1);

        if (instruction instanceof ReferenceInstruction) {
            ReferenceInstruction refInstr = (ReferenceInstruction) instruction;
            switch (op.referenceType) {
                case ReferenceType.METHOD:
                    MethodReference methodRef = (MethodReference) refInstr.getReference();
                    if (fullMethodSignatures) {
                        apiCounts.adjustOrPutValue(methodRef, 1, 1);
                    } else {
                        ShortMethodReference shortMethodRef = new ShortMethodReference(methodRef);
                        apiCounts.adjustOrPutValue(shortMethodRef, 1, 1);
                    }
                    break;
                case ReferenceType.FIELD:
                    FieldReference fieldRef = (FieldReference) refInstr.getReference();
                    fieldReferenceCounts.adjustOrPutValue(fieldRef, 1, 1);
                    break;
                case ReferenceType.STRING:
                    StringReference stringRef = (StringReference) refInstr.getReference();
                    stringReferenceCounts.adjustOrPutValue(stringRef, 1, 1);
                    break;
            }
        }
    }
}
 

import org.jf.dexlib2.iface.instruction.Instruction; //导入依赖的package包/类
/**
 * 比较method重的tryBlock块
 *
 * @param a
 * @param b
 * @return
 */
private static boolean equalsInstruction(List<Instruction> a, List<Instruction> b) {
    if (a.size() != b.size()) {
        return false;
    }
    Instruction at, bt;
    for (int i = 0; i < a.size(); i++) {
        at = a.get(i);
        bt = b.get(i);
        if (!at.getOpcode().equals(bt.getOpcode()) || !(at.getCodeUnits() == bt.getCodeUnits())) {
            return false;
        }
    }
    return true;
}
 

import org.jf.dexlib2.iface.instruction.Instruction; //导入依赖的package包/类
@Override
protected MethodImplementation reMethodImpl(MethodImplementation methodImplementation) {
    if (methodImplementation == null){
        return null;
    }
    Iterable<? extends Instruction> instructions = methodImplementation.getInstructions();
    Iterable<? extends DebugItem> debugItems = methodImplementation.getDebugItems();
    List<? extends TryBlock<? extends ExceptionHandler>> tryBlocks = methodImplementation.getTryBlocks();
    return new ImmutableMethodImplementation(methodImplementation.getRegisterCount(), reInstructions(instructions), reTryCatchBlock(methodImplementation.getTryBlocks()), reDebugItem(methodImplementation.getDebugItems()));

}
 

import org.jf.dexlib2.iface.instruction.Instruction; //导入依赖的package包/类
public Instruction findSwitchPayload(int targetOffset, Opcode type) {
    int targetIndex;
    try {
        targetIndex = instructionOffsetMap.getInstructionIndexAtCodeOffset(targetOffset);
    } catch (InvalidInstructionOffset ex) {
        throw new InvalidSwitchPayload(targetOffset);
    }

    //TODO: does dalvik let you pad with multiple nops?
    //TODO: does dalvik let a switch instruction point to a non-payload instruction?

    Instruction instruction = instructions.get(targetIndex);
    if (instruction.getOpcode() != type) {
        // maybe it's pointing to a NOP padding instruction. Look at the next instruction
        if (instruction.getOpcode() == Opcode.NOP) {
            targetIndex += 1;
            if (targetIndex < instructions.size()) {
                instruction = instructions.get(targetIndex);
                if (instruction.getOpcode() == type) {
                    return instruction;
                }
            }
        }
        throw new InvalidSwitchPayload(targetOffset);
    } else {
        return instruction;
    }
}
 

import org.jf.dexlib2.iface.instruction.Instruction; //导入依赖的package包/类
public int findPayloadOffset(int targetOffset, Opcode type) {
    int targetIndex;
    try {
        targetIndex = instructionOffsetMap.getInstructionIndexAtCodeOffset(targetOffset);
    } catch (InvalidInstructionOffset ex) {
        throw new InvalidSwitchPayload(targetOffset);
    }

    //TODO: does dalvik let you pad with multiple nops?
    //TODO: does dalvik let a switch instruction point to a non-payload instruction?

    Instruction instruction = instructions.get(targetIndex);
    if (instruction.getOpcode() != type) {
        // maybe it's pointing to a NOP padding instruction. Look at the next instruction
        if (instruction.getOpcode() == Opcode.NOP) {
            targetIndex += 1;
            if (targetIndex < instructions.size()) {
                instruction = instructions.get(targetIndex);
                if (instruction.getOpcode() == type) {
                    return instructionOffsetMap.getInstructionCodeOffset(targetIndex);
                }
            }
        }
        throw new InvalidSwitchPayload(targetOffset);
    } else {
        return targetOffset;
    }
}
 

import org.jf.dexlib2.iface.instruction.Instruction; //导入依赖的package包/类
private boolean needsAnalyzed() {
    for (Instruction instruction : methodImpl.getInstructions()) {
        if (instruction.getOpcode().odexOnly()) {
            return true;
        }
    }
    return false;
}
 

import org.jf.dexlib2.iface.instruction.Instruction; //导入依赖的package包/类
public ImmutableMethodImplementation(int registerCount,
                                     @Nullable Iterable<? extends Instruction> instructions,
                                     @Nullable List<? extends TryBlock<? extends ExceptionHandler>> tryBlocks,
                                     @Nullable Iterable<? extends DebugItem> debugItems) {
    this.registerCount = registerCount;
    this.instructions = ImmutableInstruction.immutableListOf(instructions);
    this.tryBlocks = ImmutableTryBlock.immutableListOf(tryBlocks);
    this.debugItems = ImmutableDebugItem.immutableListOf(debugItems);
}
 

import org.jf.dexlib2.iface.instruction.Instruction; //导入依赖的package包/类
@Nullable @Override public Iterable<? extends Instruction> getInstructions(@Nonnull PoolMethod method) {
    MethodImplementation impl = method.getImplementation();
    if (impl != null) {
        return impl.getInstructions();
    }
    return null;
}