ReVanced/smali
1
0
Fork 0
mirror of https://github.com/revanced/smali.git synced 2025-05-02 07:34:28 +02:00
Code Issues Packages Projects Releases Wiki Activity

Refactor how annotatations are handled a bit, and add annotations for TypeListItems

Browse Source
This commit is contained in:
Ben Gruver 2013-02-26 22:18:32 -08:00
parent 867723e009
commit ff32d5cc14
12 changed files with 368 additions and 104 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
baksmali/src/main/java/org/jf/baksmali/dump.java
View File

@ -41,7 +41,6 @@ public class dump {
if (dumpFileName != null) {
FileWriter writer = null;
try {
writer = new FileWriter(dumpFileName);
@ -50,7 +49,7 @@ public class dump {
consoleWidth = 120;
}
dexFile.dumpTo(writer, consoleWidth);
dexFile.asRaw().dumpTo(writer, consoleWidth);
} catch (IOException ex) {
System.err.println("There was an error while dumping the dex file to " + dumpFileName);
ex.printStackTrace(System.err);

55
dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedDexFile.java
View File

@ -34,14 +34,11 @@ package org.jf.dexlib2.dexbacked;
import org.jf.dexlib2.dexbacked.raw.*;
import org.jf.dexlib2.dexbacked.util.FixedSizeSet;
import org.jf.dexlib2.iface.DexFile;
import org.jf.dexlib2.util.AnnotatedBytes;
import org.jf.util.ExceptionWithContext;
import org.jf.util.Utf8Utils;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import java.io.IOException;
import java.io.Writer;
import java.util.Set;
public abstract class DexBackedDexFile extends BaseDexBuffer implements DexFile {
@ -61,7 +58,9 @@ public abstract class DexBackedDexFile extends BaseDexBuffer implements DexFile
@Override @Nonnull public abstract DexReader readerAt(int offset);
public abstract void dumpTo(Writer out, int width) throws IOException;
@Nonnull public RawDexFile asRaw() {
return new RawDexFile(buf);
}
public static class Impl extends DexBackedDexFile {
private final int stringCount;
@ -77,11 +76,6 @@ public abstract class DexBackedDexFile extends BaseDexBuffer implements DexFile
private final int classCount;
private final int classStartOffset;
public static final int MAP_ITEM_SIZE = 12;
public static final int TYPE_LIST_SIZE_OFFSET = 0;
public static final int TYPE_LIST_LIST_OFFSET = 4;
public Impl(@Nonnull byte[] buf) {
super(buf);
@ -237,48 +231,5 @@ public abstract class DexBackedDexFile extends BaseDexBuffer implements DexFile
public DexReader readerAt(int offset) {
return new DexReader(this, offset);
}
public void dumpTo(Writer out, int width) throws IOException {
AnnotatedBytes annotatedBytes = new AnnotatedBytes(width);
HeaderItem.getAnnotator().annotateSection(annotatedBytes, this, 1);
if (stringCount > 0) {
annotatedBytes.skipTo(getStringIdItemOffset(0));
annotatedBytes.annotate(0, " ");
StringIdItem.getAnnotator().annotateSection(annotatedBytes, this, stringCount);
}
if (typeCount > 0) {
annotatedBytes.skipTo(getTypeIdItemOffset(0));
annotatedBytes.annotate(0, " ");
TypeIdItem.getAnnotator().annotateSection(annotatedBytes, this, typeCount);
}
if (protoCount > 0) {
annotatedBytes.skipTo(getProtoIdItemOffset(0));
annotatedBytes.annotate(0, " ");
ProtoIdItem.getAnnotator().annotateSection(annotatedBytes, this, protoCount);
}
if (fieldCount > 0) {
annotatedBytes.skipTo(getFieldIdItemOffset(0));
annotatedBytes.annotate(0, " ");
FieldIdItem.getAnnotator().annotateSection(annotatedBytes, this, fieldCount);
}
if (methodCount > 0) {
annotatedBytes.skipTo(getMethodIdItemOffset(0));
annotatedBytes.annotate(0, " ");
MethodIdItem.getAnnotator().annotateSection(annotatedBytes, this, methodCount);
}
if (classCount > 0) {
annotatedBytes.skipTo(getClassDefItemOffset(0));
annotatedBytes.annotate(0, " ");
ClassDefItem.getAnnotator().annotateSection(annotatedBytes, this, classCount);
}
annotatedBytes.writeAnnotations(out, buf);
}
}
}

6
dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedMethod.java
View File

@ -34,6 +34,7 @@ package org.jf.dexlib2.dexbacked;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Iterators;
import org.jf.dexlib2.base.reference.BaseMethodReference;
import org.jf.dexlib2.dexbacked.raw.TypeListItem;
import org.jf.dexlib2.dexbacked.util.AnnotationsDirectory;
import org.jf.dexlib2.dexbacked.util.FixedSizeList;
import org.jf.dexlib2.dexbacked.util.ParameterIterator;
@ -161,9 +162,8 @@ public class DexBackedMethod extends BaseMethodReference implements Method {
public List<String> getParameterTypes() {
final int parametersOffset = getParametersOffset();
if (parametersOffset > 0) {
final int parameterCount = dexFile.readSmallUint(parametersOffset +
DexBackedDexFile.Impl.TYPE_LIST_SIZE_OFFSET);
final int paramListStart = parametersOffset + DexBackedDexFile.Impl.TYPE_LIST_LIST_OFFSET;
final int parameterCount = dexFile.readSmallUint(parametersOffset + TypeListItem.SIZE_OFFSET);
final int paramListStart = parametersOffset + TypeListItem.LIST_OFFSET;
return new FixedSizeList<String>() {
@Nonnull
@Override

5
dexlib2/src/main/java/org/jf/dexlib2/dexbacked/raw/ClassDefItem.java
View File

@ -31,6 +31,8 @@
package org.jf.dexlib2.dexbacked.raw;
import com.google.common.base.Joiner;
import org.jf.dexlib2.AccessFlags;
import org.jf.dexlib2.dexbacked.DexBackedDexFile;
import org.jf.dexlib2.util.AnnotatedBytes;
@ -61,7 +63,8 @@ public class ClassDefItem {
out.annotate(4, "class_idx = %s", TypeIdItem.getReferenceAnnotation(dexFile, classIndex));
int accessFlags = dexFile.readInt(out.getCursor());
out.annotate(4, "access_flags = 0x%x", accessFlags);
out.annotate(4, "access_flags = 0x%x: %s", accessFlags,
Joiner.on('|').join(AccessFlags.getAccessFlagsForClass(accessFlags)));
int superclassIndex = dexFile.readSmallUint(out.getCursor());
out.annotate(4, "superclass_idx = %s", TypeIdItem.getReferenceAnnotation(dexFile, superclassIndex));

64
dexlib2/src/main/java/org/jf/dexlib2/dexbacked/raw/HeaderItem.java
View File

@ -52,6 +52,8 @@ public class HeaderItem {
public static final int SIGNATURE_OFFSET = 12;
public static final int SIGNATURE_SIZE = 20;
public static final int HEADER_SIZE_OFFSET = 36;
public static final int ENDIAN_TAG_OFFSET = 40;
public static final int MAP_OFFSET = 52;
@ -74,6 +76,68 @@ public class HeaderItem {
public static final int CLASS_COUNT_OFFSET = 96;
public static final int CLASS_START_OFFSET = 100;
@Nonnull private DexBackedDexFile dexFile;
public HeaderItem(@Nonnull DexBackedDexFile dexFile) {
this.dexFile = dexFile;
}
public int getMapOffset() {
return dexFile.readSmallUint(MAP_OFFSET);
}
public int getHeaderSize() {
return dexFile.readSmallUint(HEADER_SIZE_OFFSET);
}
public int getStringCount() {
return dexFile.readSmallUint(STRING_COUNT_OFFSET);
}
public int getStringOffset() {
return dexFile.readSmallUint(STRING_START_OFFSET);
}
public int getTypeCount() {
return dexFile.readSmallUint(TYPE_COUNT_OFFSET);
}
public int getTypeOffset() {
return dexFile.readSmallUint(TYPE_START_OFFSET);
}
public int getProtoCount() {
return dexFile.readSmallUint(PROTO_COUNT_OFFSET);
}
public int getProtoOffset() {
return dexFile.readSmallUint(PROTO_START_OFFSET);
}
public int getFieldCount() {
return dexFile.readSmallUint(FIELD_COUNT_OFFSET);
}
public int getFieldOffset() {
return dexFile.readSmallUint(FIELD_START_OFFSET);
}
public int getMethodCount() {
return dexFile.readSmallUint(METHOD_COUNT_OFFSET);
}
public int getMethodOffset() {
return dexFile.readSmallUint(METHOD_START_OFFSET);
}
public int getClassCount() {
return dexFile.readSmallUint(CLASS_COUNT_OFFSET);
}
public int getClassOffset() {
return dexFile.readSmallUint(CLASS_START_OFFSET);
}
@Nonnull
public static SectionAnnotator getAnnotator() {
return new SectionAnnotator() {

45
dexlib2/src/main/java/org/jf/dexlib2/writer/DexItemType.java → dexlib2/src/main/java/org/jf/dexlib2/dexbacked/raw/ItemType.java
View File

@ -29,9 +29,11 @@
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package org.jf.dexlib2.writer;
package org.jf.dexlib2.dexbacked.raw;
public class DexItemType {
import javax.annotation.Nonnull;
public class ItemType {
public static final int HEADER_ITEM = 0x0000;
public static final int STRING_ID_ITEM = 0x0001;
public static final int TYPE_ID_ITEM = 0x0002;
@ -51,27 +53,28 @@ public class DexItemType {
public static final int ENCODED_ARRAY_ITEM = 0x2005;
public static final int ANNOTATION_DIRECTORY_ITEM = 0x2006;
@Nonnull
public static String getItemTypeName(int itemType) {
switch (itemType) {
case HEADER_ITEM: return "HEADER_ITEM";
case STRING_ID_ITEM: return "STRING_ID_ITEM";
case TYPE_ID_ITEM: return "TYPE_ID_ITEM";
case PROTO_ID_ITEM: return "PROTO_ID_ITEM";
case FIELD_ID_ITEM: return "FIELD_ID_ITEM";
case METHOD_ID_ITEM: return "METHOD_ID_ITEM";
case CLASS_DEF_ITEM: return "CLASS_DEF_ITEM";
case MAP_LIST: return "MAP_LIST";
case TYPE_LIST: return "TYPE_LIST";
case ANNOTATION_SET_REF_LIST: return "ANNOTATION_SET_REF_LIST";
case ANNOTATION_SET_ITEM: return "ANNOTATION_SET_ITEM";
case CLASS_DATA_ITEM: return "CLASS_DATA_ITEM";
case CODE_ITEM: return "CODE_ITEM";
case STRING_DATA_ITEM: return "STRING_DATA_ITEM";
case DEBUG_INFO_ITEM: return "DEBUG_INFO_ITEM";
case ANNOTATION_ITEM: return "ANNOTATION_ITEM";
case ENCODED_ARRAY_ITEM: return "ENCODED_ARRAY_ITEM";
case ANNOTATION_DIRECTORY_ITEM: return "ANNOTATION_DIRECTORY_ITEM";
default: return "Unknown dex item type";
case HEADER_ITEM: return "header_item";
case STRING_ID_ITEM: return "string_id_item";
case TYPE_ID_ITEM: return "type_id_item";
case PROTO_ID_ITEM: return "proto_id_item";
case FIELD_ID_ITEM: return "field_id_item";
case METHOD_ID_ITEM: return "method_id_item";
case CLASS_DEF_ITEM: return "class_def_item";
case MAP_LIST: return "map_list";
case TYPE_LIST: return "type_list";
case ANNOTATION_SET_REF_LIST: return "annotation_set_ref_list";
case ANNOTATION_SET_ITEM: return "annotation_set_item";
case CLASS_DATA_ITEM: return "class_data_item";
case CODE_ITEM: return "code_item";
case STRING_DATA_ITEM: return "string_data_item";
case DEBUG_INFO_ITEM: return "debug_info_item";
case ANNOTATION_ITEM: return "annotation_item";
case ENCODED_ARRAY_ITEM: return "encoded_array_item";
case ANNOTATION_DIRECTORY_ITEM: return "annotation_directory_item";
default: return "unknown dex item type";
}
}
}

69
dexlib2/src/main/java/org/jf/dexlib2/dexbacked/raw/MapItem.java Normal file
View File

@ -0,0 +1,69 @@
/*
* Copyright 2013, Google Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package org.jf.dexlib2.dexbacked.raw;
import org.jf.dexlib2.dexbacked.DexBackedDexFile;
import javax.annotation.Nonnull;
public class MapItem {
public static final int ITEM_SIZE = 12;
public static final int TYPE_OFFSET = 0;
public static final int SIZE_OFFSET = 4;
public static final int OFFSET_OFFSET = 8;
private final DexBackedDexFile dexFile;
private final int offset;
public MapItem(DexBackedDexFile dexFile, int offset) {
this.dexFile = dexFile;
this.offset = offset;
}
public int getType() {
return dexFile.readUshort(offset + TYPE_OFFSET);
}
@Nonnull
public String getName() {
return ItemType.getItemTypeName(getType());
}
public int getItemCount() {
return dexFile.readSmallUint(offset + SIZE_OFFSET);
}
public int getOffset() {
return dexFile.readSmallUint(offset + OFFSET_OFFSET);
}
}

138
dexlib2/src/main/java/org/jf/dexlib2/dexbacked/raw/RawDexFile.java Normal file
View File

@ -0,0 +1,138 @@
/*
* Copyright 2013, Google Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package org.jf.dexlib2.dexbacked.raw;
import com.google.common.collect.ImmutableMap;
import org.jf.dexlib2.dexbacked.DexBackedDexFile;
import org.jf.dexlib2.dexbacked.util.FixedSizeList;
import org.jf.dexlib2.util.AnnotatedBytes;
import javax.annotation.Nonnull;
import java.io.IOException;
import java.io.Writer;
import java.util.List;
import java.util.Map;
public class RawDexFile {
@Nonnull private final byte[] buf;
@Nonnull public final DexBackedDexFile dexFile;
@Nonnull public final HeaderItem headerItem;
public RawDexFile(byte[] buf) {
this.buf = buf;
this.dexFile = new DexBackedDexFile.Impl(buf);
this.headerItem = new HeaderItem(dexFile);
}
public int getMapOffset() {
return headerItem.getMapOffset();
}
public List<MapItem> getMapItems() {
final int mapOffset = getMapOffset();
final int mapSize = dexFile.readSmallUint(mapOffset);
return new FixedSizeList<MapItem>() {
@Override
public MapItem readItem(int index) {
int mapItemOffset = mapOffset + 4 + index * MapItem.ITEM_SIZE;
return new MapItem(dexFile, mapItemOffset);
}
@Override public int size() {
return mapSize;
}
};
}
private static final Map<Integer, SectionAnnotator> annotators;
static {
annotators = ImmutableMap.of(ItemType.TYPE_LIST, TypeListItem.getAnnotator());
}
public void dumpTo(Writer out, int width) throws IOException {
AnnotatedBytes annotatedBytes = new AnnotatedBytes(width);
HeaderItem.getAnnotator().annotateSection(annotatedBytes, dexFile, 1);
int stringCount = headerItem.getStringCount();
if (stringCount > 0) {
annotatedBytes.skipTo(headerItem.getStringOffset());
annotatedBytes.annotate(0, " ");
StringIdItem.getAnnotator().annotateSection(annotatedBytes, dexFile, stringCount);
}
int typeCount = headerItem.getTypeCount();
if (typeCount > 0) {
annotatedBytes.skipTo(headerItem.getTypeOffset());
annotatedBytes.annotate(0, " ");
TypeIdItem.getAnnotator().annotateSection(annotatedBytes, dexFile, typeCount);
}
int protoCount = headerItem.getProtoCount();
if (protoCount > 0) {
annotatedBytes.skipTo(headerItem.getProtoOffset());
annotatedBytes.annotate(0, " ");
ProtoIdItem.getAnnotator().annotateSection(annotatedBytes, dexFile, protoCount);
}
int fieldCount = headerItem.getFieldCount();
if (fieldCount > 0) {
annotatedBytes.skipTo(headerItem.getFieldOffset());
annotatedBytes.annotate(0, " ");
FieldIdItem.getAnnotator().annotateSection(annotatedBytes, dexFile, fieldCount);
}
int methodCount = headerItem.getMethodCount();
if (methodCount > 0) {
annotatedBytes.skipTo(headerItem.getMethodOffset());
annotatedBytes.annotate(0, " ");
MethodIdItem.getAnnotator().annotateSection(annotatedBytes, dexFile, methodCount);
}
int classCount = headerItem.getClassCount();
if (classCount > 0) {
annotatedBytes.skipTo(headerItem.getClassOffset());
annotatedBytes.annotate(0, " ");
ClassDefItem.getAnnotator().annotateSection(annotatedBytes, dexFile, classCount);
}
for (MapItem mapItem: getMapItems()) {
SectionAnnotator annotator = annotators.get(mapItem.getType());
if (annotator != null) {
annotatedBytes.skipTo(mapItem.getOffset());
annotator.annotateSection(annotatedBytes, dexFile, mapItem.getItemCount());
}
}
annotatedBytes.writeAnnotations(out, buf);
}
}

16
dexlib2/src/main/java/org/jf/dexlib2/dexbacked/raw/SectionAnnotator.java
View File

@ -33,6 +33,7 @@ package org.jf.dexlib2.dexbacked.raw;
import org.jf.dexlib2.dexbacked.DexBackedDexFile;
import org.jf.dexlib2.util.AnnotatedBytes;
import org.jf.util.AlignmentUtils;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
@ -46,17 +47,20 @@ public abstract class SectionAnnotator {
*
* @param out The AnnotatedBytes object to annotate to
* @param dexFile The DexBackedDexFile representing the dex file being annotated
* @param length The number of items in the section (from the header/map)
* @param itemCount The number of items in the section (from the header/map)
*/
public void annotateSection(@Nonnull AnnotatedBytes out, @Nonnull DexBackedDexFile dexFile, int length) {
public void annotateSection(@Nonnull AnnotatedBytes out, @Nonnull DexBackedDexFile dexFile, int itemCount) {
String itemName = getItemName();
if (length > 0) {
int itemAlignment = getItemAlignment();
if (itemCount > 0) {
out.annotate(0, "-----------------------------");
out.annotate(0, "%s section", itemName);
out.annotate(0, "-----------------------------");
out.annotate(0, "");
for (int i=0; i<length; i++) {
for (int i=0; i<itemCount; i++) {
out.skipTo(AlignmentUtils.alignOffset(out.getCursor(), itemAlignment));
String itemIdentity = getItemIdentity(dexFile, out.getCursor(), i);
if (itemIdentity != null) {
out.annotate(0, "[%d] %s: %s", i, itemName, itemIdentity);
@ -73,4 +77,8 @@ public abstract class SectionAnnotator {
@Nullable public String getItemIdentity(@Nonnull DexBackedDexFile dexFile, int itemIndex, int itemOffset) {
return null;
}
public int getItemAlignment() {
return 1;
}
}

28
dexlib2/src/main/java/org/jf/dexlib2/dexbacked/raw/TypeListItem.java
View File

@ -32,10 +32,38 @@
package org.jf.dexlib2.dexbacked.raw;
import org.jf.dexlib2.dexbacked.DexBackedDexFile;
import org.jf.dexlib2.util.AnnotatedBytes;
import javax.annotation.Nonnull;
public class TypeListItem {
public static final int SIZE_OFFSET = 0;
public static final int LIST_OFFSET = 4;
@Nonnull
public static SectionAnnotator getAnnotator() {
return new SectionAnnotator() {
@Nonnull @Override public String getItemName() {
return "type_list";
}
@Override
protected void annotateItem(@Nonnull AnnotatedBytes out, @Nonnull DexBackedDexFile dexFile, int itemIndex) {
int size = dexFile.readSmallUint(out.getCursor());
out.annotate(4, "size: %d", size);
for (int i=0; i<size; i++) {
int typeIndex = dexFile.readUshort(out.getCursor());
out.annotate(2, TypeIdItem.getReferenceAnnotation(dexFile, typeIndex));
}
}
@Override public int getItemAlignment() {
return 4;
}
};
}
@Nonnull
public static String getReferenceAnnotation(@Nonnull DexBackedDexFile dexFile, int typeListOffset) {
if (typeListOffset == 0) {

6
dexlib2/src/main/java/org/jf/dexlib2/dexbacked/reference/DexBackedMethodReference.java
View File

@ -36,6 +36,7 @@ import org.jf.dexlib2.base.reference.BaseMethodReference;
import org.jf.dexlib2.dexbacked.DexBackedDexFile;
import org.jf.dexlib2.dexbacked.raw.MethodIdItem;
import org.jf.dexlib2.dexbacked.raw.ProtoIdItem;
import org.jf.dexlib2.dexbacked.raw.TypeListItem;
import org.jf.dexlib2.dexbacked.util.FixedSizeList;
import javax.annotation.Nonnull;
@ -69,9 +70,8 @@ public class DexBackedMethodReference extends BaseMethodReference {
int protoIdItemOffset = getProtoIdItemOffset();
final int parametersOffset = dexFile.readSmallUint(protoIdItemOffset + ProtoIdItem.PARAMETERS_OFFSET);
if (parametersOffset > 0) {
final int parameterCount = dexFile.readSmallUint(parametersOffset +
DexBackedDexFile.Impl.TYPE_LIST_SIZE_OFFSET);
final int paramListStart = parametersOffset + DexBackedDexFile.Impl.TYPE_LIST_LIST_OFFSET;
final int parameterCount = dexFile.readSmallUint(parametersOffset + TypeListItem.SIZE_OFFSET);
final int paramListStart = parametersOffset + TypeListItem.LIST_OFFSET;
return new FixedSizeList<String>() {
@Nonnull
@Override

37
dexlib2/src/main/java/org/jf/dexlib2/writer/MapItem.java
View File

@ -31,6 +31,7 @@
package org.jf.dexlib2.writer;
import org.jf.dexlib2.dexbacked.raw.ItemType;
import org.jf.util.ExceptionWithContext;
import javax.annotation.Nonnull;
@ -59,26 +60,26 @@ public class MapItem {
writer.writeInt(numItems);
// index section
writeItem(writer, DexItemType.HEADER_ITEM, 1, 0);
writeItem(writer, DexItemType.STRING_ID_ITEM, dexFile.stringPool.getNumItems(), dexFile.stringPool.getIndexSectionOffset());
writeItem(writer, DexItemType.TYPE_ID_ITEM, dexFile.typePool.getNumItems(), dexFile.typePool.getSectionOffset());
writeItem(writer, DexItemType.PROTO_ID_ITEM, dexFile.protoPool.getNumItems(), dexFile.protoPool.getSectionOffset());
writeItem(writer, DexItemType.FIELD_ID_ITEM, dexFile.fieldPool.getNumItems(), dexFile.fieldPool.getSectionOffset());
writeItem(writer, DexItemType.METHOD_ID_ITEM, dexFile.methodPool.getNumItems(), dexFile.methodPool.getSectionOffset());
writeItem(writer, DexItemType.CLASS_DEF_ITEM, dexFile.classDefPool.getNumClassDefItems(), dexFile.classDefPool.getIndexSectionOffset());
writeItem(writer, ItemType.HEADER_ITEM, 1, 0);
writeItem(writer, ItemType.STRING_ID_ITEM, dexFile.stringPool.getNumItems(), dexFile.stringPool.getIndexSectionOffset());
writeItem(writer, ItemType.TYPE_ID_ITEM, dexFile.typePool.getNumItems(), dexFile.typePool.getSectionOffset());
writeItem(writer, ItemType.PROTO_ID_ITEM, dexFile.protoPool.getNumItems(), dexFile.protoPool.getSectionOffset());
writeItem(writer, ItemType.FIELD_ID_ITEM, dexFile.fieldPool.getNumItems(), dexFile.fieldPool.getSectionOffset());
writeItem(writer, ItemType.METHOD_ID_ITEM, dexFile.methodPool.getNumItems(), dexFile.methodPool.getSectionOffset());
writeItem(writer, ItemType.CLASS_DEF_ITEM, dexFile.classDefPool.getNumClassDefItems(), dexFile.classDefPool.getIndexSectionOffset());
// data section
writeItem(writer, DexItemType.STRING_DATA_ITEM, dexFile.stringPool.getNumItems(), dexFile.stringPool.getDataSectionOffset());
writeItem(writer, DexItemType.TYPE_LIST, dexFile.typeListPool.getNumItems(), dexFile.typeListPool.getSectionOffset());
writeItem(writer, DexItemType.ENCODED_ARRAY_ITEM, dexFile.encodedArrayPool.getNumItems(), dexFile.encodedArrayPool.getSectionOffset());
writeItem(writer, DexItemType.ANNOTATION_ITEM, dexFile.annotationPool.getNumItems(), dexFile.annotationPool.getSectionOffset());
writeItem(writer, DexItemType.ANNOTATION_SET_ITEM, dexFile.annotationSetPool.getNumItems(), dexFile.annotationSetPool.getSectionOffset());
writeItem(writer, DexItemType.ANNOTATION_SET_REF_LIST, dexFile.annotationSetRefPool.getNumItems(), dexFile.annotationSetRefPool.getSectionOffset());
writeItem(writer, DexItemType.ANNOTATION_DIRECTORY_ITEM, dexFile.annotationDirectoryPool.getNumItems(), dexFile.annotationDirectoryPool.getSectionOffset());
writeItem(writer, DexItemType.DEBUG_INFO_ITEM, dexFile.debugInfoPool.getNumItems(), dexFile.debugInfoPool.getSectionOffset());
writeItem(writer, DexItemType.CODE_ITEM, dexFile.codeItemPool.getNumItems(), dexFile.codeItemPool.getSectionOffset());
writeItem(writer, DexItemType.CLASS_DATA_ITEM, dexFile.classDefPool.getNumClassDataItems(), dexFile.classDefPool.getDataSectionOffset());
writeItem(writer, DexItemType.MAP_LIST, 1, sectionOffset);
writeItem(writer, ItemType.STRING_DATA_ITEM, dexFile.stringPool.getNumItems(), dexFile.stringPool.getDataSectionOffset());
writeItem(writer, ItemType.TYPE_LIST, dexFile.typeListPool.getNumItems(), dexFile.typeListPool.getSectionOffset());
writeItem(writer, ItemType.ENCODED_ARRAY_ITEM, dexFile.encodedArrayPool.getNumItems(), dexFile.encodedArrayPool.getSectionOffset());
writeItem(writer, ItemType.ANNOTATION_ITEM, dexFile.annotationPool.getNumItems(), dexFile.annotationPool.getSectionOffset());
writeItem(writer, ItemType.ANNOTATION_SET_ITEM, dexFile.annotationSetPool.getNumItems(), dexFile.annotationSetPool.getSectionOffset());
writeItem(writer, ItemType.ANNOTATION_SET_REF_LIST, dexFile.annotationSetRefPool.getNumItems(), dexFile.annotationSetRefPool.getSectionOffset());
writeItem(writer, ItemType.ANNOTATION_DIRECTORY_ITEM, dexFile.annotationDirectoryPool.getNumItems(), dexFile.annotationDirectoryPool.getSectionOffset());
writeItem(writer, ItemType.DEBUG_INFO_ITEM, dexFile.debugInfoPool.getNumItems(), dexFile.debugInfoPool.getSectionOffset());
writeItem(writer, ItemType.CODE_ITEM, dexFile.codeItemPool.getNumItems(), dexFile.codeItemPool.getSectionOffset());
writeItem(writer, ItemType.CLASS_DATA_ITEM, dexFile.classDefPool.getNumClassDataItems(), dexFile.classDefPool.getDataSectionOffset());
writeItem(writer, ItemType.MAP_LIST, 1, sectionOffset);
}
private int calcNumItems() {