public DexBackedMethod(@Nonnull DexReader reader, @Nonnull DexBackedClassDef classDef, int previousMethodIndex) { this.dexFile = reader.dexBuf; this.classDef = classDef; startOffset = reader.getOffset(); // large values may be used for the index delta, which cause the cumulative index to overflow upon // addition, effectively allowing out of order entries. int methodIndexDiff = reader.readLargeUleb128(); this.methodIndex = methodIndexDiff + previousMethodIndex; this.accessFlags = reader.readSmallUleb128(); this.codeOffset = reader.readSmallUleb128(); this.methodAnnotationSetOffset = 0; this.parameterAnnotationSetListOffset = 0; }
@Override protected String readNextItem(@Nonnull DexReader reader, int index) { int length = reader.readInt(); int offset = reader.getOffset(); reader.moveRelative(length + 20); try { return new String(DexBackedOdexFile.this.buf, offset, length-1, "US-ASCII"); } catch (UnsupportedEncodingException ex) { throw new RuntimeException(ex); } } };
public static String asString(@Nonnull DexReader reader) { int valueArgType = reader.readUbyte(); int intValue = reader.readByte(); return String.format("0x%x", intValue); case ValueType.SHORT: intValue = reader.readSizedInt(valueArg+1); return String.format("0x%x", intValue); case ValueType.CHAR: intValue = reader.readSizedSmallUint(valueArg+1); return String.format("0x%x", intValue); case ValueType.INT: intValue = reader.readSizedInt(valueArg+1); return String.format("0x%x", intValue); case ValueType.LONG: long longValue = reader.readSizedLong(valueArg+1); return String.format("0x%x", longValue); case ValueType.FLOAT: float floatValue = Float.intBitsToFloat(reader.readSizedRightExtendedInt(valueArg + 1)); return String.format("%f", floatValue); case ValueType.DOUBLE: double doubleValue = Double.longBitsToDouble(reader.readSizedRightExtendedLong(valueArg + 1)); return String.format("%f", doubleValue); case ValueType.METHOD_TYPE: int protoIndex = reader.readSizedSmallUint(valueArg + 1); return ProtoIdItem.getReferenceAnnotation(reader.dexBuf, protoIndex); case ValueType.STRING: int stringIndex = reader.readSizedSmallUint(valueArg + 1); return StringIdItem.getReferenceAnnotation(reader.dexBuf, stringIndex, true); case ValueType.TYPE:
int registers = reader.readUshort(); out.annotate(2, "registers_size = %d", registers); int inSize = reader.readUshort(); out.annotate(2, "ins_size = %d", inSize); int outSize = reader.readUshort(); out.annotate(2, "outs_size = %d", outSize); int triesCount = reader.readUshort(); out.annotate(2, "tries_size = %d", triesCount); int debugInfoOffset = reader.readInt(); out.annotate(4, "debug_info_off = 0x%x", debugInfoOffset); int instructionSize = reader.readSmallUint(); out.annotate(4, "insns_size = 0x%x", instructionSize); int end = reader.getOffset() + instructionSize*2; try { while (reader.getOffset() < end) { Instruction instruction = DexBackedInstruction.readFrom(reader); if (reader.getOffset() > end) { out.annotateTo(end, "truncated instruction"); reader.setOffset(end); } else { switch (instruction.getOpcode().format) {
int lineStart = reader.readBigUleb128(); out.annotateTo(reader.getOffset(), "line_start = %d", lineStart & 0xFFFFFFFFL); int parametersSize = reader.readSmallUleb128(); out.annotateTo(reader.getOffset(), "parameters_size = %d", parametersSize); out.indent(); for (int i=0; i<parametersSize; i++) { int paramaterIndex = reader.readSmallUleb128() - 1; out.annotateTo(reader.getOffset(), "%s", StringIdItem.getOptionalReferenceAnnotation(dexFile, paramaterIndex, true)); int opcode = reader.readUbyte(); switch (opcode) { case DebugItemType.END_SEQUENCE: { out.annotateTo(reader.getOffset(), "DBG_END_SEQUENCE"); break loop; out.annotateTo(reader.getOffset(), "DBG_ADVANCE_PC"); out.indent(); int addressDiff = reader.readSmallUleb128(); codeAddress += addressDiff; out.annotateTo(reader.getOffset(), "addr_diff = +0x%x: 0x%x", addressDiff, codeAddress); out.deindent(); out.annotateTo(reader.getOffset(), "DBG_ADVANCE_LINE"); out.indent(); int lineDiff = reader.readSleb128();
public DexBackedClassDef(@Nonnull DexBackedDexFile dexFile, int classDefOffset) { this.dexFile = dexFile; this.classDefOffset = classDefOffset; int classDataOffset = dexFile.readSmallUint(classDefOffset + ClassDefItem.CLASS_DATA_OFFSET); if (classDataOffset == 0) { staticFieldsOffset = -1; staticFieldCount = 0; instanceFieldCount = 0; directMethodCount = 0; virtualMethodCount = 0; } else { DexReader reader = dexFile.readerAt(classDataOffset); staticFieldCount = reader.readSmallUleb128(); instanceFieldCount = reader.readSmallUleb128(); directMethodCount = reader.readSmallUleb128(); virtualMethodCount = reader.readSmallUleb128(); staticFieldsOffset = reader.getOffset(); } }
@Nonnull public static Instruction readFrom(@Nonnull DexReader reader) { int opcodeValue = reader.peekUbyte(); if (opcodeValue == 0) { opcodeValue = reader.peekUshort(); } Opcode opcode = reader.dexBuf.getOpcodes().getOpcodeByValue(opcodeValue); Instruction instruction = buildInstruction(reader.dexBuf, opcode, reader.getOffset()); reader.moveRelative(instruction.getCodeUnits()*2); return instruction; }
public static void skipFrom(@Nonnull DexReader reader) { int startOffset = reader.getOffset(); int b = reader.readUbyte(); int valueType = b & 0x1f; reader.skipByte(); break; case ValueType.SHORT: case ValueType.METHOD_TYPE: int valueArg = b >>> 5; reader.moveRelative(valueArg+1); break; case ValueType.ARRAY:
int size = 0; DexReader reader = dexFile.readerAt(startOffset); reader.readLargeUleb128(); //field_idx_diff reader.readSmallUleb128(); //access_flags size += reader.getOffset() - startOffset; reader.setOffset(initialValueOffset); if (initialValue != null) { DexBackedEncodedValue.skipFrom(reader); size += reader.getOffset() - initialValueOffset;
@Override protected void annotateItem(@Nonnull AnnotatedBytes out, int itemIndex, @Nullable String itemIdentity) { DexReader reader = dexFile.readerAt(out.getCursor()); int utf16Length = reader.readSmallUleb128(); out.annotateTo(reader.getOffset(), "utf16_size = %d", utf16Length); String value = reader.readString(utf16Length); out.annotateTo(reader.getOffset() + 1, "data = \"%s\"", StringUtils.escapeString(value)); } };
public DexBackedAnnotation(@Nonnull DexBackedDexFile dexFile, int annotationOffset) { this.dexFile = dexFile; DexReader reader = dexFile.readerAt(annotationOffset); this.visibility = reader.readUbyte(); this.typeIndex = reader.readSmallUleb128(); this.elementsOffset = reader.getOffset(); }
public DexBackedMethod(@Nonnull DexReader reader, @Nonnull DexBackedClassDef classDef, int previousMethodIndex) { this.dexFile = reader.dexBuf; this.classDef = classDef; // large values may be used for the index delta, which cause the cumulative index to overflow upon // addition, effectively allowing out of order entries. int methodIndexDiff = reader.readLargeUleb128(); this.methodIndex = methodIndexDiff + previousMethodIndex; this.accessFlags = reader.readSmallUleb128(); this.codeOffset = reader.readSmallUleb128(); Logger.log("the codeoffset :" +this.codeOffset); this.methodAnnotationSetOffset = 0; this.parameterAnnotationSetListOffset = 0; }
public DexBackedTypedExceptionHandler(@Nonnull DexReader reader) { this.dexFile = reader.dexBuf; this.typeId = reader.readSmallUleb128(); this.handlerCodeAddress = reader.readSmallUleb128(); }
@Nonnull public String getString(int stringIndex) { int stringOffset = getStringIdItemOffset(stringIndex); int stringDataOffset = readSmallUint(stringOffset); DexReader reader = readerAt(stringDataOffset); int utf16Length = reader.readSmallUleb128(); return reader.readString(utf16Length); }
public static void skipFrom(@Nonnull DexReader reader) { reader.skipUleb128(); // type int elementCount = reader.readSmallUleb128(); skipElements(reader, elementCount); }
/** * Calculate and return the private size of a string reference. * * Calculated as: string_data_off + string_data_item size * * @return size in bytes */ public int getSize() { int size = StringIdItem.ITEM_SIZE; //uint for string_data_off //add the string data length: int stringOffset = dexFile.getStringIdItemOffset(stringIndex); int stringDataOffset = dexFile.readSmallUint(stringOffset); DexReader reader = dexFile.readerAt(stringDataOffset); size += reader.peekSmallUleb128Size(); int utf16Length = reader.readSmallUleb128(); //and string data itself: size += reader.peekStringLength(utf16Length); return size; } }
if (staticInitialValuesOffset != 0) { DexReader reader = dexFile.readerAt(staticInitialValuesOffset); size += reader.peekSmallUleb128Size(); //encoded_array size field if (classDataOffset > 0) { DexReader reader = dexFile.readerAt(classDataOffset); reader.readSmallUleb128(); //staticFieldCount reader.readSmallUleb128(); //instanceFieldCount reader.readSmallUleb128(); //directMethodCount reader.readSmallUleb128(); //virtualMethodCount size += reader.getOffset() - classDataOffset;
private int getDirectMethodsOffset() { if (directMethodsOffset > 0) { return directMethodsOffset; } DexReader reader = dexFile.readerAt(getInstanceFieldsOffset()); DexBackedField.skipFields(reader, instanceFieldCount); directMethodsOffset = reader.getOffset(); return directMethodsOffset; }
public Iterator<DebugItem> iterator() { DexReader reader = dexFile.readerAt(debugInfoOffset); final int lineNumberStart = reader.readBigUleb128(); int registerCount = methodImpl.getRegisterCount(); return new VariableSizeLookaheadIterator<DebugItem>(dexFile, reader.getOffset()) { private int codeAddress = 0; private int lineNumber = lineNumberStart;