From 8faa4b31ecbfe16ece9346ef669a446f37aaca80 Mon Sep 17 00:00:00 2001 From: Ben Gruver Date: Thu, 1 Aug 2019 15:48:45 -0700 Subject: [PATCH] Refactor how information about indexed items are exposed in DexBackedDexFile This adds a unified IndexedSection/OptionalIndexedSection class for all indexed items --- .../java/org/jf/baksmali/DisassemblyTest.java | 2 +- .../jf/dexlib2/dexbacked/BaseDexBuffer.java | 4 +- .../dexbacked/DexBackedAnnotation.java | 2 +- .../dexbacked/DexBackedAnnotationElement.java | 2 +- .../dexlib2/dexbacked/DexBackedClassDef.java | 9 +- .../dexlib2/dexbacked/DexBackedDexFile.java | 453 ++++++++++-------- .../jf/dexlib2/dexbacked/DexBackedField.java | 6 +- .../jf/dexlib2/dexbacked/DexBackedMethod.java | 12 +- .../DexBackedTypedExceptionHandler.java | 2 +- .../dexlib2/dexbacked/raw/AnnotationItem.java | 2 +- .../dexlib2/dexbacked/raw/ClassDefItem.java | 6 +- .../jf/dexlib2/dexbacked/raw/FieldIdItem.java | 8 +- .../dexlib2/dexbacked/raw/MethodIdItem.java | 6 +- .../jf/dexlib2/dexbacked/raw/ProtoIdItem.java | 4 +- .../dexlib2/dexbacked/raw/StringIdItem.java | 18 +- .../jf/dexlib2/dexbacked/raw/TypeIdItem.java | 16 +- .../dexlib2/dexbacked/raw/TypeListItem.java | 2 +- .../reference/DexBackedCallSiteReference.java | 4 +- .../reference/DexBackedFieldReference.java | 10 +- .../DexBackedMethodHandleReference.java | 4 +- .../DexBackedMethodProtoReference.java | 8 +- .../reference/DexBackedMethodReference.java | 14 +- .../reference/DexBackedStringReference.java | 7 +- .../reference/DexBackedTypeReference.java | 4 +- .../jf/dexlib2/dexbacked/util/DebugInfo.java | 16 +- .../DexBackedAnnotationEncodedValue.java | 2 +- .../value/DexBackedStringEncodedValue.java | 2 +- .../value/DexBackedTypeEncodedValue.java | 2 +- 28 files changed, 338 insertions(+), 289 deletions(-) diff --git a/baksmali/src/test/java/org/jf/baksmali/DisassemblyTest.java b/baksmali/src/test/java/org/jf/baksmali/DisassemblyTest.java index 769372eb..f8ebe919 100644 --- a/baksmali/src/test/java/org/jf/baksmali/DisassemblyTest.java +++ b/baksmali/src/test/java/org/jf/baksmali/DisassemblyTest.java @@ -63,7 +63,7 @@ public class DisassemblyTest extends DexTest { protected void runTest(@Nonnull String testName, @Nonnull BaksmaliOptions options) { try { DexBackedDexFile inputDex = getInputDexFile(testName, options); - Assert.assertEquals(1, inputDex.getClassCount()); + Assert.assertEquals(1, inputDex.getClassSection().size()); ClassDef inputClass = Iterables.getFirst(inputDex.getClasses(), null); Assert.assertNotNull(inputClass); String input = BaksmaliTestUtils.getNormalizedSmali(inputClass, options, true); diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/BaseDexBuffer.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/BaseDexBuffer.java index eeb28227..154ac10d 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/BaseDexBuffer.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/BaseDexBuffer.java @@ -36,8 +36,8 @@ import org.jf.util.ExceptionWithContext; import javax.annotation.Nonnull; public class BaseDexBuffer { - @Nonnull /* package private */ final byte[] buf; - /* package private */ final int baseOffset; + @Nonnull final byte[] buf; + final int baseOffset; public BaseDexBuffer(@Nonnull byte[] buf) { this(buf, 0); diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedAnnotation.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedAnnotation.java index 480c6998..aadef9f5 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedAnnotation.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedAnnotation.java @@ -55,7 +55,7 @@ public class DexBackedAnnotation extends BaseAnnotation { } @Override public int getVisibility() { return visibility; } - @Nonnull @Override public String getType() { return dexFile.getType(typeIndex); } + @Nonnull @Override public String getType() { return dexFile.getTypeSection().get(typeIndex); } @Nonnull @Override diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedAnnotationElement.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedAnnotationElement.java index d55bf4c2..9dd41dac 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedAnnotationElement.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedAnnotationElement.java @@ -48,6 +48,6 @@ public class DexBackedAnnotationElement extends BaseAnnotationElement { this.value = DexBackedEncodedValue.readFrom(reader); } - @Nonnull @Override public String getName() { return dexFile.getString(nameIndex); } + @Nonnull @Override public String getName() { return dexFile.getStringSection().get(nameIndex); } @Nonnull @Override public EncodedValue getValue() { return value; } } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedClassDef.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedClassDef.java index 6b415fb1..b828e9af 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedClassDef.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedClassDef.java @@ -95,13 +95,13 @@ public class DexBackedClassDef extends BaseTypeReference implements ClassDef { @Nonnull @Override public String getType() { - return dexFile.getType(dexFile.readSmallUint(classDefOffset + ClassDefItem.CLASS_OFFSET)); + return dexFile.getTypeSection().get(dexFile.readSmallUint(classDefOffset + ClassDefItem.CLASS_OFFSET)); } @Nullable @Override public String getSuperclass() { - return dexFile.getOptionalType(dexFile.readOptionalUint(classDefOffset + ClassDefItem.SUPERCLASS_OFFSET)); + return dexFile.getTypeSection().getOptional(dexFile.readOptionalUint(classDefOffset + ClassDefItem.SUPERCLASS_OFFSET)); } @Override @@ -112,7 +112,8 @@ public class DexBackedClassDef extends BaseTypeReference implements ClassDef { @Nullable @Override public String getSourceFile() { - return dexFile.getOptionalString(dexFile.readOptionalUint(classDefOffset + ClassDefItem.SOURCE_FILE_OFFSET)); + return dexFile.getStringSection().getOptional( + dexFile.readOptionalUint(classDefOffset + ClassDefItem.SOURCE_FILE_OFFSET)); } @Nonnull @@ -125,7 +126,7 @@ public class DexBackedClassDef extends BaseTypeReference implements ClassDef { @Override @Nonnull public String get(int index) { - return dexFile.getType(dexFile.readUshort(interfacesOffset + 4 + (2*index))); + return dexFile.getTypeSection().get(dexFile.readUshort(interfacesOffset + 4 + (2*index))); } @Override public int size() { return size; } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedDexFile.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedDexFile.java index e640c550..729ed7bb 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedDexFile.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedDexFile.java @@ -35,16 +35,12 @@ import com.google.common.io.ByteStreams; import org.jf.dexlib2.Opcodes; import org.jf.dexlib2.ReferenceType; import org.jf.dexlib2.dexbacked.raw.*; -import org.jf.dexlib2.dexbacked.reference.DexBackedFieldReference; -import org.jf.dexlib2.dexbacked.reference.DexBackedMethodReference; -import org.jf.dexlib2.dexbacked.reference.DexBackedStringReference; -import org.jf.dexlib2.dexbacked.reference.DexBackedTypeReference; +import org.jf.dexlib2.dexbacked.reference.*; import org.jf.dexlib2.dexbacked.util.FixedSizeList; import org.jf.dexlib2.dexbacked.util.FixedSizeSet; import org.jf.dexlib2.iface.DexFile; -import org.jf.dexlib2.iface.reference.Reference; +import org.jf.dexlib2.iface.reference.*; import org.jf.dexlib2.util.DexUtil; -import org.jf.util.ExceptionWithContext; import javax.annotation.Nonnull; import javax.annotation.Nullable; @@ -123,7 +119,7 @@ public class DexBackedDexFile extends BaseDexBuffer implements DexFile { return new DexBackedDexFile(opcodes, buf, 0, false); } - @Override @Nonnull public Opcodes getOpcodes() { + @Nonnull public Opcodes getOpcodes() { return opcodes; } @@ -132,13 +128,12 @@ public class DexBackedDexFile extends BaseDexBuffer implements DexFile { } @Nonnull - @Override public Set getClasses() { return new FixedSizeSet() { @Nonnull @Override public DexBackedClassDef readItem(int index) { - return new DexBackedClassDef(DexBackedDexFile.this, getClassDefItemOffset(index)); + return getClassSection().get(index); } @Override @@ -148,192 +143,32 @@ public class DexBackedDexFile extends BaseDexBuffer implements DexFile { }; } - public int getStringIdItemOffset(int stringIndex) { - if (stringIndex < 0 || stringIndex >= stringCount) { - throw new InvalidItemIndex(stringIndex, "String index out of bounds: %d", stringIndex); - } - return stringStartOffset + stringIndex*StringIdItem.ITEM_SIZE; - } - - public int getTypeIdItemOffset(int typeIndex) { - if (typeIndex < 0 || typeIndex >= typeCount) { - throw new InvalidItemIndex(typeIndex, "Type index out of bounds: %d", typeIndex); - } - return typeStartOffset + typeIndex*TypeIdItem.ITEM_SIZE; - } - - public int getFieldIdItemOffset(int fieldIndex) { - if (fieldIndex < 0 || fieldIndex >= fieldCount) { - throw new InvalidItemIndex(fieldIndex, "Field index out of bounds: %d", fieldIndex); - } - return fieldStartOffset + fieldIndex*FieldIdItem.ITEM_SIZE; - } - - public int getMethodIdItemOffset(int methodIndex) { - if (methodIndex < 0 || methodIndex >= methodCount) { - throw new InvalidItemIndex(methodIndex, "Method index out of bounds: %d", methodIndex); - } - return methodStartOffset + methodIndex*MethodIdItem.ITEM_SIZE; - } - - public int getProtoIdItemOffset(int protoIndex) { - if (protoIndex < 0 || protoIndex >= protoCount) { - throw new InvalidItemIndex(protoIndex, "Proto index out of bounds: %d", protoIndex); - } - return protoStartOffset + protoIndex*ProtoIdItem.ITEM_SIZE; - } - - public int getClassDefItemOffset(int classIndex) { - if (classIndex < 0 || classIndex >= classCount) { - throw new InvalidItemIndex(classIndex, "Class index out of bounds: %d", classIndex); - } - return classStartOffset + classIndex*ClassDefItem.ITEM_SIZE; - } - - public int getCallSiteIdItemOffset(int callSiteIndex) { - MapItem mapItem = getMapItemForSection(ItemType.CALL_SITE_ID_ITEM); - if (mapItem == null || callSiteIndex >= mapItem.getItemCount()) { - throw new InvalidItemIndex(callSiteIndex, "Call site index out of bounds: %d", callSiteIndex); - } - return mapItem.getOffset() + callSiteIndex * CallSiteIdItem.ITEM_SIZE; - } - - public int getMethodHandleItemOffset(int methodHandleIndex) { - MapItem mapItem = getMapItemForSection(ItemType.METHOD_HANDLE_ITEM); - if (mapItem == null || methodHandleIndex >= mapItem.getItemCount()) { - throw new InvalidItemIndex(methodHandleIndex , "Method handle index out of bounds: %d", methodHandleIndex); - } - return mapItem.getOffset() + methodHandleIndex * MethodHandleItem.ITEM_SIZE; - } - - public int getClassCount() { - return classCount; - } - - public int getStringCount() { - return stringCount; - } - - public int getTypeCount() { - return typeCount; - } - - public int getProtoCount() { - return protoCount; - } - - public int getFieldCount() { - return fieldCount; - } - - public int getMethodCount() { - return methodCount; - } - - public int getCallSiteCount() { - MapItem mapItem = getMapItemForSection(ItemType.CALL_SITE_ID_ITEM); - if (mapItem == null) { - return 0; - } - return mapItem.getItemCount(); - } - - public int getMethodHandleCount() { - MapItem mapItem = getMapItemForSection(ItemType.METHOD_HANDLE_ITEM); - if (mapItem == null) { - return 0; - } - return mapItem.getItemCount(); - } - - @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); - } - - @Nullable - public String getOptionalString(int stringIndex) { - if (stringIndex == -1) { - return null; - } - return getString(stringIndex); - } - - @Nonnull - public String getType(int typeIndex) { - int typeOffset = getTypeIdItemOffset(typeIndex); - int stringIndex = readSmallUint(typeOffset); - return getString(stringIndex); - } - - @Nullable - public String getOptionalType(int typeIndex) { - if (typeIndex == -1) { - return null; - } - return getType(typeIndex); - } - - public List getStrings() { + public List getStringReferences() { return new AbstractList() { @Override public DexBackedStringReference get(int index) { - if (index < 0 || index >= getStringCount()) { + if (index < 0 || index >= getStringSection().size()) { throw new IndexOutOfBoundsException(); } return new DexBackedStringReference(DexBackedDexFile.this, index); } @Override public int size() { - return getStringCount(); + return getStringSection().size(); } }; } - public List getTypes() { + public List getTypeReferences() { return new AbstractList() { @Override public DexBackedTypeReference get(int index) { - if (index < 0 || index >= getTypeCount()) { + if (index < 0 || index >= getTypeSection().size()) { throw new IndexOutOfBoundsException(); } return new DexBackedTypeReference(DexBackedDexFile.this, index); } @Override public int size() { - return getTypeCount(); - } - }; - } - - public List getMethods() { - return new AbstractList() { - @Override public DexBackedMethodReference get(int index) { - if (index < 0 || index >= getMethodCount()) { - throw new IndexOutOfBoundsException(); - } - return new DexBackedMethodReference(DexBackedDexFile.this, index); - } - - @Override public int size() { - return getMethodCount(); - } - }; - } - - public List getFields() { - return new AbstractList() { - @Override public DexBackedFieldReference get(int index) { - if (index < 0 || index >= getFieldCount()) { - throw new IndexOutOfBoundsException(); - } - return new DexBackedFieldReference(DexBackedDexFile.this, index); - } - - @Override public int size() { - return getFieldCount(); + return getTypeSection().size(); } }; } @@ -341,13 +176,13 @@ public class DexBackedDexFile extends BaseDexBuffer implements DexFile { public List getReferences(int referenceType) { switch (referenceType) { case ReferenceType.STRING: - return getStrings(); + return getStringReferences(); case ReferenceType.TYPE: - return getTypes(); + return getTypeReferences(); case ReferenceType.METHOD: - return getMethods(); + return getMethodSection(); case ReferenceType.FIELD: - return getFields(); + return getFieldSection(); default: throw new IllegalArgumentException(String.format("Invalid reference type: %d", referenceType)); } @@ -402,21 +237,259 @@ public class DexBackedDexFile extends BaseDexBuffer implements DexFile { } } - public static class InvalidItemIndex extends ExceptionWithContext { - private final int itemIndex; - - public InvalidItemIndex(int itemIndex) { - super(""); - this.itemIndex = itemIndex; + private OptionalIndexedSection stringSection = new OptionalIndexedSection() { + @Override + public String get(int index) { + int stringOffset = getOffset(index); + int stringDataOffset = readSmallUint(stringOffset); + DexReader reader = readerAt(stringDataOffset); + int utf16Length = reader.readSmallUleb128(); + return reader.readString(utf16Length); } - public InvalidItemIndex(int itemIndex, String message, Object... formatArgs) { - super(message, formatArgs); - this.itemIndex = itemIndex; + @Override + public int size() { + return stringCount; } - public int getInvalidIndex() { - return itemIndex; + @Nullable + @Override + public String getOptional(int index) { + if (index == -1) { + return null; + } + return get(index); } + + @Override + public int getOffset(int index) { + if (index < 0 || index >= size()) { + throw new IndexOutOfBoundsException( + String.format("Invalid string index %d, not in [0, %d)", index, size())); + } + return stringStartOffset + index*StringIdItem.ITEM_SIZE; + } + }; + + public OptionalIndexedSection getStringSection() { + return stringSection; + } + + private OptionalIndexedSection typeSection = new OptionalIndexedSection() { + @Override + public String get(int index) { + int typeOffset = getOffset(index); + int stringIndex = readSmallUint(typeOffset); + return getStringSection().get(stringIndex); + } + + @Override + public int size() { + return typeCount; + } + + @Nullable + @Override + public String getOptional(int index) { + if (index == -1) { + return null; + } + return get(index); + } + + @Override + public int getOffset(int index) { + if (index < 0 || index >= size()) { + throw new IndexOutOfBoundsException( + String.format("Invalid type index %d, not in [0, %d)", index, size())); + } + return typeStartOffset + index * TypeIdItem.ITEM_SIZE; + } + }; + + public OptionalIndexedSection getTypeSection() { + return typeSection; + } + + private IndexedSection fieldSection = new IndexedSection() { + @Override + public FieldReference get(int index) { + return new DexBackedFieldReference(DexBackedDexFile.this, index); + } + + @Override + public int size() { + return fieldCount; + } + + @Override + public int getOffset(int index) { + if (index < 0 || index >= size()) { + throw new IndexOutOfBoundsException( + String.format("Invalid field index %d, not in [0, %d)", index, size())); + } + + return fieldStartOffset + index * FieldIdItem.ITEM_SIZE; + } + }; + + public IndexedSection getFieldSection() { + return fieldSection; + } + + private IndexedSection methodSection = new IndexedSection() { + @Override + public MethodReference get(int index) { + return new DexBackedMethodReference(DexBackedDexFile.this, index); + } + + @Override + public int size() { + return methodCount; + } + + @Override + public int getOffset(int index) { + if (index < 0 || index >= size()) { + throw new IndexOutOfBoundsException( + String.format("Invalid method index %d, not in [0, %d)", index, size())); + } + + return methodStartOffset + index * MethodIdItem.ITEM_SIZE; + } + }; + + public IndexedSection getMethodSection() { + return methodSection; + } + + private IndexedSection protoSection = new IndexedSection() { + @Override + public MethodProtoReference get(int index) { + return new DexBackedMethodProtoReference(DexBackedDexFile.this, index); + } + + @Override + public int size() { + return protoCount; + } + + @Override + public int getOffset(int index) { + if (index < 0 || index >= size()) { + throw new IndexOutOfBoundsException( + String.format("Invalid proto index %d, not in [0, %d)", index, size())); + } + + return protoStartOffset + index * ProtoIdItem.ITEM_SIZE; + } + }; + + public IndexedSection getProtoSection() { + return protoSection; + } + + private IndexedSection classSection = new IndexedSection() { + @Override + public DexBackedClassDef get(int index) { + return new DexBackedClassDef(DexBackedDexFile.this, getOffset(index)); + } + + @Override + public int size() { + return classCount; + } + + @Override + public int getOffset(int index) { + if (index < 0 || index >= size()) { + throw new IndexOutOfBoundsException( + String.format("Invalid class index %d, not in [0, %d)", index, size())); + } + + return classStartOffset + index * ClassDefItem.ITEM_SIZE; + } + }; + + public IndexedSection getClassSection() { + return classSection; + } + + private IndexedSection callSiteSection = new IndexedSection() { + @Override + public CallSiteReference get(int index) { + return new DexBackedCallSiteReference(DexBackedDexFile.this, index); + } + + @Override + public int size() { + MapItem mapItem = getMapItemForSection(ItemType.CALL_SITE_ID_ITEM); + if (mapItem == null) { + return 0; + } + return mapItem.getItemCount(); + } + + @Override + public int getOffset(int index) { + MapItem mapItem = getMapItemForSection(ItemType.CALL_SITE_ID_ITEM); + if (index < 0 || index >= size()) { + throw new IndexOutOfBoundsException( + String.format("Invalid callsite index %d, not in [0, %d)", index, size())); + } + return mapItem.getOffset() + index * CallSiteIdItem.ITEM_SIZE; + } + }; + + public IndexedSection getCallSiteSection() { + return callSiteSection; + } + + private IndexedSection methodHandleSection = new IndexedSection() { + @Override + public MethodHandleReference get(int index) { + return new DexBackedMethodHandleReference(DexBackedDexFile.this, index); + } + + @Override + public int size() { + MapItem mapItem = getMapItemForSection(ItemType.METHOD_HANDLE_ITEM); + if (mapItem == null) { + return 0; + } + return mapItem.getItemCount(); + } + + @Override + public int getOffset(int index) { + MapItem mapItem = getMapItemForSection(ItemType.METHOD_HANDLE_ITEM); + if (index < 0 || index >= size()) { + throw new IndexOutOfBoundsException( + String.format("Invalid method handle index %d, not in [0, %d)", index, size())); + } + return mapItem.getOffset() + index * MethodHandleItem.ITEM_SIZE; + } + }; + + public IndexedSection getMethodHandleSection() { + return methodHandleSection; + } + + public static abstract class OptionalIndexedSection extends IndexedSection { + /** + * @param index The index of the item, or -1 for a null item. + * @return The value at the given index, or null if index is -1. + * @throws IndexOutOfBoundsException if the index is out of bounds and is not -1. + */ + @Nullable public abstract T getOptional(int index); + } + + public static abstract class IndexedSection extends AbstractList { + /** + * @param index The index of the item to get the offset for. + * @return The offset from the beginning of the dex file to the specified item. + * @throws IndexOutOfBoundsException if the index is out of bounds. + */ + public abstract int getOffset(int index); } } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedField.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedField.java index 50dd6d20..53e3a1b6 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedField.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedField.java @@ -101,13 +101,13 @@ public class DexBackedField extends BaseFieldReference implements Field { @Nonnull @Override public String getName() { - return dexFile.getString(dexFile.readSmallUint(getFieldIdItemOffset() + FieldIdItem.NAME_OFFSET)); + return dexFile.getStringSection().get(dexFile.readSmallUint(getFieldIdItemOffset() + FieldIdItem.NAME_OFFSET)); } @Nonnull @Override public String getType() { - return dexFile.getType(dexFile.readUshort(getFieldIdItemOffset() + FieldIdItem.TYPE_OFFSET)); + return dexFile.getTypeSection().get(dexFile.readUshort(getFieldIdItemOffset() + FieldIdItem.TYPE_OFFSET)); } @Nonnull @Override public String getDefiningClass() { return classDef.getType(); } @@ -135,7 +135,7 @@ public class DexBackedField extends BaseFieldReference implements Field { private int getFieldIdItemOffset() { if (fieldIdItemOffset == 0) { - fieldIdItemOffset = dexFile.getFieldIdItemOffset(fieldIndex); + fieldIdItemOffset = dexFile.getFieldSection().getOffset(fieldIndex); } return fieldIdItemOffset; } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedMethod.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedMethod.java index 821d2232..027df6ec 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedMethod.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedMethod.java @@ -43,7 +43,6 @@ import org.jf.dexlib2.dexbacked.util.FixedSizeList; import org.jf.dexlib2.dexbacked.util.ParameterIterator; import org.jf.dexlib2.iface.Annotation; import org.jf.dexlib2.iface.Method; -import org.jf.dexlib2.iface.MethodImplementation; import org.jf.dexlib2.iface.MethodParameter; import org.jf.util.AbstractForwardSequentialList; @@ -115,13 +114,14 @@ public class DexBackedMethod extends BaseMethodReference implements Method { @Nonnull @Override public String getName() { - return dexFile.getString(dexFile.readSmallUint(getMethodIdItemOffset() + MethodIdItem.NAME_OFFSET)); + return dexFile.getStringSection().get(dexFile.readSmallUint(getMethodIdItemOffset() + MethodIdItem.NAME_OFFSET)); } @Nonnull @Override public String getReturnType() { - return dexFile.getType(dexFile.readSmallUint(getProtoIdItemOffset() + ProtoIdItem.RETURN_TYPE_OFFSET)); + return dexFile.getTypeSection().get( + dexFile.readSmallUint(getProtoIdItemOffset() + ProtoIdItem.RETURN_TYPE_OFFSET)); } @Nonnull @@ -171,7 +171,7 @@ public class DexBackedMethod extends BaseMethodReference implements Method { @Nonnull @Override public String readItem(final int index) { - return dexFile.getType(dexFile.readUshort(paramListStart + 2*index)); + return dexFile.getTypeSection().get(dexFile.readUshort(paramListStart + 2*index)); } @Override public int size() { return parameterCount; } }; @@ -196,7 +196,7 @@ public class DexBackedMethod extends BaseMethodReference implements Method { private int getMethodIdItemOffset() { if (methodIdItemOffset == 0) { - methodIdItemOffset = dexFile.getMethodIdItemOffset(methodIndex); + methodIdItemOffset = dexFile.getMethodSection().getOffset(methodIndex); } return methodIdItemOffset; } @@ -204,7 +204,7 @@ public class DexBackedMethod extends BaseMethodReference implements Method { private int getProtoIdItemOffset() { if (protoIdItemOffset == 0) { int protoIndex = dexFile.readUshort(getMethodIdItemOffset() + MethodIdItem.PROTO_OFFSET); - protoIdItemOffset = dexFile.getProtoIdItemOffset(protoIndex); + protoIdItemOffset = dexFile.getProtoSection().getOffset(protoIndex); } return protoIdItemOffset; } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedTypedExceptionHandler.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedTypedExceptionHandler.java index 791ffbe6..e47fe5e4 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedTypedExceptionHandler.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedTypedExceptionHandler.java @@ -44,6 +44,6 @@ public class DexBackedTypedExceptionHandler extends DexBackedExceptionHandler { this.handlerCodeAddress = reader.readSmallUleb128(); } - @Nonnull @Override public String getExceptionType() { return dexFile.getType(typeId); } + @Nonnull @Override public String getExceptionType() { return dexFile.getTypeSection().get(typeId); } @Override public int getHandlerCodeAddress() { return handlerCodeAddress; } } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/raw/AnnotationItem.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/raw/AnnotationItem.java index c781b403..5f3db45f 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/raw/AnnotationItem.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/raw/AnnotationItem.java @@ -80,7 +80,7 @@ public class AnnotationItem { DexReader reader = dexFile.readerAt(annotationItemOffset); reader.readUbyte(); int typeIndex = reader.readSmallUleb128(); - String annotationType = dexFile.getType(typeIndex); + String annotationType = dexFile.getTypeSection().get(typeIndex); return String.format("annotation_item[0x%x]: %s", annotationItemOffset, annotationType); } catch (Exception ex) { ex.printStackTrace(System.err); diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/raw/ClassDefItem.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/raw/ClassDefItem.java index 9ded6d27..5c30ac96 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/raw/ClassDefItem.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/raw/ClassDefItem.java @@ -98,7 +98,7 @@ public class ClassDefItem { out.annotate(4, "class_data_off = class_data_item[NO_OFFSET]"); } else { out.annotate(4, "class_data_off = class_data_item[0x%x]", classDataOffset); - addClassDataIdentity(classDataOffset, dexFile.getType(classIndex)); + addClassDataIdentity(classDataOffset, dexFile.getTypeSection().get(classIndex)); } int staticValuesOffset = dexFile.readSmallUint(out.getCursor()); @@ -119,9 +119,9 @@ public class ClassDefItem { @Nonnull public static String asString(@Nonnull DexBackedDexFile dexFile, int classIndex) { - int offset = dexFile.getClassDefItemOffset(classIndex); + int offset = dexFile.getClassSection().getOffset(classIndex); int typeIndex = dexFile.readSmallUint(offset + CLASS_OFFSET); - return dexFile.getType(typeIndex); + return dexFile.getTypeSection().get(typeIndex); } public static String[] getClasses(@Nonnull RawDexFile dexFile) { diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/raw/FieldIdItem.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/raw/FieldIdItem.java index a1b1dd7e..37521963 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/raw/FieldIdItem.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/raw/FieldIdItem.java @@ -68,15 +68,15 @@ public class FieldIdItem { @Nonnull public static String asString(@Nonnull DexBackedDexFile dexFile, int fieldIndex) { - int fieldOffset = dexFile.getFieldIdItemOffset(fieldIndex); + int fieldOffset = dexFile.getFieldSection().getOffset(fieldIndex); int classIndex = dexFile.readUshort(fieldOffset + CLASS_OFFSET); - String classType = dexFile.getType(classIndex); + String classType = dexFile.getTypeSection().get(classIndex); int typeIndex = dexFile.readUshort(fieldOffset + TYPE_OFFSET); - String fieldType = dexFile.getType(typeIndex); + String fieldType = dexFile.getTypeSection().get(typeIndex); int nameIndex = dexFile.readSmallUint(fieldOffset + NAME_OFFSET); - String fieldName = dexFile.getString(nameIndex); + String fieldName = dexFile.getStringSection().get(nameIndex); return String.format("%s->%s:%s", classType, fieldName, fieldType); } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/raw/MethodIdItem.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/raw/MethodIdItem.java index 7a12aabb..28f4c19d 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/raw/MethodIdItem.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/raw/MethodIdItem.java @@ -68,15 +68,15 @@ public class MethodIdItem { @Nonnull public static String asString(@Nonnull DexBackedDexFile dexFile, int methodIndex) { - int methodOffset = dexFile.getMethodIdItemOffset(methodIndex); + int methodOffset = dexFile.getMethodSection().getOffset(methodIndex); int classIndex = dexFile.readUshort(methodOffset + CLASS_OFFSET); - String classType = dexFile.getType(classIndex); + String classType = dexFile.getTypeSection().get(classIndex); int protoIndex = dexFile.readUshort(methodOffset + PROTO_OFFSET); String protoString = ProtoIdItem.asString(dexFile, protoIndex); int nameIndex = dexFile.readSmallUint(methodOffset + NAME_OFFSET); - String methodName = dexFile.getString(nameIndex); + String methodName = dexFile.getStringSection().get(nameIndex); return String.format("%s->%s%s", classType, methodName, protoString); } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/raw/ProtoIdItem.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/raw/ProtoIdItem.java index e6c7fe10..3d3e9101 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/raw/ProtoIdItem.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/raw/ProtoIdItem.java @@ -79,7 +79,7 @@ public class ProtoIdItem { @Nonnull public static String asString(@Nonnull DexBackedDexFile dexFile, int protoIndex) { - int offset = dexFile.getProtoIdItemOffset(protoIndex); + int offset = dexFile.getProtoSection().getOffset(protoIndex); StringBuilder sb = new StringBuilder(); sb.append("("); @@ -89,7 +89,7 @@ public class ProtoIdItem { sb.append(")"); int returnTypeIndex = dexFile.readSmallUint(offset + RETURN_TYPE_OFFSET); - String returnType = dexFile.getType(returnTypeIndex); + String returnType = dexFile.getTypeSection().get(returnTypeIndex); sb.append(returnType); return sb.toString(); diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/raw/StringIdItem.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/raw/StringIdItem.java index 23199729..5651414a 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/raw/StringIdItem.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/raw/StringIdItem.java @@ -53,7 +53,7 @@ public class StringIdItem { public void annotateItem(@Nonnull AnnotatedBytes out, int itemIndex, @Nullable String itemIdentity) { int stringDataOffset = dexFile.readSmallUint(out.getCursor()); try { - String stringValue = dexFile.getString(itemIndex); + String stringValue = dexFile.getStringSection().get(itemIndex); out.annotate(4, "string_data_item[0x%x]: \"%s\"", stringDataOffset, StringUtils.escapeString(stringValue)); return; @@ -76,7 +76,7 @@ public class StringIdItem { public static String getReferenceAnnotation(@Nonnull DexBackedDexFile dexFile, int stringIndex, boolean quote) { try { - String string = dexFile.getString(stringIndex); + String string = dexFile.getStringSection().get(stringIndex); if (quote) { string = String.format("\"%s\"", StringUtils.escapeString(string)); } @@ -101,18 +101,4 @@ public class StringIdItem { } return getReferenceAnnotation(dexFile, stringIndex, quote); } - - public static String[] getStrings(@Nonnull RawDexFile dexFile) { - MapItem mapItem = dexFile.getMapItemForSection(ItemType.STRING_ID_ITEM); - if (mapItem == null) { - return new String[0]; - } - - int stringCount = mapItem.getItemCount(); - String[] ret = new String[stringCount]; - for (int i=0; i= dexFile.getCallSiteCount()) { + if (callSiteIndex < 0 || callSiteIndex >= dexFile.getCallSiteSection().size()) { throw new InvalidReferenceException("callsite@" + callSiteIndex); } } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/reference/DexBackedFieldReference.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/reference/DexBackedFieldReference.java index 35576653..620e1334 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/reference/DexBackedFieldReference.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/reference/DexBackedFieldReference.java @@ -49,20 +49,22 @@ public class DexBackedFieldReference extends BaseFieldReference { @Nonnull @Override public String getDefiningClass() { - return dexFile.getType(dexFile.readUshort(dexFile.getFieldIdItemOffset(fieldIndex) + FieldIdItem.CLASS_OFFSET)); + return dexFile.getTypeSection().get( + dexFile.readUshort(dexFile.getFieldSection().getOffset(fieldIndex) + FieldIdItem.CLASS_OFFSET)); } @Nonnull @Override public String getName() { - return dexFile.getString(dexFile.readSmallUint(dexFile.getFieldIdItemOffset(fieldIndex) + + return dexFile.getStringSection().get(dexFile.readSmallUint(dexFile.getFieldSection().getOffset(fieldIndex) + FieldIdItem.NAME_OFFSET)); } @Nonnull @Override public String getType() { - return dexFile.getType(dexFile.readUshort(dexFile.getFieldIdItemOffset(fieldIndex) + FieldIdItem.TYPE_OFFSET)); + return dexFile.getTypeSection().get( + dexFile.readUshort(dexFile.getFieldSection().getOffset(fieldIndex) + FieldIdItem.TYPE_OFFSET)); } /** @@ -78,7 +80,7 @@ public class DexBackedFieldReference extends BaseFieldReference { @Override public void validateReference() throws InvalidReferenceException { - if (fieldIndex < 0 || fieldIndex >= dexFile.getFieldCount()) { + if (fieldIndex < 0 || fieldIndex >= dexFile.getFieldSection().size()) { throw new InvalidReferenceException("field@" + fieldIndex); } } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/reference/DexBackedMethodHandleReference.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/reference/DexBackedMethodHandleReference.java index 58314dc7..30be0a15 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/reference/DexBackedMethodHandleReference.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/reference/DexBackedMethodHandleReference.java @@ -48,7 +48,7 @@ public class DexBackedMethodHandleReference extends BaseMethodHandleReference { public DexBackedMethodHandleReference(DexBackedDexFile dexFile, int methodHandleIndex) { this.dexFile = dexFile; this.methodHandleIndex = methodHandleIndex; - this.methodHandleOffset = dexFile.getMethodHandleItemOffset(methodHandleIndex); + this.methodHandleOffset = dexFile.getMethodHandleSection().getOffset(methodHandleIndex); } @Override @@ -79,7 +79,7 @@ public class DexBackedMethodHandleReference extends BaseMethodHandleReference { @Override public void validateReference() throws InvalidReferenceException { - if (methodHandleIndex < 0 || methodHandleIndex >= dexFile.getMethodHandleCount()) { + if (methodHandleIndex < 0 || methodHandleIndex >= dexFile.getMethodHandleSection().size()) { throw new InvalidReferenceException("methodhandle@" + methodHandleIndex); } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/reference/DexBackedMethodProtoReference.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/reference/DexBackedMethodProtoReference.java index bdc2c41b..bad6b93e 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/reference/DexBackedMethodProtoReference.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/reference/DexBackedMethodProtoReference.java @@ -53,7 +53,7 @@ public class DexBackedMethodProtoReference extends BaseMethodProtoReference { @Nonnull @Override public List getParameterTypes() { - final int parametersOffset = dexFile.readSmallUint(dexFile.getProtoIdItemOffset(protoIndex) + + final int parametersOffset = dexFile.readSmallUint(dexFile.getProtoSection().getOffset(protoIndex) + ProtoIdItem.PARAMETERS_OFFSET); if (parametersOffset > 0) { final int parameterCount = dexFile.readSmallUint(parametersOffset + TypeListItem.SIZE_OFFSET); @@ -62,7 +62,7 @@ public class DexBackedMethodProtoReference extends BaseMethodProtoReference { @Nonnull @Override public String readItem(final int index) { - return dexFile.getType(dexFile.readUshort(paramListStart + 2*index)); + return dexFile.getTypeSection().get(dexFile.readUshort(paramListStart + 2*index)); } @Override public int size() { return parameterCount; } }; @@ -73,7 +73,7 @@ public class DexBackedMethodProtoReference extends BaseMethodProtoReference { @Nonnull @Override public String getReturnType() { - return dexFile.getType(dexFile.readSmallUint(dexFile.getProtoIdItemOffset(protoIndex) + + return dexFile.getTypeSection().get(dexFile.readSmallUint(dexFile.getProtoSection().getOffset(protoIndex) + ProtoIdItem.RETURN_TYPE_OFFSET)); } @@ -95,7 +95,7 @@ public class DexBackedMethodProtoReference extends BaseMethodProtoReference { @Override public void validateReference() throws InvalidReferenceException { - if (protoIndex < 0 || protoIndex >= dexFile.getProtoCount()) { + if (protoIndex < 0 || protoIndex >= dexFile.getProtoSection().size()) { throw new InvalidReferenceException("proto@" + protoIndex); } } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/reference/DexBackedMethodReference.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/reference/DexBackedMethodReference.java index 775e8d6a..b642ed9c 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/reference/DexBackedMethodReference.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/reference/DexBackedMethodReference.java @@ -55,14 +55,14 @@ public class DexBackedMethodReference extends BaseMethodReference { @Nonnull @Override public String getDefiningClass() { - return dexFile.getType(dexFile.readUshort(dexFile.getMethodIdItemOffset(methodIndex) + + return dexFile.getTypeSection().get(dexFile.readUshort(dexFile.getMethodSection().getOffset(methodIndex) + MethodIdItem.CLASS_OFFSET)); } @Nonnull @Override public String getName() { - return dexFile.getString(dexFile.readSmallUint(dexFile.getMethodIdItemOffset(methodIndex) + + return dexFile.getStringSection().get(dexFile.readSmallUint(dexFile.getMethodSection().getOffset(methodIndex) + MethodIdItem.NAME_OFFSET)); } @@ -78,7 +78,7 @@ public class DexBackedMethodReference extends BaseMethodReference { @Nonnull @Override public String readItem(final int index) { - return dexFile.getType(dexFile.readUshort(paramListStart + 2*index)); + return dexFile.getTypeSection().get(dexFile.readUshort(paramListStart + 2*index)); } @Override public int size() { return parameterCount; } }; @@ -90,13 +90,13 @@ public class DexBackedMethodReference extends BaseMethodReference { @Override public String getReturnType() { int protoIdItemOffset = getProtoIdItemOffset(); - return dexFile.getType(dexFile.readSmallUint(protoIdItemOffset + ProtoIdItem.RETURN_TYPE_OFFSET)); + return dexFile.getTypeSection().get(dexFile.readSmallUint(protoIdItemOffset + ProtoIdItem.RETURN_TYPE_OFFSET)); } private int getProtoIdItemOffset() { if (protoIdItemOffset == 0) { - protoIdItemOffset = dexFile.getProtoIdItemOffset( - dexFile.readUshort(dexFile.getMethodIdItemOffset(methodIndex) + MethodIdItem.PROTO_OFFSET)); + protoIdItemOffset = dexFile.getProtoSection().getOffset( + dexFile.readUshort(dexFile.getMethodSection().getOffset(methodIndex) + MethodIdItem.PROTO_OFFSET)); } return protoIdItemOffset; } @@ -114,7 +114,7 @@ public class DexBackedMethodReference extends BaseMethodReference { @Override public void validateReference() throws InvalidReferenceException { - if (methodIndex < 0 || methodIndex >= dexFile.getMethodCount()) { + if (methodIndex < 0 || methodIndex >= dexFile.getMethodSection().size()) { throw new InvalidReferenceException("method@" + methodIndex); } } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/reference/DexBackedStringReference.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/reference/DexBackedStringReference.java index d1ed0547..80c9a5df 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/reference/DexBackedStringReference.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/reference/DexBackedStringReference.java @@ -50,10 +50,9 @@ public class DexBackedStringReference extends BaseStringReference { @Nonnull public String getString() { - return dexFile.getString(stringIndex); + return dexFile.getStringSection().get(stringIndex); } - /** * Calculate and return the private size of a string reference. * @@ -64,7 +63,7 @@ public class DexBackedStringReference extends BaseStringReference { public int getSize() { int size = StringIdItem.ITEM_SIZE; //uint for string_data_off //add the string data length: - int stringOffset = dexFile.getStringIdItemOffset(stringIndex); + int stringOffset = dexFile.getStringSection().getOffset(stringIndex); int stringDataOffset = dexFile.readSmallUint(stringOffset); DexReader reader = dexFile.readerAt(stringDataOffset); size += reader.peekSmallUleb128Size(); @@ -76,7 +75,7 @@ public class DexBackedStringReference extends BaseStringReference { @Override public void validateReference() throws InvalidReferenceException { - if (stringIndex < 0 || stringIndex >= dexFile.getStringCount()) { + if (stringIndex < 0 || stringIndex >= dexFile.getStringSection().size()) { throw new InvalidReferenceException("string@" + stringIndex); } } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/reference/DexBackedTypeReference.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/reference/DexBackedTypeReference.java index 3b952a46..0c71de48 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/reference/DexBackedTypeReference.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/reference/DexBackedTypeReference.java @@ -48,7 +48,7 @@ public class DexBackedTypeReference extends BaseTypeReference { } @Nonnull public String getType() { - return dexFile.getType(typeIndex); + return dexFile.getTypeSection().get(typeIndex); } @@ -65,7 +65,7 @@ public class DexBackedTypeReference extends BaseTypeReference { @Override public void validateReference() throws InvalidReferenceException { - if (typeIndex < 0 || typeIndex >= dexFile.getTypeCount()) { + if (typeIndex < 0 || typeIndex >= dexFile.getTypeSection().size()) { throw new InvalidReferenceException("type@" + typeIndex); } } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/util/DebugInfo.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/util/DebugInfo.java index d82e4d6f..1d4f2892 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/util/DebugInfo.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/util/DebugInfo.java @@ -190,8 +190,8 @@ public abstract class DebugInfo implements Iterable { } case DebugItemType.START_LOCAL: { int register = reader.readSmallUleb128(); - String name = dexFile.getOptionalString(reader.readSmallUleb128() - 1); - String type = dexFile.getOptionalType(reader.readSmallUleb128() - 1); + String name = dexFile.getStringSection().getOptional(reader.readSmallUleb128() - 1); + String type = dexFile.getTypeSection().getOptional(reader.readSmallUleb128() - 1); ImmutableStartLocal startLocal = new ImmutableStartLocal(codeAddress, register, name, type, null); if (register >= 0 && register < locals.length) { @@ -201,9 +201,10 @@ public abstract class DebugInfo implements Iterable { } case DebugItemType.START_LOCAL_EXTENDED: { int register = reader.readSmallUleb128(); - String name = dexFile.getOptionalString(reader.readSmallUleb128() - 1); - String type = dexFile.getOptionalType(reader.readSmallUleb128() - 1); - String signature = dexFile.getOptionalString(reader.readSmallUleb128() - 1); + String name = dexFile.getStringSection().getOptional(reader.readSmallUleb128() - 1); + String type = dexFile.getTypeSection().getOptional(reader.readSmallUleb128() - 1); + String signature = dexFile.getStringSection().getOptional( + reader.readSmallUleb128() - 1); ImmutableStartLocal startLocal = new ImmutableStartLocal(codeAddress, register, name, type, signature); if (register >= 0 && register < locals.length) { @@ -261,7 +262,8 @@ public abstract class DebugInfo implements Iterable { return new ImmutableEpilogueBegin(codeAddress); } case DebugItemType.SET_SOURCE_FILE: { - String sourceFile = dexFile.getOptionalString(reader.readSmallUleb128() - 1); + String sourceFile = dexFile.getStringSection().getOptional( + reader.readSmallUleb128() - 1); return new ImmutableSetSourceFile(codeAddress, sourceFile); } default: { @@ -287,7 +289,7 @@ public abstract class DebugInfo implements Iterable { final int parameterNameCount = reader.readSmallUleb128(); return new VariableSizeIterator(reader, parameterNameCount) { @Override protected String readNextItem(@Nonnull DexReader reader, int index) { - return dexFile.getOptionalString(reader.readSmallUleb128() - 1); + return dexFile.getStringSection().getOptional(reader.readSmallUleb128() - 1); } }; } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/value/DexBackedAnnotationEncodedValue.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/value/DexBackedAnnotationEncodedValue.java index c6854c70..14c5f1c7 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/value/DexBackedAnnotationEncodedValue.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/value/DexBackedAnnotationEncodedValue.java @@ -49,7 +49,7 @@ public class DexBackedAnnotationEncodedValue extends BaseAnnotationEncodedValue public DexBackedAnnotationEncodedValue(@Nonnull DexReader reader) { this.dexFile = reader.dexBuf; - this.type = dexFile.getType(reader.readSmallUleb128()); + this.type = dexFile.getTypeSection().get(reader.readSmallUleb128()); this.elementCount = reader.readSmallUleb128(); this.elementsOffset = reader.getOffset(); skipElements(reader, elementCount); diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/value/DexBackedStringEncodedValue.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/value/DexBackedStringEncodedValue.java index bba3051e..4b6c65d8 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/value/DexBackedStringEncodedValue.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/value/DexBackedStringEncodedValue.java @@ -47,6 +47,6 @@ public class DexBackedStringEncodedValue extends BaseStringEncodedValue { } @Nonnull @Override public String getValue() { - return dexFile.getString(stringIndex); + return dexFile.getStringSection().get(stringIndex); } } diff --git a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/value/DexBackedTypeEncodedValue.java b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/value/DexBackedTypeEncodedValue.java index 9a2fd548..2f331c44 100644 --- a/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/value/DexBackedTypeEncodedValue.java +++ b/dexlib2/src/main/java/org/jf/dexlib2/dexbacked/value/DexBackedTypeEncodedValue.java @@ -47,6 +47,6 @@ public class DexBackedTypeEncodedValue extends BaseTypeEncodedValue { } @Nonnull @Override public String getValue() { - return dexFile.getType(typeIndex); + return dexFile.getTypeSection().get(typeIndex); } }