Examples with DexReader org.jf.dexlib2.dexbacked.DexReader used on opensource projects

Example 16 with DexReader

use of org.jf.dexlib2.dexbacked.DexReader in project smali by JesusFreke.

the class DexBackedField method getSize.

/**
 * Calculate and return the private size of a field definition.
 *
 * Calculated as: field_idx_diff + access_flags + annotations overhead +
 * initial value size + field reference size
 *
 * @return size in bytes
 */
public int getSize() {
    int size = 0;
    DexReader reader = dexFile.getBuffer().readerAt(startOffset);
    // field_idx_diff
    reader.readLargeUleb128();
    // access_flags
    reader.readSmallUleb128();
    size += reader.getOffset() - startOffset;
    Set<? extends DexBackedAnnotation> annotations = getAnnotations();
    if (!annotations.isEmpty()) {
        // 2 * uint overhead from field_annotation
        size += 2 * 4;
    }
    if (initialValueOffset > 0) {
        reader.setOffset(initialValueOffset);
        if (initialValue != null) {
            DexBackedEncodedValue.skipFrom(reader);
            size += reader.getOffset() - initialValueOffset;
        }
    }
    DexBackedFieldReference fieldRef = new DexBackedFieldReference(dexFile, fieldIndex);
    size += fieldRef.getSize();
    return size;
}

Example 17 with DexReader

use of org.jf.dexlib2.dexbacked.DexReader in project smali by JesusFreke.

the class DexBackedMethodImplementation method getInstructions.

@Nonnull
@Override
public Iterable<? extends Instruction> getInstructions() {
    // instructionsSize is the number of 16-bit code units in the instruction list, not the number of instructions
    int instructionsSize = getInstructionsSize();
    final int instructionsStartOffset = getInstructionsStartOffset();
    final int endOffset = instructionsStartOffset + (instructionsSize * 2);
    return new Iterable<Instruction>() {

        @Override
        public Iterator<Instruction> iterator() {
            return new VariableSizeLookaheadIterator<Instruction>(dexFile.getDataBuffer(), instructionsStartOffset) {

                @Override
                protected Instruction readNextItem(@Nonnull DexReader reader) {
                    if (reader.getOffset() >= endOffset) {
                        return endOfData();
                    }
                    Instruction instruction = DexBackedInstruction.readFrom(dexFile, reader);
                    // Does the instruction extend past the end of the method?
                    int offset = reader.getOffset();
                    if (offset > endOffset || offset < 0) {
                        throw new ExceptionWithContext("The last instruction in method %s is truncated", method);
                    }
                    return instruction;
                }
            };
        }
    };
}

Example 18 with DexReader

use of org.jf.dexlib2.dexbacked.DexReader in project smali by JesusFreke.

the class ClassDataItem method makeAnnotator.

