org.jf.dexlib2.Opcode Java Examples

public ImmutableInstruction35c(@Nonnull Opcode opcode,
                               int registerCount,
                               int registerC,
                               int registerD,
                               int registerE,
                               int registerF,
                               int registerG,
                               @Nonnull Reference reference) {
    super(opcode);
    this.registerCount = Preconditions.check35cRegisterCount(registerCount);
    this.registerC = (registerCount>0) ? Preconditions.checkNibbleRegister(registerC) : 0;
    this.registerD = (registerCount>1) ? Preconditions.checkNibbleRegister(registerD) : 0;
    this.registerE = (registerCount>2) ? Preconditions.checkNibbleRegister(registerE) : 0;
    this.registerF = (registerCount>3) ? Preconditions.checkNibbleRegister(registerF) : 0;
    this.registerG = (registerCount>4) ? Preconditions.checkNibbleRegister(registerG) : 0;
    this.reference = ImmutableReferenceFactory.of(opcode.referenceType, reference);
}
 

private void analyzeInvokeObjectInitRange(@Nonnull AnalyzedInstruction analyzedInstruction, boolean analyzeResult) {
    Instruction3rc instruction = (Instruction3rc)analyzedInstruction.instruction;

    Instruction deodexedInstruction;

    int startRegister = instruction.getStartRegister();
    // hack: we should be using instruction.getRegisterCount, but some tweaked versions of dalvik appear
    // to generate invoke-object-init/range instructions with an invalid register count. We know it should
    // always be 1, so just use that.
    int registerCount = 1;
    if (startRegister < 16) {
        deodexedInstruction = new ImmutableInstruction35c(Opcode.INVOKE_DIRECT,
                registerCount, startRegister, 0, 0, 0, 0, instruction.getReference());
    } else {
        deodexedInstruction = new ImmutableInstruction3rc(Opcode.INVOKE_DIRECT_RANGE,
                startRegister, registerCount, instruction.getReference());
    }

    analyzedInstruction.setDeodexedInstruction(deodexedInstruction);

    if (analyzeResult) {
        analyzeInstruction(analyzedInstruction);
    }
}
 

private void analyzeExecuteInline(@Nonnull AnalyzedInstruction analyzedInstruction) {
    if (inlineResolver == null) {
        throw new AnalysisException("Cannot analyze an odexed instruction unless we are deodexing");
    }

    Instruction35mi instruction = (Instruction35mi)analyzedInstruction.instruction;
    Method resolvedMethod = inlineResolver.resolveExecuteInline(analyzedInstruction);

    Opcode deodexedOpcode;
    int acccessFlags = resolvedMethod.getAccessFlags();
    if (AccessFlags.STATIC.isSet(acccessFlags)) {
        deodexedOpcode = Opcode.INVOKE_STATIC;
    } else if (AccessFlags.PRIVATE.isSet(acccessFlags)) {
        deodexedOpcode = Opcode.INVOKE_DIRECT;
    } else {
        deodexedOpcode = Opcode.INVOKE_VIRTUAL;
    }

    Instruction35c deodexedInstruction = new ImmutableInstruction35c(deodexedOpcode, instruction.getRegisterCount(),
            instruction.getRegisterC(), instruction.getRegisterD(), instruction.getRegisterE(),
            instruction.getRegisterF(), instruction.getRegisterG(), resolvedMethod);

    analyzedInstruction.setDeodexedInstruction(deodexedInstruction);
    analyzeInstruction(analyzedInstruction);
}
 

private void analyzeExecuteInline(@Nonnull AnalyzedInstruction analyzedInstruction) {
    if (inlineResolver == null) {
        throw new AnalysisException("Cannot analyze an odexed instruction unless we are deodexing");
    }

    Instruction35mi instruction = (Instruction35mi)analyzedInstruction.instruction;
    Method resolvedMethod = inlineResolver.resolveExecuteInline(analyzedInstruction);

    Opcode deodexedOpcode;
    int acccessFlags = resolvedMethod.getAccessFlags();
    if (AccessFlags.STATIC.isSet(acccessFlags)) {
        deodexedOpcode = Opcode.INVOKE_STATIC;
    } else if (AccessFlags.PRIVATE.isSet(acccessFlags)) {
        deodexedOpcode = Opcode.INVOKE_DIRECT;
    } else {
        deodexedOpcode = Opcode.INVOKE_VIRTUAL;
    }

    Instruction35c deodexedInstruction = new ImmutableInstruction35c(deodexedOpcode, instruction.getRegisterCount(),
            instruction.getRegisterC(), instruction.getRegisterD(), instruction.getRegisterE(),
            instruction.getRegisterF(), instruction.getRegisterG(), resolvedMethod);

    analyzedInstruction.setDeodexedInstruction(deodexedInstruction);
    analyzeInstruction(analyzedInstruction);
}
 

