* limitations under the License.
*/
-package com.android.dx.io;
+package com.android.dex;
-import com.android.dx.util.ByteArrayByteInput;
+import com.android.dex.util.ByteArrayByteInput;
import junit.framework.TestCase;
public final class EncodedValueReaderTest extends TestCase {
* limitations under the License.
*/
-package com.android.dx.util;
+package com.android.dx.util._tests;
+import com.android.dx.util.BitIntSet;
+import com.android.dx.util.IntIterator;
+import com.android.dx.util.ListIntSet;
import java.util.NoSuchElementException;
import junit.framework.TestCase;
* limitations under the License.
*/
-package com.android.dx.util;
+package com.android.dx.util._tests;
+import com.android.dx.util.Bits;
import junit.framework.TestCase;
public final class BitsTest extends TestCase {
* limitations under the License.
*/
-package com.android.dx.util;
+package com.android.dx.util._tests;
+import com.android.dx.util.IntList;
import junit.framework.TestCase;
public final class IntListTest extends TestCase {
* limitations under the License.
*/
-package com.android.dx.util;
+package com.android.dx.util._tests;
+import com.android.dx.util.BitIntSet;
+import com.android.dx.util.IntIterator;
+import com.android.dx.util.ListIntSet;
import java.util.NoSuchElementException;
import junit.framework.TestCase;
* limitations under the License.
*/
-package com.android.dx.io;
+package com.android.dex;
-import static com.android.dx.io.EncodedValueReader.ENCODED_ANNOTATION;
+import static com.android.dex.EncodedValueReader.ENCODED_ANNOTATION;
/**
* An annotation.
*/
public final class Annotation implements Comparable<Annotation> {
- private final DexBuffer buffer;
+ private final Dex dex;
private final byte visibility;
private final EncodedValue encodedAnnotation;
- public Annotation(DexBuffer dexBuffer, byte visibility, EncodedValue encodedAnnotation) {
- this.buffer = dexBuffer;
+ public Annotation(Dex dex, byte visibility, EncodedValue encodedAnnotation) {
+ this.dex = dex;
this.visibility = visibility;
this.encodedAnnotation = encodedAnnotation;
}
return reader.getAnnotationType();
}
- public void writeTo(DexBuffer.Section out) {
+ public void writeTo(Dex.Section out) {
out.writeByte(visibility);
encodedAnnotation.writeTo(out);
}
}
@Override public String toString() {
- return buffer == null
+ return dex == null
? visibility + " " + getTypeIndex()
- : visibility + " " + buffer.typeNames().get(getTypeIndex());
+ : visibility + " " + dex.typeNames().get(getTypeIndex());
}
}
* limitations under the License.
*/
-package com.android.dx.io;
+package com.android.dex;
public final class ClassData {
private final Field[] staticFields;
* limitations under the License.
*/
-package com.android.dx.io;
+package com.android.dex;
/**
* A type definition.
*/
public final class ClassDef {
public static final int NO_INDEX = -1;
- private final DexBuffer buffer;
+ private final Dex buffer;
private final int offset;
private final int typeIndex;
private final int accessFlags;
private final int classDataOffset;
private final int staticValuesOffset;
- public ClassDef(DexBuffer buffer, int offset, int typeIndex, int accessFlags,
+ public ClassDef(Dex buffer, int offset, int typeIndex, int accessFlags,
int supertypeIndex, int interfacesOffset, int sourceFileIndex,
int annotationsOffset, int classDataOffset, int staticValuesOffset) {
this.buffer = buffer;
* limitations under the License.
*/
-package com.android.dx.io;
+package com.android.dex;
public final class Code {
private final int registersSize;
* limitations under the License.
*/
-package com.android.dx.io;
-
-import com.android.dx.dex.DexFormat;
-import com.android.dx.dex.SizeOf;
-import com.android.dx.dex.TableOfContents;
-import com.android.dx.io.Code.CatchHandler;
-import com.android.dx.io.Code.Try;
-import com.android.dx.merge.TypeList;
-import com.android.dx.util.ByteInput;
-import com.android.dx.util.ByteOutput;
-import com.android.dx.util.DexException;
-import com.android.dx.util.FileUtils;
-import com.android.dx.util.Leb128Utils;
-import com.android.dx.util.Mutf8;
+package com.android.dex;
+
+import com.android.dex.Code.CatchHandler;
+import com.android.dex.Code.Try;
+import com.android.dex.util.ByteInput;
+import com.android.dex.util.ByteOutput;
+import com.android.dex.util.FileUtils;
+
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
* The bytes of a dex file in memory for reading and writing. All int offsets
* are unsigned.
*/
-public final class DexBuffer {
+public final class Dex {
private byte[] data;
private final TableOfContents tableOfContents = new TableOfContents();
private int length = 0;
/**
* Creates a new dex buffer defining no classes.
*/
- public DexBuffer() {
+ public Dex() {
this.data = new byte[0];
}
* Creates a new dex buffer that reads from {@code data}. It is an error to
* modify {@code data} after using it to create a dex buffer.
*/
- public DexBuffer(byte[] data) throws IOException {
+ public Dex(byte[] data) throws IOException {
this.data = data;
this.length = data.length;
this.tableOfContents.readFrom(this);
/**
* Creates a new dex buffer of the dex in {@code in}, and closes {@code in}.
*/
- public DexBuffer(InputStream in) throws IOException {
+ public Dex(InputStream in) throws IOException {
loadFrom(in);
}
/**
* Creates a new dex buffer from the dex file {@code file}.
*/
- public DexBuffer(File file) throws IOException {
+ public Dex(File file) throws IOException {
if (FileUtils.hasArchiveSuffix(file.getName())) {
ZipFile zipFile = new ZipFile(file);
ZipEntry entry = zipFile.getEntry(DexFormat.DEX_IN_JAR_NAME);
return Collections.<ClassDef>emptySet().iterator();
}
return new Iterator<ClassDef>() {
- private DexBuffer.Section in = open(tableOfContents.classDefs.off);
+ private Dex.Section in = open(tableOfContents.classDefs.off);
private int count = 0;
public boolean hasNext() {
}
public int readUleb128() {
- return Leb128Utils.readUnsignedLeb128(this);
+ return Leb128.readUnsignedLeb128(this);
}
public int readUleb128p1() {
- return Leb128Utils.readUnsignedLeb128(this) - 1;
+ return Leb128.readUnsignedLeb128(this) - 1;
}
public int readSleb128() {
- return Leb128Utils.readSignedLeb128(this);
+ return Leb128.readSignedLeb128(this);
}
public TypeList readTypeList() {
types[i] = readShort();
}
alignToFourBytes();
- return new TypeList(DexBuffer.this, types);
+ return new TypeList(Dex.this, types);
}
public String readString() {
int declaringClassIndex = readUnsignedShort();
int typeIndex = readUnsignedShort();
int nameIndex = readInt();
- return new FieldId(DexBuffer.this, declaringClassIndex, typeIndex, nameIndex);
+ return new FieldId(Dex.this, declaringClassIndex, typeIndex, nameIndex);
}
public MethodId readMethodId() {
int declaringClassIndex = readUnsignedShort();
int protoIndex = readUnsignedShort();
int nameIndex = readInt();
- return new MethodId(DexBuffer.this, declaringClassIndex, protoIndex, nameIndex);
+ return new MethodId(Dex.this, declaringClassIndex, protoIndex, nameIndex);
}
public ProtoId readProtoId() {
int shortyIndex = readInt();
int returnTypeIndex = readInt();
int parametersOffset = readInt();
- return new ProtoId(DexBuffer.this, shortyIndex, returnTypeIndex, parametersOffset);
+ return new ProtoId(Dex.this, shortyIndex, returnTypeIndex, parametersOffset);
}
public ClassDef readClassDef() {
int annotationsOffset = readInt();
int classDataOffset = readInt();
int staticValuesOffset = readInt();
- return new ClassDef(DexBuffer.this, offset, type, accessFlags, supertype,
+ return new ClassDef(Dex.this, offset, type, accessFlags, supertype,
interfacesOffset, sourceFileIndex, annotationsOffset, classDataOffset,
staticValuesOffset);
}
int start = position;
new EncodedValueReader(this, EncodedValueReader.ENCODED_ANNOTATION).skipValue();
int end = position;
- return new Annotation(DexBuffer.this, visibility,
+ return new Annotation(Dex.this, visibility,
new EncodedValue(Arrays.copyOfRange(data, start, end)));
}
*/
public void alignToFourBytes() {
int unalignedCount = position;
- position = DexBuffer.fourByteAlign(position);
+ position = Dex.fourByteAlign(position);
for (int i = unalignedCount; i < position; i++) {
data[i] = 0;
}
public void writeUleb128(int i) {
try {
- Leb128Utils.writeUnsignedLeb128(this, i);
+ Leb128.writeUnsignedLeb128(this, i);
ensureCapacity(0);
} catch (ArrayIndexOutOfBoundsException e) {
throw new DexException("Section limit " + limit + " exceeded by " + name);
public void writeSleb128(int i) {
try {
- Leb128Utils.writeSignedLeb128(this, i);
+ Leb128.writeSignedLeb128(this, i);
ensureCapacity(0);
} catch (ArrayIndexOutOfBoundsException e) {
throw new DexException("Section limit " + limit + " exceeded by " + name);
* limitations under the License.
*/
-package com.android.dx.util;
+package com.android.dex;
+
+import com.android.dex.util.ExceptionWithContext;
/**
* Thrown when there's a format problem reading, writing, or generally
* limitations under the License.
*/
-package com.android.dx.dex;
+package com.android.dex;
/**
* Constants that show up in and are otherwise related to {@code .dex}
* limitations under the License.
*/
-package com.android.dx.io;
+package com.android.dex;
-import com.android.dx.util.ByteArrayByteInput;
-import com.android.dx.util.ByteInput;
+import com.android.dex.util.ByteArrayByteInput;
+import com.android.dex.util.ByteInput;
/**
* An encoded value or array.
return data;
}
- public void writeTo(DexBuffer.Section out) {
+ public void writeTo(Dex.Section out) {
out.write(data);
}
* limitations under the License.
*/
-package com.android.dx.util;
+package com.android.dex;
+
+import com.android.dex.util.ByteInput;
+import com.android.dex.util.ByteOutput;
/**
- * Helpers for {@code encoded_values} and parts thereof.
+ * Read and write {@code encoded_value} primitives.
*/
-public final class EncodedValueUtils {
- private EncodedValueUtils() {
+public final class EncodedValueCodec {
+ private EncodedValueCodec() {
}
/**
* limitations under the License.
*/
-package com.android.dx.io;
+package com.android.dex;
-import com.android.dx.util.ByteInput;
-import com.android.dx.util.DexException;
-import com.android.dx.util.EncodedValueUtils;
-import com.android.dx.util.Leb128Utils;
+import com.android.dex.util.ByteInput;
/**
* Pull parser for encoded values.
public int readArray() {
checkType(ENCODED_ARRAY);
type = MUST_READ;
- return Leb128Utils.readUnsignedLeb128(in);
+ return Leb128.readUnsignedLeb128(in);
}
/**
public int readAnnotation() {
checkType(ENCODED_ANNOTATION);
type = MUST_READ;
- annotationType = Leb128Utils.readUnsignedLeb128(in);
- return Leb128Utils.readUnsignedLeb128(in);
+ annotationType = Leb128.readUnsignedLeb128(in);
+ return Leb128.readUnsignedLeb128(in);
}
/**
}
public int readAnnotationName() {
- return Leb128Utils.readUnsignedLeb128(in);
+ return Leb128.readUnsignedLeb128(in);
}
public byte readByte() {
checkType(ENCODED_BYTE);
type = MUST_READ;
- return (byte) EncodedValueUtils.readSignedInt(in, arg);
+ return (byte) EncodedValueCodec.readSignedInt(in, arg);
}
public short readShort() {
checkType(ENCODED_SHORT);
type = MUST_READ;
- return (short) EncodedValueUtils.readSignedInt(in, arg);
+ return (short) EncodedValueCodec.readSignedInt(in, arg);
}
public char readChar() {
checkType(ENCODED_CHAR);
type = MUST_READ;
- return (char) EncodedValueUtils.readUnsignedInt(in, arg, false);
+ return (char) EncodedValueCodec.readUnsignedInt(in, arg, false);
}
public int readInt() {
checkType(ENCODED_INT);
type = MUST_READ;
- return EncodedValueUtils.readSignedInt(in, arg);
+ return EncodedValueCodec.readSignedInt(in, arg);
}
public long readLong() {
checkType(ENCODED_LONG);
type = MUST_READ;
- return EncodedValueUtils.readSignedLong(in, arg);
+ return EncodedValueCodec.readSignedLong(in, arg);
}
public float readFloat() {
checkType(ENCODED_FLOAT);
type = MUST_READ;
- return Float.intBitsToFloat(EncodedValueUtils.readUnsignedInt(in, arg, true));
+ return Float.intBitsToFloat(EncodedValueCodec.readUnsignedInt(in, arg, true));
}
public double readDouble() {
checkType(ENCODED_DOUBLE);
type = MUST_READ;
- return Double.longBitsToDouble(EncodedValueUtils.readUnsignedLong(in, arg, true));
+ return Double.longBitsToDouble(EncodedValueCodec.readUnsignedLong(in, arg, true));
}
public int readString() {
checkType(ENCODED_STRING);
type = MUST_READ;
- return EncodedValueUtils.readUnsignedInt(in, arg, false);
+ return EncodedValueCodec.readUnsignedInt(in, arg, false);
}
public int readType() {
checkType(ENCODED_TYPE);
type = MUST_READ;
- return EncodedValueUtils.readUnsignedInt(in, arg, false);
+ return EncodedValueCodec.readUnsignedInt(in, arg, false);
}
public int readField() {
checkType(ENCODED_FIELD);
type = MUST_READ;
- return EncodedValueUtils.readUnsignedInt(in, arg, false);
+ return EncodedValueCodec.readUnsignedInt(in, arg, false);
}
public int readEnum() {
checkType(ENCODED_ENUM);
type = MUST_READ;
- return EncodedValueUtils.readUnsignedInt(in, arg, false);
+ return EncodedValueCodec.readUnsignedInt(in, arg, false);
}
public int readMethod() {
checkType(ENCODED_METHOD);
type = MUST_READ;
- return EncodedValueUtils.readUnsignedInt(in, arg, false);
+ return EncodedValueCodec.readUnsignedInt(in, arg, false);
}
public void readNull() {
* limitations under the License.
*/
-package com.android.dx.io;
+package com.android.dex;
-import com.android.dx.util.Unsigned;
+import com.android.dex.util.Unsigned;
public final class FieldId implements Comparable<FieldId> {
- private final DexBuffer buffer;
+ private final Dex dex;
private final int declaringClassIndex;
private final int typeIndex;
private final int nameIndex;
- public FieldId(DexBuffer buffer, int declaringClassIndex, int typeIndex, int nameIndex) {
- this.buffer = buffer;
+ public FieldId(Dex dex, int declaringClassIndex, int typeIndex, int nameIndex) {
+ this.dex = dex;
this.declaringClassIndex = declaringClassIndex;
this.typeIndex = typeIndex;
this.nameIndex = nameIndex;
return Unsigned.compare(typeIndex, other.typeIndex); // should always be 0
}
- public void writeTo(DexBuffer.Section out) {
+ public void writeTo(Dex.Section out) {
out.writeUnsignedShort(declaringClassIndex);
out.writeUnsignedShort(typeIndex);
out.writeInt(nameIndex);
}
@Override public String toString() {
- if (buffer == null) {
+ if (dex == null) {
return declaringClassIndex + " " + typeIndex + " " + nameIndex;
}
- return buffer.typeNames().get(typeIndex) + "." + buffer.strings().get(nameIndex);
+ return dex.typeNames().get(typeIndex) + "." + dex.strings().get(nameIndex);
}
}
* limitations under the License.
*/
-package com.android.dx.util;
+package com.android.dex;
+
+import com.android.dex.util.ByteInput;
+import com.android.dex.util.ByteOutput;
/**
* Reads and writes DWARFv3 LEB 128 signed and unsigned integers. See DWARF v3
* section 7.6.
*/
-public final class Leb128Utils {
- /**
- * This class is uninstantiable.
- */
- private Leb128Utils() {
- // This space intentionally left blank.
+public final class Leb128 {
+ private Leb128() {
}
/**
* limitations under the License.
*/
-package com.android.dx.io;
+package com.android.dex;
-import com.android.dx.util.Unsigned;
+import com.android.dex.util.Unsigned;
public final class MethodId implements Comparable<MethodId> {
- private final DexBuffer buffer;
+ private final Dex dex;
private final int declaringClassIndex;
private final int protoIndex;
private final int nameIndex;
- public MethodId(DexBuffer buffer, int declaringClassIndex, int protoIndex, int nameIndex) {
- this.buffer = buffer;
+ public MethodId(Dex dex, int declaringClassIndex, int protoIndex, int nameIndex) {
+ this.dex = dex;
this.declaringClassIndex = declaringClassIndex;
this.protoIndex = protoIndex;
this.nameIndex = nameIndex;
return Unsigned.compare(protoIndex, other.protoIndex);
}
- public void writeTo(DexBuffer.Section out) {
+ public void writeTo(Dex.Section out) {
out.writeUnsignedShort(declaringClassIndex);
out.writeUnsignedShort(protoIndex);
out.writeInt(nameIndex);
}
@Override public String toString() {
- if (buffer == null) {
+ if (dex == null) {
return declaringClassIndex + " " + protoIndex + " " + nameIndex;
}
- return buffer.typeNames().get(declaringClassIndex)
- + "." + buffer.strings().get(nameIndex)
- + buffer.readTypeList(buffer.protoIds().get(protoIndex).getParametersOffset());
+ return dex.typeNames().get(declaringClassIndex)
+ + "." + dex.strings().get(nameIndex)
+ + dex.readTypeList(dex.protoIds().get(protoIndex).getParametersOffset());
}
}
* limitations under the License.
*/
-package com.android.dx.util;
+package com.android.dex;
+import com.android.dex.util.ByteInput;
import java.io.UTFDataFormatException;
/**
* limitations under the License.
*/
-package com.android.dx.io;
+package com.android.dex;
-import com.android.dx.util.Unsigned;
+import com.android.dex.util.Unsigned;
public final class ProtoId implements Comparable<ProtoId> {
- private final DexBuffer buffer;
+ private final Dex dex;
private final int shortyIndex;
private final int returnTypeIndex;
private final int parametersOffset;
- public ProtoId(DexBuffer buffer, int shortyIndex, int returnTypeIndex, int parametersOffset) {
- this.buffer = buffer;
+ public ProtoId(Dex dex, int shortyIndex, int returnTypeIndex, int parametersOffset) {
+ this.dex = dex;
this.shortyIndex = shortyIndex;
this.returnTypeIndex = returnTypeIndex;
this.parametersOffset = parametersOffset;
return parametersOffset;
}
- public void writeTo(DexBuffer.Section out) {
+ public void writeTo(Dex.Section out) {
out.writeInt(shortyIndex);
out.writeInt(returnTypeIndex);
out.writeInt(parametersOffset);
}
@Override public String toString() {
- if (buffer == null) {
+ if (dex == null) {
return shortyIndex + " " + returnTypeIndex + " " + parametersOffset;
}
- return buffer.strings().get(shortyIndex)
- + ": " + buffer.typeNames().get(returnTypeIndex)
- + " " + buffer.readTypeList(parametersOffset);
+ return dex.strings().get(shortyIndex)
+ + ": " + dex.typeNames().get(returnTypeIndex)
+ + " " + dex.readTypeList(parametersOffset);
}
}
* limitations under the License.
*/
-package com.android.dx.dex;
+package com.android.dex;
public final class SizeOf {
private SizeOf() {}
* limitations under the License.
*/
-package com.android.dx.dex;
+package com.android.dex;
-import com.android.dx.io.DexBuffer;
-import com.android.dx.util.DexException;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.Arrays;
signature = new byte[20];
}
- public void readFrom(DexBuffer buffer) throws IOException {
- readHeader(buffer.open(0));
- readMap(buffer.open(mapList.off));
+ public void readFrom(Dex dex) throws IOException {
+ readHeader(dex.open(0));
+ readMap(dex.open(mapList.off));
computeSizesFromOffsets();
}
- private void readHeader(DexBuffer.Section headerIn) throws UnsupportedEncodingException {
+ private void readHeader(Dex.Section headerIn) throws UnsupportedEncodingException {
byte[] magic = headerIn.readByteArray(8);
int apiTarget = DexFormat.magicToApi(magic);
dataOff = headerIn.readInt();
}
- private void readMap(DexBuffer.Section in) throws IOException {
+ private void readMap(Dex.Section in) throws IOException {
int mapSize = in.readInt();
Section previous = null;
for (int i = 0; i < mapSize; i++) {
throw new IllegalArgumentException("No such map item: " + type);
}
- public void writeHeader(DexBuffer.Section out) throws IOException {
+ public void writeHeader(Dex.Section out) throws IOException {
out.write(DexFormat.apiToMagic(DexFormat.API_NO_EXTENDED_OPCODES).getBytes("UTF-8"));
out.writeInt(checksum);
out.write(signature);
out.writeInt(dataOff);
}
- public void writeMap(DexBuffer.Section out) throws IOException {
+ public void writeMap(Dex.Section out) throws IOException {
int count = 0;
for (Section section : sections) {
if (section.exists()) {
* limitations under the License.
*/
-package com.android.dx.merge;
+package com.android.dex;
-import com.android.dx.io.DexBuffer;
-import com.android.dx.util.Unsigned;
-import java.util.Arrays;
+import com.android.dex.util.Unsigned;
public final class TypeList implements Comparable<TypeList> {
public static final TypeList EMPTY = new TypeList(null, new short[0]);
- private final DexBuffer buffer;
+ private final Dex dex;
private final short[] types;
- public TypeList(DexBuffer buffer, short[] types) {
- this.buffer = buffer;
+ public TypeList(Dex dex, short[] types) {
+ this.dex = dex;
this.types = types;
}
StringBuilder result = new StringBuilder();
result.append("(");
for (int i = 0, typesLength = types.length; i < typesLength; i++) {
- result.append(buffer != null ? buffer.typeNames().get(types[i]) : types[i]);
+ result.append(dex != null ? dex.typeNames().get(types[i]) : types[i]);
}
result.append(")");
return result.toString();
* limitations under the License.
*/
-package com.android.dx.util;
+package com.android.dex.util;
public final class ByteArrayByteInput implements ByteInput {
* limitations under the License.
*/
-package com.android.dx.util;
+package com.android.dex.util;
/**
* A byte source.
* limitations under the License.
*/
-package com.android.dx.util;
+package com.android.dex.util;
/**
* A byte sink.
* limitations under the License.
*/
-package com.android.dx.util;
+package com.android.dex.util;
import java.io.PrintStream;
import java.io.PrintWriter;
/**
* Exception which carries around structured context.
*/
-public class ExceptionWithContext
- extends RuntimeException {
+public class ExceptionWithContext extends RuntimeException {
/** {@code non-null;} human-oriented context of the exception */
private StringBuffer context;
* limitations under the License.
*/
-package com.android.dx.util;
+package com.android.dex.util;
import java.io.File;
import java.io.FileInputStream;
* File I/O utilities.
*/
public final class FileUtils {
- /**
- * This class is uninstantiable.
- */
private FileUtils() {
- // This space intentionally left blank.
}
/**
* limitations under the License.
*/
-package com.android.dx.util;
+package com.android.dex.util;
/**
* Unsigned arithmetic over Java's signed types.
package com.android.dx.cf.code;
-import com.android.dx.rop.code.RegisterSpec;
import com.android.dx.rop.code.LocalItem;
+import com.android.dx.rop.code.RegisterSpec;
import com.android.dx.rop.cst.Constant;
import com.android.dx.rop.type.Prototype;
import com.android.dx.rop.type.StdTypeList;
import com.android.dx.rop.cst.Constant;
import com.android.dx.rop.cst.CstMemberRef;
-import com.android.dx.rop.cst.CstType;
import com.android.dx.rop.cst.CstString;
+import com.android.dx.rop.cst.CstType;
import com.android.dx.rop.type.Type;
import com.android.dx.util.Bits;
import com.android.dx.util.IntList;
package com.android.dx.cf.code;
-import com.android.dx.util.FixedSizeList;
import com.android.dx.util.Hex;
import com.android.dx.util.LabeledList;
package com.android.dx.cf.code;
+import com.android.dex.util.ExceptionWithContext;
import com.android.dx.rop.type.Type;
import com.android.dx.rop.type.TypeBearer;
-import com.android.dx.util.ExceptionWithContext;
import com.android.dx.util.Hex;
import com.android.dx.util.MutabilityControl;
package com.android.dx.cf.code;
+import com.android.dex.util.ExceptionWithContext;
import com.android.dx.rop.cst.CstType;
import com.android.dx.rop.type.StdTypeList;
import com.android.dx.rop.type.Type;
-import com.android.dx.util.ExceptionWithContext;
import com.android.dx.util.IntList;
/**
package com.android.dx.cf.code;
+import com.android.dx.rop.code.LocalItem;
import com.android.dx.rop.cst.CstString;
import com.android.dx.rop.type.Type;
-import com.android.dx.rop.code.LocalItem;
import com.android.dx.util.FixedSizeList;
/**
package com.android.dx.cf.code;
+import com.android.dex.util.ExceptionWithContext;
import com.android.dx.rop.code.RegisterSpec;
import com.android.dx.rop.type.Type;
import com.android.dx.rop.type.TypeBearer;
-import com.android.dx.util.ExceptionWithContext;
-import com.android.dx.util.Hex;
import com.android.dx.util.MutabilityControl;
import com.android.dx.util.ToHuman;
package com.android.dx.cf.code;
+import com.android.dex.util.ExceptionWithContext;
import com.android.dx.rop.code.RegisterSpec;
import com.android.dx.rop.type.Type;
import com.android.dx.rop.type.TypeBearer;
-import com.android.dx.util.ExceptionWithContext;
import com.android.dx.util.Hex;
-import com.android.dx.util.MutabilityControl;
-
import java.util.ArrayList;
/**
package com.android.dx.cf.code;
+import com.android.dx.rop.code.LocalItem;
import com.android.dx.rop.cst.Constant;
import com.android.dx.rop.type.Prototype;
import com.android.dx.rop.type.Type;
-import com.android.dx.rop.code.LocalItem;
import java.util.ArrayList;
/**
package com.android.dx.cf.code;
+import com.android.dex.util.ExceptionWithContext;
import com.android.dx.rop.code.RegisterSpec;
import com.android.dx.rop.type.Type;
import com.android.dx.rop.type.TypeBearer;
-import com.android.dx.util.ExceptionWithContext;
import com.android.dx.util.Hex;
-import com.android.dx.util.MutabilityControl;
/**
* Representation of an array of local variables, with Java semantics.
package com.android.dx.cf.code;
-import com.android.dx.rop.code.*;
+import com.android.dx.rop.code.AccessFlags;
+import com.android.dx.rop.code.BasicBlock;
+import com.android.dx.rop.code.BasicBlockList;
+import com.android.dx.rop.code.Insn;
+import com.android.dx.rop.code.InsnList;
+import com.android.dx.rop.code.PlainCstInsn;
+import com.android.dx.rop.code.PlainInsn;
+import com.android.dx.rop.code.RegisterSpec;
+import com.android.dx.rop.code.RegisterSpecList;
+import com.android.dx.rop.code.Rop;
+import com.android.dx.rop.code.RopMethod;
+import com.android.dx.rop.code.Rops;
+import com.android.dx.rop.code.SourcePosition;
+import com.android.dx.rop.code.ThrowingCstInsn;
+import com.android.dx.rop.code.ThrowingInsn;
+import com.android.dx.rop.code.TranslationAdvice;
import com.android.dx.rop.cst.CstInteger;
import com.android.dx.rop.cst.CstType;
import com.android.dx.rop.type.Prototype;
import com.android.dx.util.Bits;
import com.android.dx.util.Hex;
import com.android.dx.util.IntList;
-
import java.util.ArrayList;
import java.util.BitSet;
import java.util.HashMap;
import com.android.dx.rop.type.TypeBearer;
import com.android.dx.rop.type.TypeList;
import com.android.dx.util.IntList;
-
import java.util.ArrayList;
/**
package com.android.dx.cf.code;
-import com.android.dx.util.ExceptionWithContext;
+import com.android.dex.util.ExceptionWithContext;
/**
* Exception from simulation.
package com.android.dx.cf.code;
+import com.android.dx.rop.code.LocalItem;
import com.android.dx.rop.cst.Constant;
import com.android.dx.rop.cst.CstFieldRef;
import com.android.dx.rop.cst.CstInteger;
import com.android.dx.rop.cst.CstType;
import com.android.dx.rop.type.Prototype;
import com.android.dx.rop.type.Type;
-import com.android.dx.rop.code.LocalItem;
import com.android.dx.util.Hex;
-
import java.util.ArrayList;
/**
import com.android.dx.rop.type.Type;
import com.android.dx.util.ByteArray;
import com.android.dx.util.Hex;
-
import java.io.IOException;
/**
package com.android.dx.cf.direct;
-import com.android.dx.util.FileUtils;
-
+import com.android.dex.util.FileUtils;
+import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
-import java.io.ByteArrayOutputStream;
import java.io.InputStream;
-import java.util.zip.ZipFile;
-import java.util.zip.ZipEntry;
-import java.util.Arrays;
-import java.util.Comparator;
import java.util.ArrayList;
+import java.util.Arrays;
import java.util.Collections;
+import java.util.Comparator;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
/**
* Opens all the class files found in a class path element. Path elements
import com.android.dx.rop.type.Type;
import com.android.dx.util.ByteArray;
import com.android.dx.util.Hex;
-import com.android.dx.util.IntList;
-
-import java.util.List;
import java.util.ArrayList;
/**
import com.android.dx.cf.iface.StdAttributeList;
import com.android.dx.rop.code.AccessFlags;
import com.android.dx.rop.cst.ConstantPool;
-import com.android.dx.rop.cst.CstType;
import com.android.dx.rop.cst.CstString;
+import com.android.dx.rop.cst.CstType;
import com.android.dx.rop.cst.StdConstantPool;
import com.android.dx.rop.type.StdTypeList;
import com.android.dx.rop.type.Type;
import com.android.dx.rop.type.TypeList;
import com.android.dx.util.ByteArray;
import com.android.dx.util.Hex;
-
import java.io.IOException;
/**
package com.android.dx.cf.iface;
-import com.android.dx.util.ExceptionWithContext;
+import com.android.dex.util.ExceptionWithContext;
/**
* Exception from parsing.
package com.android.dx.command.annotool;
+import com.android.dx.cf.attrib.AttRuntimeInvisibleAnnotations;
+import com.android.dx.cf.attrib.AttRuntimeVisibleAnnotations;
+import com.android.dx.cf.attrib.BaseAnnotations;
import com.android.dx.cf.direct.ClassPathOpener;
import com.android.dx.cf.direct.DirectClassFile;
import com.android.dx.cf.direct.StdAttributeFactory;
-import com.android.dx.cf.iface.AttributeList;
import com.android.dx.cf.iface.Attribute;
-import com.android.dx.cf.attrib.AttRuntimeInvisibleAnnotations;
-import com.android.dx.cf.attrib.BaseAnnotations;
-import com.android.dx.cf.attrib.AttRuntimeVisibleAnnotations;
-import com.android.dx.util.ByteArray;
+import com.android.dx.cf.iface.AttributeList;
import com.android.dx.rop.annotation.Annotation;
-
+import com.android.dx.util.ByteArray;
import java.io.File;
import java.lang.annotation.ElementType;
import java.util.HashSet;
package com.android.dx.command.annotool;
-import com.android.dx.cf.direct.ClassPathOpener;
-import com.android.dx.cf.direct.DirectClassFile;
-import com.android.dx.cf.direct.StdAttributeFactory;
-import com.android.dx.cf.iface.AttributeList;
-import com.android.dx.cf.iface.Attribute;
-import com.android.dx.cf.attrib.AttRuntimeInvisibleAnnotations;
-import com.android.dx.cf.attrib.BaseAnnotations;
-import com.android.dx.cf.attrib.AttRuntimeVisibleAnnotations;
-import com.android.dx.util.ByteArray;
-import com.android.dx.rop.annotation.Annotation;
-
-import java.io.File;
import java.lang.annotation.ElementType;
import java.util.EnumSet;
-import java.util.Arrays;
public class Main {
package com.android.dx.command.dexer;
+import com.android.dex.Dex;
+import com.android.dex.DexFormat;
+import com.android.dex.util.FileUtils;
import com.android.dx.Version;
import com.android.dx.cf.code.SimException;
import com.android.dx.cf.direct.ClassPathOpener;
import com.android.dx.cf.iface.ParseException;
import com.android.dx.command.DxConsole;
import com.android.dx.command.UsageException;
-import com.android.dx.dex.DexFormat;
import com.android.dx.dex.DexOptions;
import com.android.dx.dex.cf.CfOptions;
import com.android.dx.dex.cf.CfTranslator;
import com.android.dx.dex.file.ClassDefItem;
import com.android.dx.dex.file.DexFile;
import com.android.dx.dex.file.EncodedMethod;
-import com.android.dx.io.DexBuffer;
import com.android.dx.merge.CollisionPolicy;
import com.android.dx.merge.DexMerger;
import com.android.dx.rop.annotation.Annotation;
import com.android.dx.rop.annotation.AnnotationsList;
import com.android.dx.rop.cst.CstNat;
import com.android.dx.rop.cst.CstString;
-import com.android.dx.util.FileUtils;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
* and the base dex do not exist.
*/
private static byte[] mergeIncremental(byte[] update, File base) throws IOException {
- DexBuffer dexA = null;
- DexBuffer dexB = null;
+ Dex dexA = null;
+ Dex dexB = null;
if (update != null) {
- dexA = new DexBuffer(update);
+ dexA = new Dex(update);
}
if (base.exists()) {
- dexB = new DexBuffer(base);
+ dexB = new Dex(base);
}
- DexBuffer result;
+ Dex result;
if (dexA == null && dexB == null) {
return null;
} else if (dexA == null) {
* same type, this fails with an exception.
*/
private static byte[] mergeLibraryDexBuffers(byte[] outArray) throws IOException {
- for (byte[] libraryDexBuffer : libraryDexBuffers) {
+ for (byte[] libraryDex : libraryDexBuffers) {
if (outArray == null) {
- outArray = libraryDexBuffer;
+ outArray = libraryDex;
continue;
}
- DexBuffer a = new DexBuffer(outArray);
- DexBuffer b = new DexBuffer(libraryDexBuffer);
- DexBuffer ab = new DexMerger(a, b, CollisionPolicy.FAIL).merge();
+ Dex a = new Dex(outArray);
+ Dex b = new Dex(libraryDex);
+ Dex ab = new DexMerger(a, b, CollisionPolicy.FAIL).merge();
outArray = ab.getBytes();
}
import com.android.dx.cf.code.ConcreteMethod;
import com.android.dx.cf.iface.Member;
import com.android.dx.cf.iface.ParseObserver;
-import com.android.dx.rop.code.AccessFlags;
import com.android.dx.util.ByteArray;
import com.android.dx.util.Hex;
import com.android.dx.util.IndentingWriter;
import com.android.dx.util.TwoColumnOutput;
-
import java.io.IOException;
import java.io.PrintStream;
import java.io.StringWriter;
package com.android.dx.command.dump;
-import com.android.dx.cf.attrib.AttCode;
import com.android.dx.cf.code.BasicBlocker;
import com.android.dx.cf.code.ByteBlock;
import com.android.dx.cf.code.ByteBlockList;
import com.android.dx.cf.direct.StdAttributeFactory;
import com.android.dx.cf.iface.Member;
import com.android.dx.cf.iface.Method;
+import com.android.dx.rop.code.AccessFlags;
import com.android.dx.rop.code.BasicBlock;
import com.android.dx.rop.code.BasicBlockList;
+import com.android.dx.rop.code.DexTranslationAdvice;
import com.android.dx.rop.code.Insn;
import com.android.dx.rop.code.InsnList;
import com.android.dx.rop.code.RopMethod;
-import com.android.dx.rop.code.DexTranslationAdvice;
import com.android.dx.rop.code.TranslationAdvice;
-import com.android.dx.rop.code.AccessFlags;
import com.android.dx.rop.cst.CstType;
import com.android.dx.ssa.Optimizer;
import com.android.dx.util.ByteArray;
import com.android.dx.util.Hex;
import com.android.dx.util.IntList;
-
import java.io.PrintStream;
/**
import com.android.dx.cf.direct.DirectClassFile;
import com.android.dx.cf.direct.StdAttributeFactory;
import com.android.dx.util.ByteArray;
-
import java.io.PrintStream;
/**
import com.android.dx.cf.iface.Member;
import com.android.dx.cf.iface.Method;
import com.android.dx.cf.iface.ParseObserver;
+import com.android.dx.rop.code.AccessFlags;
import com.android.dx.rop.code.BasicBlock;
import com.android.dx.rop.code.BasicBlockList;
-import com.android.dx.rop.code.RopMethod;
import com.android.dx.rop.code.DexTranslationAdvice;
+import com.android.dx.rop.code.RopMethod;
import com.android.dx.rop.code.TranslationAdvice;
-import com.android.dx.rop.code.AccessFlags;
import com.android.dx.ssa.Optimizer;
import com.android.dx.util.ByteArray;
import com.android.dx.util.Hex;
package com.android.dx.command.dump;
+import com.android.dex.util.FileUtils;
import com.android.dx.cf.iface.ParseException;
-import com.android.dx.util.FileUtils;
import com.android.dx.util.HexParser;
-
import java.io.UnsupportedEncodingException;
/**
import com.android.dx.cf.code.Ropper;
import com.android.dx.cf.iface.Member;
import com.android.dx.cf.iface.Method;
+import com.android.dx.rop.code.AccessFlags;
+import com.android.dx.rop.code.DexTranslationAdvice;
import com.android.dx.rop.code.RopMethod;
import com.android.dx.rop.code.TranslationAdvice;
-import com.android.dx.rop.code.DexTranslationAdvice;
-import com.android.dx.rop.code.AccessFlags;
-import com.android.dx.ssa.DeadCodeRemover;
-import com.android.dx.ssa.PhiTypeResolver;
+import com.android.dx.ssa.Optimizer;
import com.android.dx.ssa.SsaBasicBlock;
-import com.android.dx.ssa.SsaConverter;
import com.android.dx.ssa.SsaInsn;
import com.android.dx.ssa.SsaMethod;
-import com.android.dx.ssa.Optimizer;
-import com.android.dx.ssa.ConstCollector;
-import com.android.dx.ssa.SCCP;
-import com.android.dx.ssa.LiteralOpUpgrader;
-import com.android.dx.ssa.back.SsaToRop;
import com.android.dx.util.ByteArray;
import com.android.dx.util.Hex;
import com.android.dx.util.IntList;
-
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.BitSet;
package com.android.dx.command.findusages;
-import com.android.dx.io.ClassData;
-import com.android.dx.io.ClassDef;
+import com.android.dex.ClassData;
+import com.android.dex.ClassDef;
+import com.android.dex.Dex;
+import com.android.dex.FieldId;
+import com.android.dex.MethodId;
import com.android.dx.io.CodeReader;
-import com.android.dx.io.DexBuffer;
-import com.android.dx.io.FieldId;
-import com.android.dx.io.MethodId;
import com.android.dx.io.OpcodeInfo;
import com.android.dx.io.instructions.DecodedInstruction;
-import java.io.PrintStream;
import java.io.PrintWriter;
import java.util.Collections;
import java.util.HashSet;
import java.util.regex.Pattern;
public final class FindUsages {
- private final DexBuffer dex;
+ private final Dex dex;
private final Set<Integer> methodIds;
private final Set<Integer> fieldIds;
private final CodeReader codeReader = new CodeReader();
private ClassDef currentClass;
private ClassData.Method currentMethod;
- public FindUsages(final DexBuffer dex, String declaredBy, String memberName, final PrintWriter out) {
+ public FindUsages(final Dex dex, String declaredBy, String memberName, final PrintWriter out) {
this.dex = dex;
this.out = out;
* Returns the fields with {@code memberNameIndex} declared by {@code
* declaringType}.
*/
- private Set<Integer> getFieldIds(DexBuffer dex, Set<Integer> memberNameIndexes, int declaringType) {
+ private Set<Integer> getFieldIds(Dex dex, Set<Integer> memberNameIndexes, int declaringType) {
Set<Integer> fields = new HashSet<Integer>();
int fieldIndex = 0;
for (FieldId fieldId : dex.fieldIds()) {
* Returns the methods with {@code memberNameIndex} declared by {@code
* declaringType} and its subtypes.
*/
- private Set<Integer> getMethodIds(DexBuffer dex, Set<Integer> memberNameIndexes, int declaringType) {
+ private Set<Integer> getMethodIds(Dex dex, Set<Integer> memberNameIndexes, int declaringType) {
Set<Integer> subtypes = findAssignableTypes(dex, declaringType);
Set<Integer> methods = new HashSet<Integer>();
/**
* Returns the set of types that can be assigned to {@code typeIndex}.
*/
- private Set<Integer> findAssignableTypes(DexBuffer dex, int typeIndex) {
+ private Set<Integer> findAssignableTypes(Dex dex, int typeIndex) {
Set<Integer> assignableTypes = new HashSet<Integer>();
assignableTypes.add(typeIndex);
package com.android.dx.command.findusages;
-import com.android.dx.io.DexBuffer;
+import com.android.dex.Dex;
import java.io.File;
import java.io.IOException;
import java.io.PrintWriter;
String declaredBy = args[1];
String memberName = args[2];
- DexBuffer dex = new DexBuffer(new File(dexFile));
+ Dex dex = new Dex(new File(dexFile));
PrintWriter out = new PrintWriter(System.out);
new FindUsages(dex, declaredBy, memberName, out).findUsages();
out.flush();
package com.android.dx.command.grep;
-import com.android.dx.io.ClassData;
-import com.android.dx.io.ClassDef;
+import com.android.dex.ClassData;
+import com.android.dex.ClassDef;
+import com.android.dex.Dex;
+import com.android.dex.EncodedValueReader;
+import com.android.dex.MethodId;
import com.android.dx.io.CodeReader;
-import com.android.dx.io.DexBuffer;
-import com.android.dx.io.EncodedValueReader;
-import com.android.dx.io.MethodId;
import com.android.dx.io.instructions.DecodedInstruction;
import java.io.PrintWriter;
import java.util.HashSet;
import java.util.regex.Pattern;
public final class Grep {
- private final DexBuffer dex;
+ private final Dex dex;
private final CodeReader codeReader = new CodeReader();
private final Set<Integer> stringIds;
private ClassDef currentClass;
private ClassData.Method currentMethod;
- public Grep(final DexBuffer dex, Pattern pattern, final PrintWriter out) {
+ public Grep(final Dex dex, Pattern pattern, final PrintWriter out) {
this.dex = dex;
this.out = out;
return count;
}
- private Set<Integer> getStringIds(DexBuffer dex, Pattern pattern) {
+ private Set<Integer> getStringIds(Dex dex, Pattern pattern) {
Set<Integer> stringIds = new HashSet<Integer>();
int stringIndex = 0;
for (String s : dex.strings()) {
package com.android.dx.command.grep;
-import com.android.dx.io.DexBuffer;
+import com.android.dex.Dex;
import java.io.File;
import java.io.IOException;
import java.io.PrintWriter;
String dexFile = args[0];
String pattern = args[1];
- DexBuffer dex = new DexBuffer(new File(dexFile));
+ Dex dex = new Dex(new File(dexFile));
int count = new Grep(dex, Pattern.compile(pattern), new PrintWriter(System.out)).grep();
System.exit((count > 0) ? 0 : 1);
}
package com.android.dx.dex;
+import com.android.dex.DexFormat;
+
/**
* Container for options used to control details of dex file generation.
*/
import com.android.dx.rop.type.Type;
import com.android.dx.rop.type.TypeList;
import com.android.dx.util.Warning;
-
import java.util.ArrayList;
/**
package com.android.dx.dex.cf;
import com.android.dx.dex.code.PositionList;
-
import java.io.PrintStream;
/**
package com.android.dx.dex.cf;
+import com.android.dex.util.ExceptionWithContext;
import com.android.dx.cf.code.ConcreteMethod;
import com.android.dx.cf.code.Ropper;
import com.android.dx.cf.direct.DirectClassFile;
import com.android.dx.rop.annotation.Annotations;
import com.android.dx.rop.annotation.AnnotationsList;
import com.android.dx.rop.code.AccessFlags;
+import com.android.dx.rop.code.DexTranslationAdvice;
import com.android.dx.rop.code.LocalVariableExtractor;
import com.android.dx.rop.code.LocalVariableInfo;
import com.android.dx.rop.code.RopMethod;
-import com.android.dx.rop.code.DexTranslationAdvice;
import com.android.dx.rop.code.TranslationAdvice;
import com.android.dx.rop.cst.Constant;
import com.android.dx.rop.cst.CstBoolean;
import com.android.dx.rop.type.Type;
import com.android.dx.rop.type.TypeList;
import com.android.dx.ssa.Optimizer;
-import com.android.dx.util.ExceptionWithContext;
/**
* Static method that turns {@code byte[]}s containing Java
import com.android.dx.dex.code.DalvCode;
import com.android.dx.rop.code.RopMethod;
-
import java.io.PrintStream;
/**
import com.android.dx.rop.code.RopMethod;
import com.android.dx.rop.code.TranslationAdvice;
import com.android.dx.ssa.Optimizer;
-
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import com.android.dx.io.Opcodes;
import com.android.dx.rop.code.RegisterSpecList;
import com.android.dx.rop.code.SourcePosition;
-import com.android.dx.rop.cst.*;
+import com.android.dx.rop.cst.Constant;
+import com.android.dx.rop.cst.CstLiteral32;
+import com.android.dx.rop.cst.CstLiteral64;
+import com.android.dx.rop.cst.CstType;
import com.android.dx.util.AnnotatedOutput;
import com.android.dx.util.Hex;
-import com.android.dx.rop.type.Type;
import java.util.ArrayList;
/**
package com.android.dx.dex.code;
import com.android.dx.rop.type.Type;
-
import java.util.HashSet;
/**
package com.android.dx.dex.code;
-import com.android.dx.rop.cst.CstType;
import com.android.dx.util.FixedSizeList;
/**
import com.android.dx.rop.cst.Constant;
import com.android.dx.rop.type.Type;
-
import java.util.HashSet;
/**
import com.android.dx.util.AnnotatedOutput;
import com.android.dx.util.Hex;
import com.android.dx.util.TwoColumnOutput;
-
import java.util.BitSet;
/**
package com.android.dx.dex.code;
+import com.android.dex.util.ExceptionWithContext;
import com.android.dx.io.Opcodes;
import com.android.dx.rop.cst.Constant;
import com.android.dx.rop.cst.CstBaseMethodRef;
import com.android.dx.util.AnnotatedOutput;
-import com.android.dx.util.ExceptionWithContext;
import com.android.dx.util.FixedSizeList;
import com.android.dx.util.IndentingWriter;
-
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import com.android.dx.rop.code.RegisterSpec;
import com.android.dx.rop.code.RegisterSpecList;
import com.android.dx.rop.code.SourcePosition;
-import com.android.dx.rop.type.Type;
import com.android.dx.util.AnnotatedOutput;
/**
import com.android.dx.rop.cst.CstString;
import com.android.dx.util.AnnotatedOutput;
import com.android.dx.util.Hex;
-
import java.util.BitSet;
/**
import com.android.dx.rop.code.RegisterSpec;
import com.android.dx.rop.code.RegisterSpecSet;
-import com.android.dx.rop.cst.CstType;
import com.android.dx.rop.cst.CstString;
+import com.android.dx.rop.cst.CstType;
import com.android.dx.rop.type.Type;
import com.android.dx.util.FixedSizeList;
-
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.Arrays;
package com.android.dx.dex.code;
import com.android.dx.dex.DexOptions;
-
import java.util.ArrayList;
/**
import com.android.dx.rop.code.SourcePosition;
import com.android.dx.rop.cst.Constant;
import com.android.dx.rop.cst.CstMemberRef;
-import com.android.dx.rop.cst.CstType;
import com.android.dx.rop.cst.CstString;
+import com.android.dx.rop.cst.CstType;
import com.android.dx.rop.type.Type;
-import com.android.dx.util.DexException;
+import com.android.dex.DexException;
import java.util.ArrayList;
import java.util.BitSet;
import java.util.HashSet;
import com.android.dx.rop.code.Insn;
import com.android.dx.rop.code.RegOps;
+import com.android.dx.rop.code.RegisterSpec;
import com.android.dx.rop.code.Rop;
import com.android.dx.rop.code.Rops;
import com.android.dx.rop.code.ThrowingCstInsn;
-import com.android.dx.rop.code.RegisterSpec;
import com.android.dx.rop.cst.Constant;
import com.android.dx.rop.cst.CstFieldRef;
-import com.android.dx.rop.cst.CstType;
import com.android.dx.rop.cst.CstString;
+import com.android.dx.rop.cst.CstType;
import com.android.dx.rop.type.Type;
-
import java.util.HashMap;
/**
import com.android.dx.rop.cst.CstInteger;
import com.android.dx.util.Bits;
import com.android.dx.util.IntList;
-
import java.util.ArrayList;
/**
import com.android.dx.rop.type.Type;
import com.android.dx.rop.type.TypeList;
import com.android.dx.util.IntList;
-
import java.util.ArrayList;
import java.util.HashSet;
import com.android.dx.rop.cst.Constant;
import com.android.dx.rop.cst.CstLiteralBits;
import com.android.dx.util.AnnotatedOutput;
-
import java.util.BitSet;
/**
import com.android.dx.dex.code.SimpleInsn;
import com.android.dx.rop.code.RegisterSpecList;
import com.android.dx.util.AnnotatedOutput;
-
import java.util.BitSet;
/**
import com.android.dx.rop.code.RegisterSpec;
import com.android.dx.rop.code.RegisterSpecList;
import com.android.dx.util.AnnotatedOutput;
-
import java.util.BitSet;
/**
import com.android.dx.rop.cst.CstString;
import com.android.dx.rop.cst.CstType;
import com.android.dx.util.AnnotatedOutput;
-
import java.util.BitSet;
/**
import com.android.dx.rop.cst.Constant;
import com.android.dx.rop.cst.CstLiteralBits;
import com.android.dx.util.AnnotatedOutput;
-
import java.util.BitSet;
/**
import com.android.dx.rop.cst.Constant;
import com.android.dx.rop.cst.CstLiteralBits;
import com.android.dx.util.AnnotatedOutput;
-
import java.util.BitSet;
/**
import com.android.dx.dex.code.TargetInsn;
import com.android.dx.rop.code.RegisterSpecList;
import com.android.dx.util.AnnotatedOutput;
-
import java.util.BitSet;
/**
import com.android.dx.rop.cst.Constant;
import com.android.dx.rop.cst.CstLiteralBits;
import com.android.dx.util.AnnotatedOutput;
-
import java.util.BitSet;
/**
import com.android.dx.rop.cst.CstFieldRef;
import com.android.dx.rop.cst.CstType;
import com.android.dx.util.AnnotatedOutput;
-
import java.util.BitSet;
/**
import com.android.dx.rop.cst.Constant;
import com.android.dx.rop.cst.CstLiteralBits;
import com.android.dx.util.AnnotatedOutput;
-
import java.util.BitSet;
/**
import com.android.dx.dex.code.TargetInsn;
import com.android.dx.rop.code.RegisterSpecList;
import com.android.dx.util.AnnotatedOutput;
-
import java.util.BitSet;
/**
import com.android.dx.dex.code.SimpleInsn;
import com.android.dx.rop.code.RegisterSpecList;
import com.android.dx.util.AnnotatedOutput;
-
import java.util.BitSet;
/**
import com.android.dx.dex.code.SimpleInsn;
import com.android.dx.rop.code.RegisterSpecList;
import com.android.dx.util.AnnotatedOutput;
-
import java.util.BitSet;
/**
import com.android.dx.rop.cst.CstString;
import com.android.dx.rop.cst.CstType;
import com.android.dx.util.AnnotatedOutput;
-
import java.util.BitSet;
/**
import com.android.dx.rop.cst.Constant;
import com.android.dx.rop.cst.CstLiteralBits;
import com.android.dx.util.AnnotatedOutput;
-
import java.util.BitSet;
/**
import com.android.dx.dex.code.TargetInsn;
import com.android.dx.rop.code.RegisterSpecList;
import com.android.dx.util.AnnotatedOutput;
-
import java.util.BitSet;
/**
import com.android.dx.dex.code.SimpleInsn;
import com.android.dx.rop.code.RegisterSpecList;
import com.android.dx.util.AnnotatedOutput;
-
import java.util.BitSet;
/**
import com.android.dx.rop.cst.CstType;
import com.android.dx.rop.type.Type;
import com.android.dx.util.AnnotatedOutput;
-
import java.util.BitSet;
/**
import com.android.dx.rop.cst.CstLiteral64;
import com.android.dx.rop.cst.CstLiteralBits;
import com.android.dx.util.AnnotatedOutput;
-
import java.util.BitSet;
/**
import com.android.dx.rop.annotation.NameValuePair;
import com.android.dx.rop.cst.Constant;
import com.android.dx.rop.cst.CstString;
-import com.android.dx.util.ByteArrayAnnotatedOutput;
import com.android.dx.util.AnnotatedOutput;
-
+import com.android.dx.util.ByteArrayAnnotatedOutput;
import java.util.Arrays;
import java.util.Comparator;
package com.android.dx.dex.file;
-import com.android.dx.rop.annotation.Annotations;
import com.android.dx.rop.annotation.Annotation;
+import com.android.dx.rop.annotation.Annotations;
import com.android.dx.util.AnnotatedOutput;
import com.android.dx.util.Hex;
package com.android.dx.dex.file;
import com.android.dx.rop.annotation.Annotation;
+import static com.android.dx.rop.annotation.AnnotationVisibility.SYSTEM;
import com.android.dx.rop.annotation.NameValuePair;
import com.android.dx.rop.cst.Constant;
import com.android.dx.rop.cst.CstAnnotation;
import com.android.dx.rop.cst.CstType;
import com.android.dx.rop.type.Type;
import com.android.dx.rop.type.TypeList;
-
import java.util.ArrayList;
-import static com.android.dx.rop.annotation.AnnotationVisibility.*;
-
/**
* Utility class for dealing with annotations.
*/
import com.android.dx.rop.cst.CstMethodRef;
import com.android.dx.util.AnnotatedOutput;
import com.android.dx.util.Hex;
-
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collections;
import com.android.dx.util.AnnotatedOutput;
import com.android.dx.util.ByteArrayAnnotatedOutput;
import com.android.dx.util.Hex;
-
import java.io.PrintWriter;
import java.util.Map;
import java.util.TreeMap;
import com.android.dx.rop.cst.CstLiteralBits;
import com.android.dx.rop.cst.CstType;
import com.android.dx.rop.cst.Zeroes;
-import com.android.dx.util.ByteArrayAnnotatedOutput;
import com.android.dx.util.AnnotatedOutput;
+import com.android.dx.util.ByteArrayAnnotatedOutput;
import com.android.dx.util.Writers;
-
import java.io.PrintWriter;
import java.io.Writer;
import java.util.ArrayList;
package com.android.dx.dex.file;
-import com.android.dx.dex.SizeOf;
+import com.android.dex.SizeOf;
import com.android.dx.rop.annotation.Annotations;
import com.android.dx.rop.annotation.AnnotationsList;
import com.android.dx.rop.code.AccessFlags;
import com.android.dx.util.AnnotatedOutput;
import com.android.dx.util.Hex;
import com.android.dx.util.Writers;
-
import java.io.PrintWriter;
import java.io.Writer;
import java.util.ArrayList;
import com.android.dx.rop.type.TypeList;
import com.android.dx.util.AnnotatedOutput;
import com.android.dx.util.Hex;
-
import java.util.ArrayList;
import java.util.Collection;
import java.util.TreeMap;
package com.android.dx.dex.file;
-import com.android.dx.dex.code.CstInsn;
-import com.android.dx.dex.code.CatchTable;
+import com.android.dex.util.ExceptionWithContext;
import com.android.dx.dex.code.DalvCode;
-import com.android.dx.dex.code.DalvInsn;
import com.android.dx.dex.code.DalvInsnList;
-import com.android.dx.dex.code.LocalList;
-import com.android.dx.dex.code.PositionList;
import com.android.dx.rop.cst.Constant;
-import com.android.dx.rop.cst.CstMemberRef;
import com.android.dx.rop.cst.CstMethodRef;
-import com.android.dx.rop.cst.CstType;
import com.android.dx.rop.type.StdTypeList;
import com.android.dx.rop.type.Type;
import com.android.dx.rop.type.TypeList;
import com.android.dx.util.AnnotatedOutput;
-import com.android.dx.util.ExceptionWithContext;
import com.android.dx.util.Hex;
-
import java.io.PrintWriter;
-import java.util.HashSet;
/**
* Representation of all the parts needed for concrete methods in a
package com.android.dx.dex.file;
+import com.android.dex.util.ByteArrayByteInput;
+import com.android.dex.util.ByteInput;
+import com.android.dex.util.ExceptionWithContext;
+import com.android.dex.Leb128;
import com.android.dx.dex.code.DalvCode;
import com.android.dx.dex.code.DalvInsnList;
import com.android.dx.dex.code.LocalList;
import com.android.dx.dex.code.PositionList;
+import static com.android.dx.dex.file.DebugInfoConstants.DBG_ADVANCE_LINE;
+import static com.android.dx.dex.file.DebugInfoConstants.DBG_ADVANCE_PC;
+import static com.android.dx.dex.file.DebugInfoConstants.DBG_END_LOCAL;
+import static com.android.dx.dex.file.DebugInfoConstants.DBG_END_SEQUENCE;
+import static com.android.dx.dex.file.DebugInfoConstants.DBG_FIRST_SPECIAL;
+import static com.android.dx.dex.file.DebugInfoConstants.DBG_LINE_BASE;
+import static com.android.dx.dex.file.DebugInfoConstants.DBG_LINE_RANGE;
+import static com.android.dx.dex.file.DebugInfoConstants.DBG_RESTART_LOCAL;
+import static com.android.dx.dex.file.DebugInfoConstants.DBG_SET_EPILOGUE_BEGIN;
+import static com.android.dx.dex.file.DebugInfoConstants.DBG_SET_FILE;
+import static com.android.dx.dex.file.DebugInfoConstants.DBG_SET_PROLOGUE_END;
+import static com.android.dx.dex.file.DebugInfoConstants.DBG_START_LOCAL;
+import static com.android.dx.dex.file.DebugInfoConstants.DBG_START_LOCAL_EXTENDED;
import com.android.dx.rop.cst.CstMethodRef;
import com.android.dx.rop.cst.CstString;
import com.android.dx.rop.type.Prototype;
import com.android.dx.rop.type.StdTypeList;
import com.android.dx.rop.type.Type;
-import com.android.dx.util.ByteArrayByteInput;
-import com.android.dx.util.ByteInput;
-import com.android.dx.util.ExceptionWithContext;
-
-import com.android.dx.util.Leb128Utils;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
-import static com.android.dx.dex.file.DebugInfoConstants.*;
-
/**
* A decoder for the dex debug info state machine format.
* This code exists mostly as a reference implementation and test for
* @throws IOException
*/
private int readStringIndex(ByteInput bs) throws IOException {
- int offsetIndex = Leb128Utils.readUnsignedLeb128(bs);
+ int offsetIndex = Leb128.readUnsignedLeb128(bs);
return offsetIndex - 1;
}
private void decode0() throws IOException {
ByteInput bs = new ByteArrayByteInput(encoded);
- line = Leb128Utils.readUnsignedLeb128(bs);
- int szParams = Leb128Utils.readUnsignedLeb128(bs);
+ line = Leb128.readUnsignedLeb128(bs);
+ int szParams = Leb128.readUnsignedLeb128(bs);
StdTypeList params = desc.getParameterTypes();
int curReg = getParamBase();
switch (opcode) {
case DBG_START_LOCAL: {
- int reg = Leb128Utils.readUnsignedLeb128(bs);
+ int reg = Leb128.readUnsignedLeb128(bs);
int nameIdx = readStringIndex(bs);
int typeIdx = readStringIndex(bs);
LocalEntry le = new LocalEntry(
break;
case DBG_START_LOCAL_EXTENDED: {
- int reg = Leb128Utils.readUnsignedLeb128(bs);
+ int reg = Leb128.readUnsignedLeb128(bs);
int nameIdx = readStringIndex(bs);
int typeIdx = readStringIndex(bs);
int sigIdx = readStringIndex(bs);
break;
case DBG_RESTART_LOCAL: {
- int reg = Leb128Utils.readUnsignedLeb128(bs);
+ int reg = Leb128.readUnsignedLeb128(bs);
LocalEntry prevle;
LocalEntry le;
break;
case DBG_END_LOCAL: {
- int reg = Leb128Utils.readUnsignedLeb128(bs);
+ int reg = Leb128.readUnsignedLeb128(bs);
LocalEntry prevle;
LocalEntry le;
return;
case DBG_ADVANCE_PC:
- address += Leb128Utils.readUnsignedLeb128(bs);
+ address += Leb128.readUnsignedLeb128(bs);
break;
case DBG_ADVANCE_LINE:
- line += Leb128Utils.readSignedLeb128(bs);
+ line += Leb128.readSignedLeb128(bs);
break;
case DBG_SET_PROLOGUE_END:
package com.android.dx.dex.file;
+import com.android.dex.util.ExceptionWithContext;
import com.android.dx.dex.code.LocalList;
import com.android.dx.dex.code.PositionList;
+import static com.android.dx.dex.file.DebugInfoConstants.DBG_ADVANCE_LINE;
+import static com.android.dx.dex.file.DebugInfoConstants.DBG_ADVANCE_PC;
+import static com.android.dx.dex.file.DebugInfoConstants.DBG_END_LOCAL;
+import static com.android.dx.dex.file.DebugInfoConstants.DBG_END_SEQUENCE;
+import static com.android.dx.dex.file.DebugInfoConstants.DBG_FIRST_SPECIAL;
+import static com.android.dx.dex.file.DebugInfoConstants.DBG_LINE_BASE;
+import static com.android.dx.dex.file.DebugInfoConstants.DBG_LINE_RANGE;
+import static com.android.dx.dex.file.DebugInfoConstants.DBG_RESTART_LOCAL;
+import static com.android.dx.dex.file.DebugInfoConstants.DBG_SET_PROLOGUE_END;
+import static com.android.dx.dex.file.DebugInfoConstants.DBG_START_LOCAL;
+import static com.android.dx.dex.file.DebugInfoConstants.DBG_START_LOCAL_EXTENDED;
import com.android.dx.rop.code.RegisterSpec;
import com.android.dx.rop.code.SourcePosition;
import com.android.dx.rop.cst.CstMethodRef;
-import com.android.dx.rop.cst.CstType;
import com.android.dx.rop.cst.CstString;
+import com.android.dx.rop.cst.CstType;
import com.android.dx.rop.type.Prototype;
import com.android.dx.rop.type.StdTypeList;
import com.android.dx.rop.type.Type;
-import com.android.dx.util.ByteArrayAnnotatedOutput;
import com.android.dx.util.AnnotatedOutput;
-import com.android.dx.util.ExceptionWithContext;
-
+import com.android.dx.util.ByteArrayAnnotatedOutput;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
+import java.util.BitSet;
import java.util.Collections;
import java.util.Comparator;
-import java.util.BitSet;
-
-import static com.android.dx.dex.file.DebugInfoConstants.*;
/**
* An encoder for the dex debug info state machine format. The format
package com.android.dx.dex.file;
+import com.android.dex.util.ExceptionWithContext;
import com.android.dx.dex.code.DalvCode;
import com.android.dx.dex.code.DalvInsnList;
import com.android.dx.dex.code.LocalList;
import com.android.dx.dex.code.PositionList;
import com.android.dx.rop.cst.CstMethodRef;
import com.android.dx.util.AnnotatedOutput;
-import com.android.dx.util.ExceptionWithContext;
-
import java.io.PrintWriter;
public class DebugInfoItem extends OffsettedItem {
package com.android.dx.dex.file;
-import com.android.dx.dex.DexFormat;
+import com.android.dex.util.ExceptionWithContext;
import com.android.dx.dex.DexOptions;
+import static com.android.dx.dex.file.MixedItemSection.SortType;
import com.android.dx.rop.cst.Constant;
import com.android.dx.rop.cst.CstBaseMethodRef;
import com.android.dx.rop.cst.CstEnumRef;
import com.android.dx.rop.cst.CstType;
import com.android.dx.rop.type.Type;
import com.android.dx.util.ByteArrayAnnotatedOutput;
-import com.android.dx.util.ExceptionWithContext;
-
import java.io.IOException;
import java.io.OutputStream;
import java.io.Writer;
import java.security.NoSuchAlgorithmException;
import java.util.zip.Adler32;
-import static com.android.dx.dex.file.MixedItemSection.SortType;
-
/**
* Representation of an entire {@code .dex} (Dalvik EXecutable)
* file, which itself consists of a set of Dalvik classes.
package com.android.dx.dex.file;
import com.android.dx.rop.cst.CstArray;
-import com.android.dx.util.ByteArrayAnnotatedOutput;
import com.android.dx.util.AnnotatedOutput;
+import com.android.dx.util.ByteArrayAnnotatedOutput;
/**
* Encoded array of constant values.
package com.android.dx.dex.file;
+import com.android.dex.Leb128;
import com.android.dx.rop.code.AccessFlags;
import com.android.dx.rop.cst.CstFieldRef;
import com.android.dx.rop.cst.CstString;
import com.android.dx.util.AnnotatedOutput;
import com.android.dx.util.Hex;
-import com.android.dx.util.Leb128Utils;
-
import java.io.PrintWriter;
/**
if (out.annotates()) {
out.annotate(0, String.format(" [%x] %s", dumpSeq,
field.toHuman()));
- out.annotate(Leb128Utils.unsignedLeb128Size(diff),
+ out.annotate(Leb128.unsignedLeb128Size(diff),
" field_idx: " + Hex.u4(fieldIdx));
- out.annotate(Leb128Utils.unsignedLeb128Size(accessFlags),
+ out.annotate(Leb128.unsignedLeb128Size(accessFlags),
" access_flags: " +
AccessFlags.fieldString(accessFlags));
}
import com.android.dx.rop.cst.CstString;
import com.android.dx.util.AnnotatedOutput;
import com.android.dx.util.ToHuman;
-
import java.io.PrintWriter;
/**
package com.android.dx.dex.file;
+import com.android.dex.Leb128;
import com.android.dx.dex.code.DalvCode;
import com.android.dx.rop.code.AccessFlags;
import com.android.dx.rop.cst.CstMethodRef;
import com.android.dx.rop.type.TypeList;
import com.android.dx.util.AnnotatedOutput;
import com.android.dx.util.Hex;
-import com.android.dx.util.Leb128Utils;
-
import java.io.PrintWriter;
/**
if (out.annotates()) {
out.annotate(0, String.format(" [%x] %s", dumpSeq,
method.toHuman()));
- out.annotate(Leb128Utils.unsignedLeb128Size(diff),
+ out.annotate(Leb128.unsignedLeb128Size(diff),
" method_idx: " + Hex.u4(methodIdx));
- out.annotate(Leb128Utils.unsignedLeb128Size(accessFlags),
+ out.annotate(Leb128.unsignedLeb128Size(accessFlags),
" access_flags: " +
AccessFlags.methodString(accessFlags));
- out.annotate(Leb128Utils.unsignedLeb128Size(codeOff),
+ out.annotate(Leb128.unsignedLeb128Size(codeOff),
" code_off: " + Hex.u4(codeOff));
}
import com.android.dx.rop.cst.CstFieldRef;
import com.android.dx.util.AnnotatedOutput;
import com.android.dx.util.Hex;
-
import java.util.Collection;
import java.util.TreeMap;
package com.android.dx.dex.file;
-import com.android.dx.dex.DexFormat;
-import com.android.dx.dex.SizeOf;
+import com.android.dex.DexFormat;
+import com.android.dex.SizeOf;
import com.android.dx.rop.cst.CstString;
import com.android.dx.util.AnnotatedOutput;
import com.android.dx.util.Hex;
package com.android.dx.dex.file;
import com.android.dx.rop.cst.Constant;
-
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import com.android.dx.util.AnnotatedOutput;
import com.android.dx.util.Hex;
-
import java.util.ArrayList;
/**
package com.android.dx.dex.file;
+import com.android.dex.SizeOf;
import com.android.dx.rop.cst.CstMemberRef;
import com.android.dx.rop.cst.CstNat;
import com.android.dx.util.AnnotatedOutput;
import com.android.dx.util.Hex;
-import com.android.dx.dex.SizeOf;
/**
* Representation of a member (field or method) reference inside a
package com.android.dx.dex.file;
-import com.android.dx.util.DexException;
+import com.android.dex.DexException;
import java.util.Formatter;
import java.util.Map;
import java.util.TreeMap;
import com.android.dx.rop.cst.CstBaseMethodRef;
import com.android.dx.util.AnnotatedOutput;
import com.android.dx.util.Hex;
-
import java.util.Collection;
import java.util.TreeMap;
package com.android.dx.dex.file;
+import com.android.dex.util.ExceptionWithContext;
import com.android.dx.util.AnnotatedOutput;
-import com.android.dx.util.ExceptionWithContext;
import com.android.dx.util.Hex;
-
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
package com.android.dx.dex.file;
+import com.android.dex.util.ExceptionWithContext;
import com.android.dx.util.AnnotatedOutput;
-import com.android.dx.util.ExceptionWithContext;
/**
* An item in a Dalvik file which is referenced by absolute offset.
import com.android.dx.util.AnnotatedOutput;
import com.android.dx.util.Hex;
import com.android.dx.util.ToHuman;
-
import java.util.ArrayList;
/**
package com.android.dx.dex.file;
-import com.android.dx.dex.SizeOf;
+import com.android.dex.SizeOf;
import com.android.dx.rop.cst.CstString;
import com.android.dx.rop.type.Prototype;
import com.android.dx.rop.type.StdTypeList;
import com.android.dx.rop.type.Prototype;
import com.android.dx.util.AnnotatedOutput;
import com.android.dx.util.Hex;
-
import java.util.Collection;
import java.util.TreeMap;
package com.android.dx.dex.file;
import com.android.dx.util.AnnotatedOutput;
-
import java.util.Collection;
/**
package com.android.dx.dex.file;
import com.android.dx.util.AnnotatedOutput;
-
import java.util.Collection;
import java.util.HashMap;
import java.util.TreeMap;
package com.android.dx.dex.file;
+import com.android.dex.Leb128;
import com.android.dx.rop.cst.CstString;
import com.android.dx.util.AnnotatedOutput;
import com.android.dx.util.ByteArray;
import com.android.dx.util.Hex;
-import com.android.dx.util.Leb128Utils;
/**
* Representation of string data for a particular string, in a Dalvik file.
int utf16Size = value.getUtf16Size();
// The +1 is for the '\0' termination byte.
- return Leb128Utils.unsignedLeb128Size(utf16Size)
+ return Leb128.unsignedLeb128Size(utf16Size)
+ value.getUtf8Size() + 1;
}
int utf16Size = value.getUtf16Size();
if (out.annotates()) {
- out.annotate(Leb128Utils.unsignedLeb128Size(utf16Size),
+ out.annotate(Leb128.unsignedLeb128Size(utf16Size),
"utf16_size: " + Hex.u4(utf16Size));
out.annotate(bytes.size() + 1, value.toQuoted());
}
package com.android.dx.dex.file;
-import com.android.dx.dex.SizeOf;
+import com.android.dex.SizeOf;
import com.android.dx.rop.cst.CstString;
import com.android.dx.util.AnnotatedOutput;
import com.android.dx.util.Hex;
import com.android.dx.rop.cst.CstString;
import com.android.dx.util.AnnotatedOutput;
import com.android.dx.util.Hex;
-
import java.util.Collection;
import java.util.TreeMap;
package com.android.dx.dex.file;
-import com.android.dx.dex.SizeOf;
-import com.android.dx.rop.cst.CstType;
+import com.android.dex.SizeOf;
import com.android.dx.rop.cst.CstString;
+import com.android.dx.rop.cst.CstType;
import com.android.dx.util.AnnotatedOutput;
import com.android.dx.util.Hex;
import com.android.dx.rop.type.Type;
import com.android.dx.util.AnnotatedOutput;
import com.android.dx.util.Hex;
-
import java.util.Collection;
import java.util.TreeMap;
package com.android.dx.dex.file;
-import com.android.dx.rop.cst.CstType;
import com.android.dx.rop.type.StdTypeList;
import com.android.dx.rop.type.Type;
import com.android.dx.rop.type.TypeList;
import com.android.dx.rop.cst.Constant;
import com.android.dx.util.AnnotatedOutput;
-
import java.util.Collection;
/**
import com.android.dx.util.AnnotatedOutput;
import com.android.dx.util.Hex;
-
-import java.util.HashMap;
import java.util.List;
/**
package com.android.dx.dex.file;
+import com.android.dex.EncodedValueCodec;
import com.android.dx.rop.annotation.Annotation;
import com.android.dx.rop.annotation.NameValuePair;
import com.android.dx.rop.cst.Constant;
import com.android.dx.rop.cst.CstString;
import com.android.dx.rop.cst.CstType;
import com.android.dx.util.AnnotatedOutput;
-import com.android.dx.util.EncodedValueUtils;
import com.android.dx.util.Hex;
import java.util.Collection;
case VALUE_INT:
case VALUE_LONG: {
long value = ((CstLiteralBits) cst).getLongBits();
- EncodedValueUtils.writeSignedIntegralValue(out, type, value);
+ EncodedValueCodec.writeSignedIntegralValue(out, type, value);
break;
}
case VALUE_CHAR: {
long value = ((CstLiteralBits) cst).getLongBits();
- EncodedValueUtils.writeUnsignedIntegralValue(out, type, value);
+ EncodedValueCodec.writeUnsignedIntegralValue(out, type, value);
break;
}
case VALUE_FLOAT: {
// Shift value left 32 so that right-zero-extension works.
long value = ((CstFloat) cst).getLongBits() << 32;
- EncodedValueUtils.writeRightZeroExtendedValue(out, type, value);
+ EncodedValueCodec.writeRightZeroExtendedValue(out, type, value);
break;
}
case VALUE_DOUBLE: {
long value = ((CstDouble) cst).getLongBits();
- EncodedValueUtils.writeRightZeroExtendedValue(out, type, value);
+ EncodedValueCodec.writeRightZeroExtendedValue(out, type, value);
break;
}
case VALUE_STRING: {
int index = file.getStringIds().indexOf((CstString) cst);
- EncodedValueUtils.writeUnsignedIntegralValue(out, type, (long) index);
+ EncodedValueCodec.writeUnsignedIntegralValue(out, type, (long) index);
break;
}
case VALUE_TYPE: {
int index = file.getTypeIds().indexOf((CstType) cst);
- EncodedValueUtils.writeUnsignedIntegralValue(out, type, (long) index);
+ EncodedValueCodec.writeUnsignedIntegralValue(out, type, (long) index);
break;
}
case VALUE_FIELD: {
int index = file.getFieldIds().indexOf((CstFieldRef) cst);
- EncodedValueUtils.writeUnsignedIntegralValue(out, type, (long) index);
+ EncodedValueCodec.writeUnsignedIntegralValue(out, type, (long) index);
break;
}
case VALUE_METHOD: {
int index = file.getMethodIds().indexOf((CstMethodRef) cst);
- EncodedValueUtils.writeUnsignedIntegralValue(out, type, (long) index);
+ EncodedValueCodec.writeUnsignedIntegralValue(out, type, (long) index);
break;
}
case VALUE_ENUM: {
CstFieldRef fieldRef = ((CstEnumRef) cst).getFieldRef();
int index = file.getFieldIds().indexOf(fieldRef);
- EncodedValueUtils.writeUnsignedIntegralValue(out, type, (long) index);
+ EncodedValueCodec.writeUnsignedIntegralValue(out, type, (long) index);
break;
}
case VALUE_ARRAY: {
package com.android.dx.io;
+import com.android.dex.DexException;
import com.android.dx.io.instructions.DecodedInstruction;
-import com.android.dx.util.DexException;
/**
* Walks through a block of code and calls visitor call backs.
package com.android.dx.io;
+import com.android.dex.Dex;
import java.io.IOException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
* first 32 bytes of dex files are not specified to be included in the
* signature.
*/
- public byte[] computeSignature(DexBuffer dex) throws IOException {
+ public byte[] computeSignature(Dex dex) throws IOException {
MessageDigest digest;
try {
digest = MessageDigest.getInstance("SHA-1");
/**
* Returns the checksum of all but the first 12 bytes of {@code dex}.
*/
- public int computeChecksum(DexBuffer dex) throws IOException {
+ public int computeChecksum(Dex dex) throws IOException {
Adler32 adler32 = new Adler32();
int offset = CHECKSUM_OFFSET + CHECKSUM_SIZE;
* Generates the signature and checksum of the dex file {@code out} and
* writes them to the file.
*/
- public void writeHashes(DexBuffer dex) throws IOException {
+ public void writeHashes(Dex dex) throws IOException {
byte[] signature = computeSignature(dex);
dex.open(SIGNATURE_OFFSET).write(signature);
package com.android.dx.io;
-import com.android.dx.dex.TableOfContents;
+import com.android.dex.ClassDef;
+import com.android.dex.Dex;
+import com.android.dex.FieldId;
+import com.android.dex.MethodId;
+import com.android.dex.ProtoId;
+import com.android.dex.TableOfContents;
import java.io.File;
import java.io.IOException;
* Executable that prints all indices of a dex file.
*/
public final class DexIndexPrinter {
- private final DexBuffer dexBuffer;
+ private final Dex dex;
private final TableOfContents tableOfContents;
public DexIndexPrinter(File file) throws IOException {
- this.dexBuffer = new DexBuffer(file);
- this.tableOfContents = dexBuffer.getTableOfContents();
+ this.dex = new Dex(file);
+ this.tableOfContents = dex.getTableOfContents();
}
private void printMap() {
private void printStrings() throws IOException {
int index = 0;
- for (String string : dexBuffer.strings()) {
+ for (String string : dex.strings()) {
System.out.println("string " + index + ": " + string);
index++;
}
private void printTypeIds() throws IOException {
int index = 0;
- for (Integer type : dexBuffer.typeIds()) {
- System.out.println("type " + index + ": " + dexBuffer.strings().get(type));
+ for (Integer type : dex.typeIds()) {
+ System.out.println("type " + index + ": " + dex.strings().get(type));
index++;
}
}
private void printProtoIds() throws IOException {
int index = 0;
- for (ProtoId protoId : dexBuffer.protoIds()) {
+ for (ProtoId protoId : dex.protoIds()) {
System.out.println("proto " + index + ": " + protoId);
index++;
}
private void printFieldIds() throws IOException {
int index = 0;
- for (FieldId fieldId : dexBuffer.fieldIds()) {
+ for (FieldId fieldId : dex.fieldIds()) {
System.out.println("field " + index + ": " + fieldId);
index++;
}
private void printMethodIds() throws IOException {
int index = 0;
- for (MethodId methodId : dexBuffer.methodIds()) {
+ for (MethodId methodId : dex.methodIds()) {
System.out.println("methodId " + index + ": " + methodId);
index++;
}
System.out.println("No type lists");
return;
}
- DexBuffer.Section in = dexBuffer.open(tableOfContents.typeLists.off);
+ Dex.Section in = dex.open(tableOfContents.typeLists.off);
for (int i = 0; i < tableOfContents.typeLists.size; i++) {
int size = in.readInt();
System.out.print("Type list i=" + i + ", size=" + size + ", elements=");
for (int t = 0; t < size; t++) {
- System.out.print(" " + dexBuffer.typeNames().get((int) in.readShort()));
+ System.out.print(" " + dex.typeNames().get((int) in.readShort()));
}
if (size % 2 == 1) {
in.readShort(); // retain alignment
private void printClassDefs() {
int index = 0;
- for (ClassDef classDef : dexBuffer.classDefs()) {
+ for (ClassDef classDef : dex.classDefs()) {
System.out.println("class def " + index + ": " + classDef);
index++;
}
package com.android.dx.io.instructions;
-import java.io.EOFException;
import java.util.HashMap;
/**
package com.android.dx.io.instructions;
-import java.io.EOFException;
-
/**
* Base implementation of {@link CodeCursor}.
*/
package com.android.dx.io.instructions;
+import com.android.dex.DexException;
import com.android.dx.io.IndexType;
import com.android.dx.io.OpcodeInfo;
import com.android.dx.io.Opcodes;
-import com.android.dx.util.DexException;
import com.android.dx.util.Hex;
import java.io.EOFException;
package com.android.dx.io.instructions;
+import com.android.dex.DexException;
import com.android.dx.io.IndexType;
import com.android.dx.io.OpcodeInfo;
import com.android.dx.io.Opcodes;
-import com.android.dx.util.DexException;
import com.android.dx.util.Hex;
-
import java.io.EOFException;
/**
package com.android.dx.merge;
-import com.android.dx.dex.SizeOf;
-import com.android.dx.dex.TableOfContents;
-import com.android.dx.io.Annotation;
-import com.android.dx.io.ClassData;
-import com.android.dx.io.ClassDef;
-import com.android.dx.io.Code;
-import com.android.dx.io.DexBuffer;
+import com.android.dex.Annotation;
+import com.android.dex.ClassData;
+import com.android.dex.ClassDef;
+import com.android.dex.Code;
+import com.android.dex.Dex;
+import com.android.dex.DexException;
+import com.android.dex.FieldId;
+import com.android.dex.MethodId;
+import com.android.dex.ProtoId;
+import com.android.dex.SizeOf;
+import com.android.dex.TableOfContents;
+import com.android.dex.TypeList;
import com.android.dx.io.DexHasher;
-import com.android.dx.io.FieldId;
-import com.android.dx.io.MethodId;
-import com.android.dx.io.ProtoId;
-import com.android.dx.util.DexException;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
* Combine two dex files into one.
*/
public final class DexMerger {
- private final DexBuffer dexA;
- private final DexBuffer dexB;
+ private final Dex dexA;
+ private final Dex dexB;
private final CollisionPolicy collisionPolicy;
private final WriterSizes writerSizes;
- private final DexBuffer dexOut = new DexBuffer();
+ private final Dex dexOut = new Dex();
- private final DexBuffer.Section headerOut;
+ private final Dex.Section headerOut;
/** All IDs and definitions sections */
- private final DexBuffer.Section idsDefsOut;
+ private final Dex.Section idsDefsOut;
- private final DexBuffer.Section mapListOut;
+ private final Dex.Section mapListOut;
- private final DexBuffer.Section typeListOut;
+ private final Dex.Section typeListOut;
- private final DexBuffer.Section classDataOut;
+ private final Dex.Section classDataOut;
- private final DexBuffer.Section codeOut;
+ private final Dex.Section codeOut;
- private final DexBuffer.Section stringDataOut;
+ private final Dex.Section stringDataOut;
- private final DexBuffer.Section debugInfoOut;
+ private final Dex.Section debugInfoOut;
- private final DexBuffer.Section encodedArrayOut;
+ private final Dex.Section encodedArrayOut;
/** annotations directory on a type */
- private final DexBuffer.Section annotationsDirectoryOut;
+ private final Dex.Section annotationsDirectoryOut;
/** sets of annotations on a member, parameter or type */
- private final DexBuffer.Section annotationSetOut;
+ private final Dex.Section annotationSetOut;
/** parameter lists */
- private final DexBuffer.Section annotationSetRefListOut;
+ private final Dex.Section annotationSetRefListOut;
/** individual annotations, each containing zero or more fields */
- private final DexBuffer.Section annotationOut;
+ private final Dex.Section annotationOut;
private final TableOfContents contentsOut;
/** minimum number of wasted bytes before it's worthwhile to compact the result */
private int compactWasteThreshold = 1024 * 1024; // 1MiB
- public DexMerger(DexBuffer dexA, DexBuffer dexB, CollisionPolicy collisionPolicy)
+ public DexMerger(Dex dexA, Dex dexB, CollisionPolicy collisionPolicy)
throws IOException {
this(dexA, dexB, collisionPolicy, new WriterSizes(dexA, dexB));
}
- private DexMerger(DexBuffer dexA, DexBuffer dexB, CollisionPolicy collisionPolicy,
+ private DexMerger(Dex dexA, Dex dexB, CollisionPolicy collisionPolicy,
WriterSizes writerSizes) throws IOException {
this.dexA = dexA;
this.dexB = dexB;
this.compactWasteThreshold = compactWasteThreshold;
}
- private DexBuffer mergeDexBuffers() throws IOException {
+ private Dex mergeDexes() throws IOException {
mergeStringIds();
mergeTypeIds();
mergeTypeLists();
return dexOut;
}
- public DexBuffer merge() throws IOException {
+ public Dex merge() throws IOException {
long start = System.nanoTime();
- DexBuffer result = mergeDexBuffers();
+ Dex result = mergeDexes();
/*
* We use pessimistic sizes when merging dex files. If those sizes
int wastedByteCount = writerSizes.size() - compactedSizes.size();
if (wastedByteCount > + compactWasteThreshold) {
DexMerger compacter = new DexMerger(
- dexOut, new DexBuffer(), CollisionPolicy.FAIL, compactedSizes);
- result = compacter.mergeDexBuffers();
+ dexOut, new Dex(), CollisionPolicy.FAIL, compactedSizes);
+ result = compacter.mergeDexes();
System.out.printf("Result compacted from %.1fKiB to %.1fKiB to save %.1fKiB%n",
dexOut.getLength() / 1024f,
result.getLength() / 1024f,
* merged dex file. Populates maps from old to new indices in the process.
*/
abstract class IdMerger<T extends Comparable<T>> {
- private final DexBuffer.Section out;
+ private final Dex.Section out;
- protected IdMerger(DexBuffer.Section out) {
+ protected IdMerger(Dex.Section out) {
this.out = out;
}
TableOfContents.Section bSection = getSection(dexB.getTableOfContents());
getSection(contentsOut).off = out.getPosition();
- DexBuffer.Section inA = aSection.exists() ? dexA.open(aSection.off) : null;
- DexBuffer.Section inB = bSection.exists() ? dexB.open(bSection.off) : null;
+ Dex.Section inA = aSection.exists() ? dexA.open(aSection.off) : null;
+ Dex.Section inB = bSection.exists() ? dexB.open(bSection.off) : null;
int aOffset = -1;
int bOffset = -1;
int aIndex = 0;
getSection(contentsOut).size = outCount;
}
- private List<UnsortedValue> readUnsortedValues(DexBuffer source, IndexMap indexMap) {
+ private List<UnsortedValue> readUnsortedValues(Dex source, IndexMap indexMap) {
TableOfContents.Section section = getSection(source.getTableOfContents());
if (!section.exists()) {
return Collections.emptyList();
}
List<UnsortedValue> result = new ArrayList<UnsortedValue>();
- DexBuffer.Section in = source.open(section.off);
+ Dex.Section in = source.open(section.off);
for (int i = 0; i < section.size; i++) {
int offset = in.getPosition();
T value = read(in, indexMap, 0);
}
abstract TableOfContents.Section getSection(TableOfContents tableOfContents);
- abstract T read(DexBuffer.Section in, IndexMap indexMap, int index);
+ abstract T read(Dex.Section in, IndexMap indexMap, int index);
abstract void updateIndex(int offset, IndexMap indexMap, int oldIndex, int newIndex);
abstract void write(T value);
class UnsortedValue implements Comparable<UnsortedValue> {
- final DexBuffer source;
+ final Dex source;
final IndexMap indexMap;
final T value;
final int index;
final int offset;
- UnsortedValue(DexBuffer source, IndexMap indexMap, T value, int index, int offset) {
+ UnsortedValue(Dex source, IndexMap indexMap, T value, int index, int offset) {
this.source = source;
this.indexMap = indexMap;
this.value = value;
}
}
- private IndexMap getIndexMap(DexBuffer dexBuffer) {
- if (dexBuffer == dexA) {
+ private IndexMap getIndexMap(Dex dex) {
+ if (dex == dexA) {
return aIndexMap;
- } else if (dexBuffer == dexB) {
+ } else if (dex == dexB) {
return bIndexMap;
} else {
throw new IllegalArgumentException();
return tableOfContents.stringIds;
}
- @Override String read(DexBuffer.Section in, IndexMap indexMap, int index) {
+ @Override String read(Dex.Section in, IndexMap indexMap, int index) {
return in.readString();
}
return tableOfContents.typeIds;
}
- @Override Integer read(DexBuffer.Section in, IndexMap indexMap, int index) {
+ @Override Integer read(Dex.Section in, IndexMap indexMap, int index) {
int stringIndex = in.readInt();
return indexMap.adjustString(stringIndex);
}
return tableOfContents.typeLists;
}
- @Override TypeList read(DexBuffer.Section in, IndexMap indexMap, int index) {
+ @Override TypeList read(Dex.Section in, IndexMap indexMap, int index) {
return indexMap.adjustTypeList(in.readTypeList());
}
return tableOfContents.protoIds;
}
- @Override ProtoId read(DexBuffer.Section in, IndexMap indexMap, int index) {
+ @Override ProtoId read(Dex.Section in, IndexMap indexMap, int index) {
return indexMap.adjust(in.readProtoId());
}
return tableOfContents.fieldIds;
}
- @Override FieldId read(DexBuffer.Section in, IndexMap indexMap, int index) {
+ @Override FieldId read(Dex.Section in, IndexMap indexMap, int index) {
return indexMap.adjust(in.readFieldId());
}
return tableOfContents.methodIds;
}
- @Override MethodId read(DexBuffer.Section in, IndexMap indexMap, int index) {
+ @Override MethodId read(Dex.Section in, IndexMap indexMap, int index) {
return indexMap.adjust(in.readMethodId());
}
return tableOfContents.annotations;
}
- @Override Annotation read(DexBuffer.Section in, IndexMap indexMap, int index) {
+ @Override Annotation read(Dex.Section in, IndexMap indexMap, int index) {
return indexMap.adjust(in.readAnnotation());
}
contentsOut.classDefs.size = types.length;
for (SortableType type : types) {
- DexBuffer in = type.getBuffer();
+ Dex in = type.getDex();
IndexMap indexMap = (in == dexA) ? aIndexMap : bIndexMap;
transformClassDef(in, type.getClassDef(), indexMap);
}
* Reads just enough data on each class so that we can sort it and then find
* it later.
*/
- private void readSortableTypes(SortableType[] sortableTypes, DexBuffer buffer,
+ private void readSortableTypes(SortableType[] sortableTypes, Dex buffer,
IndexMap indexMap) {
for (ClassDef classDef : buffer.classDefs()) {
SortableType sortableType = indexMap.adjust(new SortableType(buffer, classDef));
transformStaticValues(dexB, bIndexMap);
}
- private void transformAnnotationSets(DexBuffer in, IndexMap indexMap) {
+ private void transformAnnotationSets(Dex in, IndexMap indexMap) {
TableOfContents.Section section = in.getTableOfContents().annotationSets;
if (section.exists()) {
- DexBuffer.Section setIn = in.open(section.off);
+ Dex.Section setIn = in.open(section.off);
for (int i = 0; i < section.size; i++) {
transformAnnotationSet(indexMap, setIn);
}
}
}
- private void transformAnnotationSetRefLists(DexBuffer in, IndexMap indexMap) {
+ private void transformAnnotationSetRefLists(Dex in, IndexMap indexMap) {
TableOfContents.Section section = in.getTableOfContents().annotationSetRefLists;
if (section.exists()) {
- DexBuffer.Section setIn = in.open(section.off);
+ Dex.Section setIn = in.open(section.off);
for (int i = 0; i < section.size; i++) {
transformAnnotationSetRefList(indexMap, setIn);
}
}
}
- private void transformAnnotationDirectories(DexBuffer in, IndexMap indexMap) {
+ private void transformAnnotationDirectories(Dex in, IndexMap indexMap) {
TableOfContents.Section section = in.getTableOfContents().annotationsDirectories;
if (section.exists()) {
- DexBuffer.Section directoryIn = in.open(section.off);
+ Dex.Section directoryIn = in.open(section.off);
for (int i = 0; i < section.size; i++) {
transformAnnotationDirectory(directoryIn, indexMap);
}
}
}
- private void transformStaticValues(DexBuffer in, IndexMap indexMap) {
+ private void transformStaticValues(Dex in, IndexMap indexMap) {
TableOfContents.Section section = in.getTableOfContents().encodedArrays;
if (section.exists()) {
- DexBuffer.Section staticValuesIn = in.open(section.off);
+ Dex.Section staticValuesIn = in.open(section.off);
for (int i = 0; i < section.size; i++) {
transformStaticValues(staticValuesIn, indexMap);
}
* Reads a class_def_item beginning at {@code in} and writes the index and
* data.
*/
- private void transformClassDef(DexBuffer in, ClassDef classDef, IndexMap indexMap) {
+ private void transformClassDef(Dex in, ClassDef classDef, IndexMap indexMap) {
idsDefsOut.assertFourByteAligned();
idsDefsOut.writeInt(classDef.getTypeIndex());
idsDefsOut.writeInt(classDef.getAccessFlags());
* Transform all annotations on a class.
*/
private void transformAnnotationDirectory(
- DexBuffer.Section directoryIn, IndexMap indexMap) {
+ Dex.Section directoryIn, IndexMap indexMap) {
contentsOut.annotationsDirectories.size++;
annotationsDirectoryOut.assertFourByteAligned();
indexMap.putAnnotationDirectoryOffset(
/**
* Transform all annotations on a single type, member or parameter.
*/
- private void transformAnnotationSet(IndexMap indexMap, DexBuffer.Section setIn) {
+ private void transformAnnotationSet(IndexMap indexMap, Dex.Section setIn) {
contentsOut.annotationSets.size++;
annotationSetOut.assertFourByteAligned();
indexMap.putAnnotationSetOffset(setIn.getPosition(), annotationSetOut.getPosition());
/**
* Transform all annotation set ref lists.
*/
- private void transformAnnotationSetRefList(IndexMap indexMap, DexBuffer.Section refListIn) {
+ private void transformAnnotationSetRefList(IndexMap indexMap, Dex.Section refListIn) {
contentsOut.annotationSetRefLists.size++;
annotationSetRefListOut.assertFourByteAligned();
indexMap.putAnnotationSetRefListOffset(
}
}
- private void transformClassData(DexBuffer in, ClassData classData, IndexMap indexMap) {
+ private void transformClassData(Dex in, ClassData classData, IndexMap indexMap) {
contentsOut.classDatas.size++;
ClassData.Field[] staticFields = classData.getStaticFields();
}
}
- private void transformMethods(DexBuffer in, IndexMap indexMap, ClassData.Method[] methods) {
+ private void transformMethods(Dex in, IndexMap indexMap, ClassData.Method[] methods) {
int lastOutMethodIndex = 0;
for (ClassData.Method method : methods) {
int outMethodIndex = indexMap.adjustMethod(method.getMethodIndex());
}
}
- private void transformCode(DexBuffer in, Code code, IndexMap indexMap) {
+ private void transformCode(Dex in, Code code, IndexMap indexMap) {
contentsOut.codes.size++;
codeOut.assertFourByteAligned();
* Unfortunately they're in the opposite order in the dex file so we
* need to transform them out-of-order.
*/
- DexBuffer.Section triesSection = dexOut.open(codeOut.getPosition());
+ Dex.Section triesSection = dexOut.open(codeOut.getPosition());
codeOut.skip(tries.length * SizeOf.TRY_ITEM);
int[] offsets = transformCatchHandlers(indexMap, catchHandlers);
transformTries(triesSection, tries, offsets);
return offsets;
}
- private void transformTries(DexBuffer.Section out, Code.Try[] tries,
+ private void transformTries(Dex.Section out, Code.Try[] tries,
int[] catchHandlerOffsets) {
for (Code.Try tryItem : tries) {
out.writeInt(tryItem.getStartAddress());
private static final byte DBG_SET_EPILOGUE_BEGIN = 0x08;
private static final byte DBG_SET_FILE = 0x09;
- private void transformDebugInfoItem(DexBuffer.Section in, IndexMap indexMap) {
+ private void transformDebugInfoItem(Dex.Section in, IndexMap indexMap) {
contentsOut.debugInfos.size++;
int lineStart = in.readUleb128();
debugInfoOut.writeUleb128(lineStart);
}
}
- private void transformStaticValues(DexBuffer.Section in, IndexMap indexMap) {
+ private void transformStaticValues(Dex.Section in, IndexMap indexMap) {
contentsOut.encodedArrays.size++;
indexMap.putStaticValuesOffset(in.getPosition(), encodedArrayOut.getPosition());
indexMap.adjustEncodedArray(in.readEncodedArray()).writeTo(encodedArrayOut);
/**
* Compute sizes for merging a and b.
*/
- public WriterSizes(DexBuffer a, DexBuffer b) {
+ public WriterSizes(Dex a, Dex b) {
plus(a.getTableOfContents(), false);
plus(b.getTableOfContents(), false);
}
debugInfo += contents.debugInfos.byteCount * 2;
}
- typeList = DexBuffer.fourByteAlign(typeList);
- code = DexBuffer.fourByteAlign(code);
+ typeList = Dex.fourByteAlign(typeList);
+ code = Dex.fourByteAlign(code);
}
public int size() {
return;
}
- DexBuffer dexA = new DexBuffer(new File(args[1]));
- DexBuffer dexB = new DexBuffer(new File(args[2]));
- DexBuffer merged = new DexMerger(dexA, dexB, CollisionPolicy.KEEP_FIRST).merge();
+ Dex dexA = new Dex(new File(args[1]));
+ Dex dexB = new Dex(new File(args[2]));
+ Dex merged = new DexMerger(dexA, dexB, CollisionPolicy.KEEP_FIRST).merge();
merged.writeTo(new File(args[0]));
}
package com.android.dx.merge;
-import com.android.dx.dex.TableOfContents;
-import com.android.dx.io.Annotation;
-import com.android.dx.io.ClassDef;
-import com.android.dx.io.DexBuffer;
-import com.android.dx.io.EncodedValue;
-import com.android.dx.io.EncodedValueReader;
-import static com.android.dx.io.EncodedValueReader.ENCODED_ANNOTATION;
-import static com.android.dx.io.EncodedValueReader.ENCODED_ARRAY;
-import static com.android.dx.io.EncodedValueReader.ENCODED_BOOLEAN;
-import static com.android.dx.io.EncodedValueReader.ENCODED_BYTE;
-import static com.android.dx.io.EncodedValueReader.ENCODED_CHAR;
-import static com.android.dx.io.EncodedValueReader.ENCODED_DOUBLE;
-import static com.android.dx.io.EncodedValueReader.ENCODED_ENUM;
-import static com.android.dx.io.EncodedValueReader.ENCODED_FIELD;
-import static com.android.dx.io.EncodedValueReader.ENCODED_FLOAT;
-import static com.android.dx.io.EncodedValueReader.ENCODED_INT;
-import static com.android.dx.io.EncodedValueReader.ENCODED_LONG;
-import static com.android.dx.io.EncodedValueReader.ENCODED_METHOD;
-import static com.android.dx.io.EncodedValueReader.ENCODED_NULL;
-import static com.android.dx.io.EncodedValueReader.ENCODED_SHORT;
-import static com.android.dx.io.EncodedValueReader.ENCODED_STRING;
-import static com.android.dx.io.EncodedValueReader.ENCODED_TYPE;
-import com.android.dx.io.FieldId;
-import com.android.dx.io.MethodId;
-import com.android.dx.io.ProtoId;
+import com.android.dex.Annotation;
+import com.android.dex.util.ByteOutput;
+import com.android.dex.ClassDef;
+import com.android.dex.Dex;
+import com.android.dex.DexException;
+import com.android.dex.EncodedValue;
+import com.android.dex.EncodedValueReader;
+import static com.android.dex.EncodedValueReader.ENCODED_ANNOTATION;
+import static com.android.dex.EncodedValueReader.ENCODED_ARRAY;
+import static com.android.dex.EncodedValueReader.ENCODED_BOOLEAN;
+import static com.android.dex.EncodedValueReader.ENCODED_BYTE;
+import static com.android.dex.EncodedValueReader.ENCODED_CHAR;
+import static com.android.dex.EncodedValueReader.ENCODED_DOUBLE;
+import static com.android.dex.EncodedValueReader.ENCODED_ENUM;
+import static com.android.dex.EncodedValueReader.ENCODED_FIELD;
+import static com.android.dex.EncodedValueReader.ENCODED_FLOAT;
+import static com.android.dex.EncodedValueReader.ENCODED_INT;
+import static com.android.dex.EncodedValueReader.ENCODED_LONG;
+import static com.android.dex.EncodedValueReader.ENCODED_METHOD;
+import static com.android.dex.EncodedValueReader.ENCODED_NULL;
+import static com.android.dex.EncodedValueReader.ENCODED_SHORT;
+import static com.android.dex.EncodedValueReader.ENCODED_STRING;
+import static com.android.dex.EncodedValueReader.ENCODED_TYPE;
+import com.android.dex.EncodedValueCodec;
+import com.android.dex.FieldId;
+import com.android.dex.Leb128;
+import com.android.dex.MethodId;
+import com.android.dex.ProtoId;
+import com.android.dex.TableOfContents;
+import com.android.dex.TypeList;
import com.android.dx.util.ByteArrayAnnotatedOutput;
-import com.android.dx.util.ByteOutput;
-import com.android.dx.util.DexException;
-import com.android.dx.util.EncodedValueUtils;
-import com.android.dx.util.Leb128Utils;
import java.util.HashMap;
/**
* {@code strings[5]}.
*/
public final class IndexMap {
- private final DexBuffer target;
+ private final Dex target;
public final int[] stringIds;
public final short[] typeIds;
public final short[] protoIds;
private final HashMap<Integer, Integer> annotationDirectoryOffsets;
private final HashMap<Integer, Integer> staticValuesOffsets;
- public IndexMap(DexBuffer target, TableOfContents tableOfContents) {
+ public IndexMap(Dex target, TableOfContents tableOfContents) {
this.target = target;
this.stringIds = new int[tableOfContents.stringIds.size];
this.typeIds = new short[tableOfContents.typeIds.size];
}
public SortableType adjust(SortableType sortableType) {
- return new SortableType(sortableType.getBuffer(), adjust(sortableType.getClassDef()));
+ return new SortableType(sortableType.getDex(), adjust(sortableType.getClassDef()));
}
public EncodedValue adjustEncodedValue(EncodedValue encodedValue) {
// TODO: extract this into a helper class, EncodedValueWriter
switch (reader.peek()) {
case ENCODED_BYTE:
- EncodedValueUtils.writeSignedIntegralValue(out, ENCODED_BYTE, reader.readByte());
+ EncodedValueCodec.writeSignedIntegralValue(out, ENCODED_BYTE, reader.readByte());
break;
case ENCODED_SHORT:
- EncodedValueUtils.writeSignedIntegralValue(out, ENCODED_SHORT, reader.readShort());
+ EncodedValueCodec.writeSignedIntegralValue(out, ENCODED_SHORT, reader.readShort());
break;
case ENCODED_INT:
- EncodedValueUtils.writeSignedIntegralValue(out, ENCODED_INT, reader.readInt());
+ EncodedValueCodec.writeSignedIntegralValue(out, ENCODED_INT, reader.readInt());
break;
case ENCODED_LONG:
- EncodedValueUtils.writeSignedIntegralValue(out, ENCODED_LONG, reader.readLong());
+ EncodedValueCodec.writeSignedIntegralValue(out, ENCODED_LONG, reader.readLong());
break;
case ENCODED_CHAR:
- EncodedValueUtils.writeUnsignedIntegralValue(out, ENCODED_CHAR, reader.readChar());
+ EncodedValueCodec.writeUnsignedIntegralValue(out, ENCODED_CHAR, reader.readChar());
break;
case ENCODED_FLOAT:
// Shift value left 32 so that right-zero-extension works.
long longBits = ((long) Float.floatToIntBits(reader.readFloat())) << 32;
- EncodedValueUtils.writeRightZeroExtendedValue(out, ENCODED_FLOAT, longBits);
+ EncodedValueCodec.writeRightZeroExtendedValue(out, ENCODED_FLOAT, longBits);
break;
case ENCODED_DOUBLE:
- EncodedValueUtils.writeRightZeroExtendedValue(
+ EncodedValueCodec.writeRightZeroExtendedValue(
out, ENCODED_DOUBLE, Double.doubleToLongBits(reader.readDouble()));
break;
case ENCODED_STRING:
- EncodedValueUtils.writeUnsignedIntegralValue(
+ EncodedValueCodec.writeUnsignedIntegralValue(
out, ENCODED_STRING, adjustString(reader.readString()));
break;
case ENCODED_TYPE:
- EncodedValueUtils.writeUnsignedIntegralValue(
+ EncodedValueCodec.writeUnsignedIntegralValue(
out, ENCODED_TYPE, adjustType(reader.readType()));
break;
case ENCODED_FIELD:
- EncodedValueUtils.writeUnsignedIntegralValue(
+ EncodedValueCodec.writeUnsignedIntegralValue(
out, ENCODED_FIELD, adjustField(reader.readField()));
break;
case ENCODED_ENUM:
- EncodedValueUtils.writeUnsignedIntegralValue(
+ EncodedValueCodec.writeUnsignedIntegralValue(
out, ENCODED_ENUM, adjustField(reader.readEnum()));
break;
case ENCODED_METHOD:
- EncodedValueUtils.writeUnsignedIntegralValue(
+ EncodedValueCodec.writeUnsignedIntegralValue(
out, ENCODED_METHOD, adjustMethod(reader.readMethod()));
break;
case ENCODED_ARRAY:
private void transformAnnotation(EncodedValueReader reader) {
int fieldCount = reader.readAnnotation();
- Leb128Utils.writeUnsignedLeb128(out, adjustType(reader.getAnnotationType()));
- Leb128Utils.writeUnsignedLeb128(out, fieldCount);
+ Leb128.writeUnsignedLeb128(out, adjustType(reader.getAnnotationType()));
+ Leb128.writeUnsignedLeb128(out, fieldCount);
for (int i = 0; i < fieldCount; i++) {
- Leb128Utils.writeUnsignedLeb128(out, adjustString(reader.readAnnotationName()));
+ Leb128.writeUnsignedLeb128(out, adjustString(reader.readAnnotationName()));
transform(reader);
}
}
private void transformArray(EncodedValueReader reader) {
int size = reader.readArray();
- Leb128Utils.writeUnsignedLeb128(out, size);
+ Leb128.writeUnsignedLeb128(out, size);
for (int i = 0; i < size; i++) {
transform(reader);
}
package com.android.dx.merge;
+import com.android.dex.DexException;
import com.android.dx.io.CodeReader;
import com.android.dx.io.Opcodes;
import com.android.dx.io.instructions.DecodedInstruction;
import com.android.dx.io.instructions.ShortArrayCodeOutput;
-import com.android.dx.util.DexException;
final class InstructionTransformer {
private final IndexMap indexMap;
package com.android.dx.merge;
-import com.android.dx.io.ClassDef;
-import com.android.dx.io.DexBuffer;
+import com.android.dex.ClassDef;
+import com.android.dex.Dex;
import java.util.Comparator;
/**
}
};
- private final DexBuffer buffer;
+ private final Dex dex;
private ClassDef classDef;
private int depth = -1;
- public SortableType(DexBuffer buffer, ClassDef classDef) {
- this.buffer = buffer;
+ public SortableType(Dex dex, ClassDef classDef) {
+ this.dex = dex;
this.classDef = classDef;
}
- public DexBuffer getBuffer() {
- return buffer;
+ public Dex getDex() {
+ return dex;
}
public ClassDef getClassDef() {
import com.android.dx.rop.cst.CstType;
import com.android.dx.util.MutabilityControl;
import com.android.dx.util.ToHuman;
-
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import com.android.dx.rop.cst.CstType;
import com.android.dx.util.MutabilityControl;
-
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
package com.android.dx.rop.code;
import com.android.dx.rop.cst.Constant;
+import com.android.dx.rop.type.StdTypeList;
import com.android.dx.rop.type.Type;
import com.android.dx.rop.type.TypeList;
-import com.android.dx.rop.type.StdTypeList;
-
import java.util.ArrayList;
/**
import com.android.dx.rop.type.TypeBearer;
import com.android.dx.util.MutabilityControl;
-
import java.util.HashMap;
/**
package com.android.dx.rop.code;
+import com.android.dx.rop.cst.Constant;
+import com.android.dx.rop.cst.CstInteger;
import com.android.dx.rop.type.StdTypeList;
import com.android.dx.rop.type.Type;
-import com.android.dx.rop.type.TypeList;
import com.android.dx.rop.type.TypeBearer;
-import com.android.dx.rop.cst.Constant;
-import com.android.dx.rop.cst.CstInteger;
+import com.android.dx.rop.type.TypeList;
/**
* Plain instruction, which has no embedded data and which cannot possibly
import com.android.dx.rop.type.Type;
import com.android.dx.rop.type.TypeBearer;
import com.android.dx.util.ToHuman;
-
import java.util.HashMap;
/**
import com.android.dx.rop.type.Type;
import com.android.dx.rop.type.TypeList;
import com.android.dx.util.FixedSizeList;
-
import java.util.BitSet;
/**
package com.android.dx.rop.code;
-import com.android.dx.util.Bits;
import com.android.dx.util.Hex;
import com.android.dx.util.IntList;
package com.android.dx.rop.cst;
-import com.android.dx.rop.type.Type;
import com.android.dx.util.FixedSizeList;
/**
package com.android.dx.rop.cst;
-import com.android.dx.util.ExceptionWithContext;
+import com.android.dex.util.ExceptionWithContext;
import com.android.dx.util.Hex;
import com.android.dx.util.MutabilityControl;
package com.android.dx.rop.type;
import com.android.dx.util.Hex;
-
import java.util.HashMap;
/**
package com.android.dx.ssa;
import com.android.dx.rop.code.RegisterSpec;
-import com.android.dx.rop.code.RegisterSpecList;
import com.android.dx.util.IntList;
/**
package com.android.dx.ssa;
-import com.android.dx.rop.code.RegOps;
import com.android.dx.rop.code.RegisterSpec;
import com.android.dx.rop.code.RegisterSpecList;
-import com.android.dx.rop.code.Rop;
-import com.android.dx.rop.code.PlainInsn;
-import com.android.dx.rop.code.Rops;
-import com.android.dx.rop.code.SourcePosition;
-import com.android.dx.rop.code.Insn;
-
import java.util.ArrayList;
import java.util.BitSet;
import java.util.HashSet;
package com.android.dx.ssa;
import com.android.dx.util.IntSet;
-import com.android.dx.util.BitIntSet;
-import com.android.dx.util.ListIntSet;
-
import java.util.ArrayList;
-import java.util.Arrays;
import java.util.BitSet;
/**
import com.android.dx.rop.type.StdTypeList;
import com.android.dx.rop.type.Type;
import com.android.dx.rop.type.TypeBearer;
-
import java.util.ArrayList;
import java.util.BitSet;
import java.util.HashSet;
package com.android.dx.ssa;
-import com.android.dx.rop.code.RegisterSpecList;
import com.android.dx.rop.code.RegisterSpec;
+import com.android.dx.rop.code.RegisterSpecList;
import com.android.dx.ssa.back.InterferenceGraph;
-import com.android.dx.util.IntSet;
import com.android.dx.util.BitIntSet;
-
+import com.android.dx.util.IntSet;
import java.util.ArrayList;
-import java.util.BitSet;
/**
* A register mapper that keeps track of the accumulated interference
package com.android.dx.ssa;
+import com.android.dx.rop.code.Insn;
import com.android.dx.rop.code.PlainCstInsn;
-import com.android.dx.rop.code.TranslationAdvice;
+import com.android.dx.rop.code.PlainInsn;
+import com.android.dx.rop.code.RegOps;
+import com.android.dx.rop.code.RegisterSpec;
import com.android.dx.rop.code.RegisterSpecList;
-import com.android.dx.rop.code.Insn;
import com.android.dx.rop.code.Rop;
-import com.android.dx.rop.code.RegisterSpec;
-import com.android.dx.rop.code.PlainInsn;
import com.android.dx.rop.code.Rops;
-import com.android.dx.rop.code.RegOps;
+import com.android.dx.rop.code.TranslationAdvice;
import com.android.dx.rop.cst.Constant;
import com.android.dx.rop.cst.CstLiteralBits;
import com.android.dx.rop.type.Type;
import com.android.dx.rop.type.TypeBearer;
-
import java.util.ArrayList;
import java.util.List;
package com.android.dx.ssa;
-import com.android.dx.rop.code.RegisterSpecSet;
import com.android.dx.rop.code.RegisterSpec;
+import com.android.dx.rop.code.RegisterSpecSet;
import com.android.dx.util.IntList;
-
import java.util.ArrayList;
import java.util.BitSet;
import java.util.List;
package com.android.dx.ssa;
-import com.android.dx.util.MutabilityControl;
-import com.android.dx.rop.code.RegisterSpecSet;
import com.android.dx.rop.code.RegisterSpec;
-
+import com.android.dx.rop.code.RegisterSpecSet;
+import com.android.dx.util.MutabilityControl;
import java.util.HashMap;
import java.util.List;
package com.android.dx.ssa;
-import com.android.dx.rop.code.RegisterSpec;
-import com.android.dx.rop.code.RegOps;
import com.android.dx.rop.code.CstInsn;
import com.android.dx.rop.code.LocalItem;
+import com.android.dx.rop.code.RegOps;
+import com.android.dx.rop.code.RegisterSpec;
import com.android.dx.rop.cst.CstInteger;
-
import java.util.HashSet;
-import java.util.ArrayList;
import java.util.List;
/**
package com.android.dx.ssa;
-import com.android.dx.rop.code.*;
+import com.android.dx.rop.code.Insn;
+import com.android.dx.rop.code.LocalItem;
+import com.android.dx.rop.code.RegOps;
+import com.android.dx.rop.code.RegisterSpec;
+import com.android.dx.rop.code.RegisterSpecList;
+import com.android.dx.rop.code.Rop;
/**
* A "normal" (non-phi) instruction in SSA form. Always wraps a rop insn.
import com.android.dx.rop.code.TranslationAdvice;
import com.android.dx.ssa.back.LivenessAnalyzer;
import com.android.dx.ssa.back.SsaToRop;
-
import java.util.EnumSet;
/**
package com.android.dx.ssa;
-import com.android.dx.rop.code.*;
+import com.android.dx.rop.code.Insn;
+import com.android.dx.rop.code.LocalItem;
+import com.android.dx.rop.code.RegisterSpec;
+import com.android.dx.rop.code.RegisterSpecList;
+import com.android.dx.rop.code.Rop;
+import com.android.dx.rop.code.SourcePosition;
import com.android.dx.rop.type.Type;
import com.android.dx.rop.type.TypeBearer;
import com.android.dx.util.Hex;
-
import java.util.ArrayList;
import java.util.List;
package com.android.dx.ssa;
import com.android.dx.cf.code.Merger;
+import com.android.dx.rop.code.LocalItem;
import com.android.dx.rop.code.RegisterSpec;
import com.android.dx.rop.code.RegisterSpecList;
-import com.android.dx.rop.code.LocalItem;
import com.android.dx.rop.type.Type;
import com.android.dx.rop.type.TypeBearer;
-
import java.util.BitSet;
import java.util.List;
import com.android.dx.rop.code.RegisterSpec;
import com.android.dx.rop.code.RegisterSpecList;
-import com.android.dx.util.ToHuman;
/**
* Represents a mapping between two register numbering schemes.
import com.android.dx.rop.code.Insn;
import com.android.dx.rop.code.PlainInsn;
import com.android.dx.rop.code.RegOps;
+import com.android.dx.rop.code.RegisterSpec;
import com.android.dx.rop.code.RegisterSpecList;
import com.android.dx.rop.code.Rop;
-import com.android.dx.rop.code.RegisterSpec;
import com.android.dx.rop.code.Rops;
import com.android.dx.rop.cst.Constant;
import com.android.dx.rop.cst.CstInteger;
import com.android.dx.rop.cst.TypedConstant;
-import com.android.dx.rop.type.TypeBearer;
import com.android.dx.rop.type.Type;
-
+import com.android.dx.rop.type.TypeBearer;
import java.util.ArrayList;
import java.util.BitSet;
import com.android.dx.util.Hex;
import com.android.dx.util.IntList;
import com.android.dx.util.IntSet;
-
import java.util.ArrayList;
import java.util.BitSet;
import java.util.Collections;
import com.android.dx.rop.code.RegisterSpec;
import com.android.dx.rop.code.RopMethod;
import com.android.dx.util.IntIterator;
-
import java.util.ArrayList;
import java.util.BitSet;
package com.android.dx.ssa;
-import com.android.dx.rop.code.*;
+import com.android.dx.rop.code.Insn;
+import com.android.dx.rop.code.LocalItem;
+import com.android.dx.rop.code.RegisterSpec;
+import com.android.dx.rop.code.RegisterSpecList;
+import com.android.dx.rop.code.Rop;
import com.android.dx.util.ToHuman;
/**
import com.android.dx.rop.code.Rops;
import com.android.dx.rop.code.SourcePosition;
import com.android.dx.util.IntList;
-
import java.util.ArrayList;
import java.util.BitSet;
import java.util.Collections;
import com.android.dx.rop.code.SourcePosition;
import com.android.dx.rop.type.Type;
import com.android.dx.util.IntList;
-
import java.util.ArrayList;
import java.util.BitSet;
import java.util.HashMap;
import com.android.dx.rop.code.CstInsn;
import com.android.dx.rop.cst.CstInteger;
-import com.android.dx.ssa.NormalSsaInsn;
import com.android.dx.ssa.BasicRegisterMapper;
+import com.android.dx.ssa.NormalSsaInsn;
import com.android.dx.ssa.RegisterMapper;
import com.android.dx.ssa.SsaMethod;
-import com.android.dx.util.IntSet;
import com.android.dx.util.BitIntSet;
-
+import com.android.dx.util.IntSet;
import java.util.BitSet;
-import java.util.ArrayList;
/**
* Allocates registers via a naive n^2 register allocator.
package com.android.dx.ssa.back;
-import com.android.dx.rop.code.*;
+import com.android.dx.rop.code.CstInsn;
+import com.android.dx.rop.code.LocalItem;
+import com.android.dx.rop.code.RegOps;
+import com.android.dx.rop.code.RegisterSpec;
+import com.android.dx.rop.code.RegisterSpecList;
+import com.android.dx.rop.code.Rop;
import com.android.dx.rop.cst.CstInteger;
import com.android.dx.ssa.InterferenceRegisterMapper;
-import com.android.dx.ssa.RegisterMapper;
-import com.android.dx.ssa.SsaInsn;
-import com.android.dx.ssa.SsaMethod;
import com.android.dx.ssa.NormalSsaInsn;
-import com.android.dx.ssa.PhiInsn;
import com.android.dx.ssa.Optimizer;
+import com.android.dx.ssa.PhiInsn;
+import com.android.dx.ssa.RegisterMapper;
import com.android.dx.ssa.SsaBasicBlock;
-import com.android.dx.util.IntSet;
+import com.android.dx.ssa.SsaInsn;
+import com.android.dx.ssa.SsaMethod;
import com.android.dx.util.IntIterator;
-
+import com.android.dx.util.IntSet;
import java.util.ArrayList;
import java.util.BitSet;
import java.util.Map;
import com.android.dx.rop.code.BasicBlock;
import com.android.dx.rop.code.BasicBlockList;
-import com.android.dx.rop.code.CstInsn;
-import com.android.dx.rop.code.Insn;
-import com.android.dx.rop.code.InsnList;
import com.android.dx.rop.code.RegOps;
import com.android.dx.rop.code.RopMethod;
-import com.android.dx.rop.code.SwitchInsn;
import com.android.dx.util.IntList;
-
import java.util.BitSet;
/**
package com.android.dx.ssa.back;
-import com.android.dx.ssa.SsaMethod;
-import com.android.dx.ssa.SsaBasicBlock;
-import com.android.dx.ssa.SsaInsn;
-import com.android.dx.ssa.PhiInsn;
import com.android.dx.ssa.SetFactory;
-import com.android.dx.rop.code.RegisterSpec;
import com.android.dx.util.IntSet;
-import com.android.dx.util.BitIntSet;
-import com.android.dx.util.ListIntSet;
-
-import java.util.BitSet;
-import java.util.List;
import java.util.ArrayList;
/**
package com.android.dx.ssa.back;
-import com.android.dx.ssa.SsaMethod;
+import com.android.dx.rop.code.RegisterSpec;
+import com.android.dx.ssa.PhiInsn;
import com.android.dx.ssa.SsaBasicBlock;
import com.android.dx.ssa.SsaInsn;
-import com.android.dx.ssa.PhiInsn;
-import com.android.dx.rop.code.RegisterSpec;
-
+import com.android.dx.ssa.SsaMethod;
+import java.util.ArrayList;
import java.util.BitSet;
import java.util.List;
-import java.util.ArrayList;
/**
* From Appel "Modern Compiler Implementation in Java" algorithm 19.17
import com.android.dx.ssa.RegisterMapper;
import com.android.dx.ssa.SsaMethod;
-import java.util.BitSet;
-import java.util.ArrayList;
-
/**
* A register allocator that maps SSA register n to Rop register 2*n,
* essentially preserving the original mapping and remaining agnostic
package com.android.dx.ssa.back;
+import com.android.dx.rop.code.PlainInsn;
import com.android.dx.rop.code.RegOps;
import com.android.dx.rop.code.RegisterSpec;
-import com.android.dx.rop.code.PlainInsn;
+import com.android.dx.rop.code.RegisterSpecList;
import com.android.dx.rop.code.Rops;
import com.android.dx.rop.code.SourcePosition;
-import com.android.dx.rop.code.RegisterSpecList;
import com.android.dx.ssa.NormalSsaInsn;
import com.android.dx.ssa.RegisterMapper;
+import com.android.dx.ssa.SsaBasicBlock;
import com.android.dx.ssa.SsaInsn;
import com.android.dx.ssa.SsaMethod;
-import com.android.dx.ssa.SsaBasicBlock;
-import com.android.dx.util.IntSet;
import com.android.dx.util.IntIterator;
-
-import java.util.BitSet;
+import com.android.dx.util.IntSet;
import java.util.ArrayList;
/**
import com.android.dx.ssa.SsaMethod;
import com.android.dx.util.Hex;
import com.android.dx.util.IntList;
-
import java.util.ArrayList;
import java.util.Arrays;
import java.util.BitSet;
package com.android.dx.util;
+import com.android.dex.util.ByteOutput;
+import com.android.dex.util.ExceptionWithContext;
+import com.android.dex.Leb128;
import java.io.IOException;
import java.io.Writer;
import java.util.ArrayList;
ensureCapacity(cursor + 5); // pessimistic
}
int cursorBefore = cursor;
- Leb128Utils.writeUnsignedLeb128(this, value);
+ Leb128.writeUnsignedLeb128(this, value);
return (cursor - cursorBefore);
}
ensureCapacity(cursor + 5); // pessimistic
}
int cursorBefore = cursor;
- Leb128Utils.writeSignedLeb128(this, value);
+ Leb128.writeSignedLeb128(this, value);
return (cursor - cursorBefore);
}
package com.android.dx.util;
+import com.android.dex.util.ExceptionWithContext;
+
/**
* Exception due to a mutability problem.
*/
package com.android.dx.util;
+import com.android.dex.util.ByteOutput;
+
/**
* Interface for a sink for binary output. This is similar to
* {@code java.util.DataOutput}, but no {@code IOExceptions}
+++ /dev/null
-/*
- * Copyright (C) 2011 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.android.dx.util;
-
-/**
- * An unsigned integer.
- */
-public final class Uint implements Comparable<Uint> {
- public final int intValue;
-
- public Uint(int value) {
- this.intValue = value;
- }
-
- public int compareTo(Uint uint) {
- return Unsigned.compare(intValue, uint.intValue);
- }
-}
package com.android.dx.merge;
-import com.android.dx.io.DexBuffer;
+import com.android.dex.Dex;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
int steps = 100;
int compactWasteThreshold = 1024;
- DexBuffer dexA = resourceToDexBuffer("/testdata/Basic.dex");
- DexBuffer dexB = resourceToDexBuffer("/testdata/TryCatchFinally.dex");
- DexBuffer merged = new DexMerger(dexA, dexB, CollisionPolicy.KEEP_FIRST).merge();
+ Dex dexA = resourceToDexBuffer("/testdata/Basic.dex");
+ Dex dexB = resourceToDexBuffer("/testdata/TryCatchFinally.dex");
+ Dex merged = new DexMerger(dexA, dexB, CollisionPolicy.KEEP_FIRST).merge();
int maxLength = 0;
for (int i = 0; i < steps; i++) {
}
public ClassLoader mergeAndLoad(String dexAResource, String dexBResource) throws Exception {
- DexBuffer dexA = resourceToDexBuffer(dexAResource);
- DexBuffer dexB = resourceToDexBuffer(dexBResource);
- DexBuffer merged = new DexMerger(dexA, dexB, CollisionPolicy.KEEP_FIRST).merge();
+ Dex dexA = resourceToDexBuffer(dexAResource);
+ Dex dexB = resourceToDexBuffer(dexBResource);
+ Dex merged = new DexMerger(dexA, dexB, CollisionPolicy.KEEP_FIRST).merge();
File mergedDex = File.createTempFile("DexMergeTest", ".classes.dex");
merged.writeTo(mergedDex);
File mergedJar = dexToJar(mergedDex);
.newInstance(mergedJar.getPath(), getClass().getClassLoader());
}
- private DexBuffer resourceToDexBuffer(String resource) throws IOException {
- return new DexBuffer(getClass().getResourceAsStream(resource));
+ private Dex resourceToDexBuffer(String resource) throws IOException {
+ return new Dex(getClass().getResourceAsStream(resource));
}
private File dexToJar(File dex) throws IOException {
package com.android.dx.util;
+import com.android.dex.util.ByteArrayByteInput;
+import com.android.dex.Leb128;
import java.io.IOException;
import java.util.Arrays;
import junit.framework.TestCase;
public final class Leb128UtilsTest extends TestCase {
public void testDecodeUnsignedLeb() throws IOException {
- assertEquals(0, Leb128Utils.readUnsignedLeb128(new ByteArrayByteInput((byte) 0)));
- assertEquals(1, Leb128Utils.readUnsignedLeb128(new ByteArrayByteInput((byte) 1)));
- assertEquals(127, Leb128Utils.readUnsignedLeb128(new ByteArrayByteInput((byte) 0x7f)));
- assertEquals(16256, Leb128Utils.readUnsignedLeb128(
+ assertEquals(0, Leb128.readUnsignedLeb128(new ByteArrayByteInput((byte) 0)));
+ assertEquals(1, Leb128.readUnsignedLeb128(new ByteArrayByteInput((byte) 1)));
+ assertEquals(127, Leb128.readUnsignedLeb128(new ByteArrayByteInput((byte) 0x7f)));
+ assertEquals(16256, Leb128.readUnsignedLeb128(
new ByteArrayByteInput((byte) 0x80, (byte) 0x7f)));
}
}
public void testDecodeSignedLeb() throws IOException {
- assertEquals(0, Leb128Utils.readSignedLeb128(new ByteArrayByteInput((byte) 0)));
- assertEquals(1, Leb128Utils.readSignedLeb128(new ByteArrayByteInput((byte) 1)));
- assertEquals(-1, Leb128Utils.readSignedLeb128(new ByteArrayByteInput((byte) 0x7f)));
- assertEquals(0x3c, Leb128Utils.readSignedLeb128(new ByteArrayByteInput((byte) 0x3c)));
- assertEquals(-128, Leb128Utils.readSignedLeb128(
+ assertEquals(0, Leb128.readSignedLeb128(new ByteArrayByteInput((byte) 0)));
+ assertEquals(1, Leb128.readSignedLeb128(new ByteArrayByteInput((byte) 1)));
+ assertEquals(-1, Leb128.readSignedLeb128(new ByteArrayByteInput((byte) 0x7f)));
+ assertEquals(0x3c, Leb128.readSignedLeb128(new ByteArrayByteInput((byte) 0x3c)));
+ assertEquals(-128, Leb128.readSignedLeb128(
new ByteArrayByteInput((byte) 0x80, (byte) 0x7f)));
}
private byte[] encodeSignedLeb(int value) {
ByteArrayAnnotatedOutput out = new ByteArrayAnnotatedOutput(5);
- Leb128Utils.writeSignedLeb128(out, value);
+ Leb128.writeSignedLeb128(out, value);
return out.toByteArray();
}
private byte[] encodeUnsignedLeb(int value) {
ByteArrayAnnotatedOutput out = new ByteArrayAnnotatedOutput(5);
- Leb128Utils.writeUnsignedLeb128(out, value);
+ Leb128.writeUnsignedLeb128(out, value);
return out.toByteArray();
}
package com.android.dx.util;
+import com.android.dex.util.ByteArrayByteInput;
+import com.android.dex.util.ByteInput;
+import com.android.dex.Mutf8;
import java.io.IOException;
import java.util.Arrays;
import junit.framework.TestCase;
package com.android.dx.merge;
-import com.android.dx.io.DexBuffer;
-import com.android.dx.util.DexException;
+import com.android.dex.Dex;
+import com.android.dex.DexException;
import java.io.IOException;
import junit.framework.TestCase;
public final class MergeConflictTest extends TestCase {
public void testMergeConflict() throws IOException {
- DexBuffer a = resourceToDexBuffer("/testdata/A.dex");
- DexBuffer b = resourceToDexBuffer("/testdata/B.dex");
+ Dex a = resourceToDexBuffer("/testdata/A.dex");
+ Dex b = resourceToDexBuffer("/testdata/B.dex");
// a and b don't overlap; this should succeed
- DexBuffer ab = new DexMerger(a, b, CollisionPolicy.FAIL).merge();
+ Dex ab = new DexMerger(a, b, CollisionPolicy.FAIL).merge();
// a and ab overlap; this should fail
DexMerger dexMerger = new DexMerger(a, ab, CollisionPolicy.FAIL);
}
}
- private DexBuffer resourceToDexBuffer(String resource) throws IOException {
- return new DexBuffer(getClass().getResourceAsStream(resource));
+ private Dex resourceToDexBuffer(String resource) throws IOException {
+ return new Dex(getClass().getResourceAsStream(resource));
}
}
OSDN Git Service