@Nonnull
public static SectionAnnotator makeAnnotator(@Nonnull DexAnnotator annotator, @Nonnull MapItem mapItem) {
    return new SectionAnnotator(annotator, mapItem) {

        private SectionAnnotator codeItemAnnotator = null;

        @Override
        public void annotateSection(@Nonnull AnnotatedBytes out) {
            codeItemAnnotator = annotator.getAnnotator(ItemType.CODE_ITEM);
            super.annotateSection(out);
        }

        @Nonnull
        @Override
        public String getItemName() {
            return "class_data_item";
        }

        @Override
        protected void annotateItem(@Nonnull AnnotatedBytes out, int itemIndex, @Nullable String itemIdentity) {
            DexReader reader = dexFile.getBuffer().readerAt(out.getCursor());
            int staticFieldsSize = reader.readSmallUleb128();
            out.annotateTo(reader.getOffset(), "static_fields_size = %d", staticFieldsSize);
            int instanceFieldsSize = reader.readSmallUleb128();
            out.annotateTo(reader.getOffset(), "instance_fields_size = %d", instanceFieldsSize);
            int directMethodsSize = reader.readSmallUleb128();
            out.annotateTo(reader.getOffset(), "direct_methods_size = %d", directMethodsSize);
            int virtualMethodsSize = reader.readSmallUleb128();
            out.annotateTo(reader.getOffset(), "virtual_methods_size = %d", virtualMethodsSize);
            int previousIndex = 0;
            if (staticFieldsSize > 0) {
                out.annotate(0, "static_fields:");
                out.indent();
                for (int i = 0; i < staticFieldsSize; i++) {
                    out.annotate(0, "static_field[%d]", i);
                    out.indent();
                    previousIndex = annotateEncodedField(out, dexFile, reader, previousIndex);
                    out.deindent();
                }
                out.deindent();
            }
            if (instanceFieldsSize > 0) {
                out.annotate(0, "instance_fields:");
                out.indent();
                previousIndex = 0;
                for (int i = 0; i < instanceFieldsSize; i++) {
                    out.annotate(0, "instance_field[%d]", i);
                    out.indent();
                    previousIndex = annotateEncodedField(out, dexFile, reader, previousIndex);
                    out.deindent();
                }
                out.deindent();
            }
            if (directMethodsSize > 0) {
                out.annotate(0, "direct_methods:");
                out.indent();
                previousIndex = 0;
                for (int i = 0; i < directMethodsSize; i++) {
                    out.annotate(0, "direct_method[%d]", i);
                    out.indent();
                    previousIndex = annotateEncodedMethod(out, dexFile, reader, previousIndex);
                    out.deindent();
                }
                out.deindent();
            }
            if (virtualMethodsSize > 0) {
                out.annotate(0, "virtual_methods:");
                out.indent();
                previousIndex = 0;
                for (int i = 0; i < virtualMethodsSize; i++) {
                    out.annotate(0, "virtual_method[%d]", i);
                    out.indent();
                    previousIndex = annotateEncodedMethod(out, dexFile, reader, previousIndex);
                    out.deindent();
                }
                out.deindent();
            }
        }

        private int annotateEncodedField(@Nonnull AnnotatedBytes out, @Nonnull DexBackedDexFile dexFile, @Nonnull DexReader reader, int previousIndex) {
            // 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 indexDelta = reader.readLargeUleb128();
            int fieldIndex = previousIndex + indexDelta;
            out.annotateTo(reader.getOffset(), "field_idx_diff = %d: %s", indexDelta, FieldIdItem.getReferenceAnnotation(dexFile, fieldIndex));
            int accessFlags = reader.readSmallUleb128();
            out.annotateTo(reader.getOffset(), "access_flags = 0x%x: %s", accessFlags, Joiner.on('|').join(AccessFlags.getAccessFlagsForField(accessFlags)));
            return fieldIndex;
        }

        private int annotateEncodedMethod(@Nonnull AnnotatedBytes out, @Nonnull DexBackedDexFile dexFile, @Nonnull DexReader reader, int previousIndex) {
            // 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 indexDelta = reader.readLargeUleb128();
            int methodIndex = previousIndex + indexDelta;
            out.annotateTo(reader.getOffset(), "method_idx_diff = %d: %s", indexDelta, MethodIdItem.getReferenceAnnotation(dexFile, methodIndex));
            int accessFlags = reader.readSmallUleb128();
            out.annotateTo(reader.getOffset(), "access_flags = 0x%x: %s", accessFlags, Joiner.on('|').join(AccessFlags.getAccessFlagsForMethod(accessFlags)));
            int codeOffset = reader.readSmallUleb128();
            if (codeOffset == 0) {
                out.annotateTo(reader.getOffset(), "code_off = code_item[NO_OFFSET]");
            } else {
                out.annotateTo(reader.getOffset(), "code_off = code_item[0x%x]", codeOffset);
                addCodeItemIdentity(codeOffset, MethodIdItem.asString(dexFile, methodIndex));
            }
            return methodIndex;
        }

        private void addCodeItemIdentity(int codeItemOffset, String methodString) {
            if (codeItemAnnotator != null) {
                codeItemAnnotator.setItemIdentity(codeItemOffset, methodString);
            }
        }
    };
}

Example 19 with DexReader

use of org.jf.dexlib2.dexbacked.DexReader in project smali by JesusFreke.

the class EncodedArrayItem method makeAnnotator.

@Nonnull
public static SectionAnnotator makeAnnotator(@Nonnull DexAnnotator annotator, @Nonnull MapItem mapItem) {
    return new SectionAnnotator(annotator, mapItem) {

        @Nonnull
        @Override
        public String getItemName() {
            return "encoded_array_item";
        }

        @Override
        protected void annotateItem(@Nonnull AnnotatedBytes out, int itemIndex, @Nullable String itemIdentity) {
            DexReader reader = dexFile.getBuffer().readerAt(out.getCursor());
            EncodedValue.annotateEncodedArray(dexFile, out, reader);
        }
    };
}

Example 20 with DexReader

use of org.jf.dexlib2.dexbacked.DexReader in project smali by JesusFreke.

the class AnnotationItem method makeAnnotator.

@Nonnull
public static SectionAnnotator makeAnnotator(@Nonnull DexAnnotator annotator, @Nonnull MapItem mapItem) {
    return new SectionAnnotator(annotator, mapItem) {

        @Nonnull
        @Override
        public String getItemName() {
            return "annotation_item";
        }

        @Override
        protected void annotateItem(@Nonnull AnnotatedBytes out, int itemIndex, @Nullable String itemIdentity) {
            int visibility = dexFile.getBuffer().readUbyte(out.getCursor());
            out.annotate(1, "visibility = %d: %s", visibility, getAnnotationVisibility(visibility));
            DexReader reader = dexFile.getBuffer().readerAt(out.getCursor());
            EncodedValue.annotateEncodedAnnotation(dexFile, out, reader);
        }
    };
}