@Nonnull
private BuilderInstruction31t newBuilderInstruction31t(@Nonnull MethodLocation location , int[] codeAddressToIndex,
                                                       @Nonnull Instruction31t instruction) {
    int codeAddress = location.getCodeAddress();
    Label newLabel;
    if (instruction.getOpcode() != Opcode.FILL_ARRAY_DATA) {
        // if it's a sparse switch or packed switch
        newLabel = newSwitchPayloadReferenceLabel(location, codeAddressToIndex, codeAddress + instruction.getCodeOffset());
    } else {
        newLabel = newLabel(codeAddressToIndex, codeAddress + instruction.getCodeOffset());
    }
    return new BuilderInstruction31t(
            instruction.getOpcode(),
            instruction.getRegisterA(),
            newLabel);
}
 

private void analyzeInvokeObjectInitRange(@Nonnull AnalyzedInstruction analyzedInstruction, boolean analyzeResult) {
    Instruction3rc instruction = (Instruction3rc)analyzedInstruction.instruction;

    Instruction deodexedInstruction;

    int startRegister = instruction.getStartRegister();
    // hack: we should be using instruction.getRegisterCount, but some tweaked versions of dalvik appear
    // to generate invoke-object-init/range instructions with an invalid register count. We know it should
    // always be 1, so just use that.
    int registerCount = 1;
    if (startRegister < 16) {
        deodexedInstruction = new ImmutableInstruction35c(Opcode.INVOKE_DIRECT,
                registerCount, startRegister, 0, 0, 0, 0, instruction.getReference());
    } else {
        deodexedInstruction = new ImmutableInstruction3rc(Opcode.INVOKE_DIRECT_RANGE,
                startRegister, registerCount, instruction.getReference());
    }

    analyzedInstruction.setDeodexedInstruction(deodexedInstruction);

    if (analyzeResult) {
        analyzeInstruction(analyzedInstruction);
    }
}
 

public ImmutableInstruction35ms(@Nonnull Opcode opcode,
                                int registerCount,
                                int registerC,
                                int registerD,
                                int registerE,
                                int registerF,
                                int registerG,
                                int vtableIndex) {
    super(opcode);
    this.registerCount = Preconditions.check35cRegisterCount(registerCount);
    this.registerC = (registerCount>0) ? Preconditions.checkNibbleRegister(registerC) : 0;
    this.registerD = (registerCount>1) ? Preconditions.checkNibbleRegister(registerD) : 0;
    this.registerE = (registerCount>2) ? Preconditions.checkNibbleRegister(registerE) : 0;
    this.registerF = (registerCount>3) ? Preconditions.checkNibbleRegister(registerF) : 0;
    this.registerG = (registerCount>4) ? Preconditions.checkNibbleRegister(registerG) : 0;
    this.vtableIndex = Preconditions.checkVtableIndex(vtableIndex);
}
 

private void analyzeExecuteInlineRange(@Nonnull AnalyzedInstruction analyzedInstruction) {
    if (inlineResolver == null) {
        throw new AnalysisException("Cannot analyze an odexed instruction unless we are deodexing");
    }

    Instruction3rmi instruction = (Instruction3rmi)analyzedInstruction.instruction;
    Method resolvedMethod = inlineResolver.resolveExecuteInline(analyzedInstruction);

    Opcode deodexedOpcode;
    int acccessFlags = resolvedMethod.getAccessFlags();
    if (AccessFlags.STATIC.isSet(acccessFlags)) {
        deodexedOpcode = Opcode.INVOKE_STATIC_RANGE;
    } else if (AccessFlags.PRIVATE.isSet(acccessFlags)) {
        deodexedOpcode = Opcode.INVOKE_DIRECT_RANGE;
    } else {
        deodexedOpcode = Opcode.INVOKE_VIRTUAL_RANGE;
    }

    Instruction3rc deodexedInstruction = new ImmutableInstruction3rc(deodexedOpcode, instruction.getStartRegister(),
            instruction.getRegisterCount(), resolvedMethod);

    analyzedInstruction.setDeodexedInstruction(deodexedInstruction);
    analyzeInstruction(analyzedInstruction);
}
 

private Instruction translateNew(final Instruction31t i1) {
    final Instruction i = new Instruction();
    i.opcode = Instruction.OP_NEW;
    i.opcode_aux = Instruction.OP_NEW_FILLED_ARRAY;
    i.rdst = (short) i1.getRegisterA();
    final int payloadAddress = currentCodeAddress + i1.getCodeOffset();
    PayloadInstruction p = payloadCache.get(payloadAddress);
    if (p != null) {
        checkState(p.getOpcode() == Opcode.ARRAY_PAYLOAD, "payload type mismatch");
        applyPayload(i, (ArrayPayload)p);
    } else {
        ArrayList<Instruction> defers = payloadDefers.get(payloadAddress);
        if (defers == null) {
            defers = new ArrayList<Instruction>();
            payloadDefers.put(payloadAddress, defers);
        }
        defers.add(i);
    }
    return i;
}
 

public ImmutableInstruction21ih(@Nonnull Opcode opcode,
                                int registerA,
                                int literal) {
    super(opcode);
    this.registerA = Preconditions.checkByteRegister(registerA);
    this.literal = Preconditions.checkIntegerHatLiteral(literal);
}
 

public BuilderInstruction22x(@Nonnull Opcode opcode,
                             int registerA,
                             int registerB) {
    super(opcode);
    this.registerA = Preconditions.checkByteRegister(registerA);
    this.registerB = Preconditions.checkShortRegister(registerB);
}
 

public ImmutableInstruction21ih(@Nonnull Opcode opcode,
                                int registerA,
                                int literal) {
    super(opcode);
    this.registerA = Preconditions.checkByteRegister(registerA);
    this.literal = Preconditions.checkIntegerHatLiteral(literal);
}
 

public ImmutableInstruction12x(@Nonnull Opcode opcode,
                               int registerA,
                               int registerB) {
    super(opcode);
    this.registerA = Preconditions.checkNibbleRegister(registerA);
    this.registerB = Preconditions.checkNibbleRegister(registerB);
}
 

public ImmutableInstruction23x(@Nonnull Opcode opcode,
                               int registerA,
                               int registerB,
                               int registerC) {
    super(opcode);
    this.registerA = Preconditions.checkByteRegister(registerA);
    this.registerB = Preconditions.checkByteRegister(registerB);
    this.registerC = Preconditions.checkByteRegister(registerC);
}
 

public ImmutableInstruction21ih(@Nonnull Opcode opcode,
                                int registerA,
                                int literal) {
    super(opcode);
    this.registerA = Preconditions.checkByteRegister(registerA);
    this.literal = Preconditions.checkIntegerHatLiteral(literal);
}
 

@Override
public void caseNewArrayExpr(NewArrayExpr nae) {
	Value size = nae.getSize();
	constantV.setOrigStmt(origStmt);
	Register sizeReg = regAlloc.asImmediate(size, constantV);
	ArrayType arrayType = nae.getBaseType().getArrayType();
	BuilderReference arrayTypeItem = DexPrinter.toTypeReference
			(arrayType, stmtV.getBelongingFile());
       stmtV.addInsn(new Insn22c(Opcode.NEW_ARRAY, destinationReg, sizeReg, arrayTypeItem), origStmt);
}
 

public BuilderInstruction23x(@Nonnull Opcode opcode,
                             int registerA,
                             int registerB,
                             int registerC) {
    super(opcode);
    this.registerA = Preconditions.checkByteRegister(registerA);
    this.registerB = Preconditions.checkByteRegister(registerB);
    this.registerC = Preconditions.checkByteRegister(registerC);
}
 

private void analyzeReturnVoidBarrier(@Nonnull AnalyzedInstruction analyzedInstruction, boolean analyzeResult) {
    Instruction10x deodexedInstruction = new ImmutableInstruction10x(Opcode.RETURN_VOID);

    analyzedInstruction.setDeodexedInstruction(deodexedInstruction);

    if (analyzeResult) {
        analyzeInstruction(analyzedInstruction);
    }
}
 

public ImmutableInstruction35c makeInstruction35c(@Nonnull Opcode opcode,
                                                  int registerCount,
                                                  int registerC,
                                                  int registerD,
                                                  int registerE,
                                                  int registerF,
                                                  int registerG,
                                                  @Nonnull Reference reference) {
    return new ImmutableInstruction35c(opcode, registerCount, registerC, registerD, registerE, registerF, registerG,
            reference);
}
 

public int 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 instructionOffsetMap.getInstructionCodeOffset(targetIndex);
                }
            }
        }
        throw new InvalidSwitchPayload(targetOffset);
    } else {
        return targetOffset;
    }
}
 

public BuilderInstruction22b(@Nonnull Opcode opcode,
                             int registerA,
                             int registerB,
                             int literal) {
    super(opcode);
    this.registerA = Preconditions.checkByteRegister(registerA);
    this.registerB = Preconditions.checkByteRegister(registerB);
    this.literal = Preconditions.checkByteLiteral(literal);
}
 

public BuilderInstruction31c(@Nonnull Opcode opcode,
                             int registerA,
                             @Nonnull Reference reference) {
    super(opcode);
    this.registerA = Preconditions.checkByteRegister(registerA);
    this.reference = reference;
}
 

private static int getOpcodeSubtype(@Nonnull Opcode opcode) {
    if (opcode.isOdexedInstanceQuick()) {
        return 0;
    } else if (opcode.isOdexedInstanceVolatile()) {
        return 1;
    } else if (opcode.isOdexedStaticVolatile()) {
        return 2;
    }
    throw new RuntimeException(String.format("Not an odexed field access opcode: %s", opcode.name));
}
 

public BuilderInstruction3rc(@Nonnull Opcode opcode,
                             int startRegister,
                             int registerCount,
                             @Nonnull Reference reference) {
    super(opcode);
    this.startRegister = Preconditions.checkShortRegister(startRegister);
    this.registerCount = Preconditions.checkRegisterRangeCount(registerCount);
    this.reference = reference;
}
 

private Insn buildSwitchInsn(Opcode opc, Value key, Stmt defaultTarget,
		SwitchPayload payload, Stmt stmt) {
	Register keyReg = regAlloc.asImmediate(key, constantV);
	Insn31t switchInsn = new Insn31t(opc, keyReg);
	switchInsn.setPayload(payload);
	payload.setSwitchInsn(switchInsn);
       addInsn(switchInsn, stmt);
	// create instruction to jump to the default target, always follows the switch instruction
	return buildGotoInsn(defaultTarget);
}
 

private static int getOpcodeSubtype(@Nonnull Opcode opcode) {
    if (opcode.isOdexedInstanceQuick()) {
        return 0;
    } else if (opcode.isOdexedInstanceVolatile()) {
        return 1;
    } else if (opcode.isOdexedStaticVolatile()) {
        return 2;
    }
    throw new RuntimeException(String.format("Not an odexed field access opcode: %s", opcode.name));
}
 

public ImmutableInstruction21c(@Nonnull Opcode opcode,
                                  int registerA,
                                  @Nonnull Reference reference) {
    super(opcode);
    this.registerA = Preconditions.checkByteRegister(registerA);
    this.reference = ImmutableReferenceFactory.of(opcode.referenceType, reference);
}
 

public ImmutableInstruction32x(@Nonnull Opcode opcode,
                               int registerA,
                               int registerB) {
    super(opcode);
    this.registerA = Preconditions.checkShortRegister(registerA);
    this.registerB = Preconditions.checkShortRegister(registerB);
}
 

private Insn buildStaticFieldPutInsn(StaticFieldRef destRef, Value source) {
	SootField destSootField = destRef.getField();
	Register sourceReg = regAlloc.asImmediate(source, constantV);
	BuilderFieldReference destField = DexPrinter.toFieldReference(destSootField, belongingFile);
	Opcode opc = getPutGetOpcodeWithTypeSuffix("sput", destField.getType());
	return new Insn21c(opc, sourceReg, destField);
}
 

public ImmutableInstruction22b(@Nonnull Opcode opcode,
                               int registerA,
                               int registerB,
                               int literal) {
    super(opcode);
    this.registerA = Preconditions.checkByteRegister(registerA);
    this.registerB = Preconditions.checkByteRegister(registerB);
    this.literal = Preconditions.checkByteLiteral(literal);
}