{
+
+ public When forConstantValue(Nonnull qualifierqualifierArgument,
+ Object value) {
+ if (value == null)
+ return When.NEVER;
+ return When.ALWAYS;
+ }
+ }
+}
diff --git a/src/javax/annotation/Nullable.java b/src/javax/annotation/Nullable.java
new file mode 100644
index 0000000..d31993d
--- /dev/null
+++ b/src/javax/annotation/Nullable.java
@@ -0,0 +1,16 @@
+package javax.annotation;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+import javax.annotation.meta.TypeQualifierNickname;
+import javax.annotation.meta.When;
+
+@Documented
+@TypeQualifierNickname
+@Nonnull(when = When.UNKNOWN)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Nullable {
+
+}
diff --git a/src/javax/annotation/OverridingMethodsMustInvokeSuper.java b/src/javax/annotation/OverridingMethodsMustInvokeSuper.java
new file mode 100644
index 0000000..4e3344e
--- /dev/null
+++ b/src/javax/annotation/OverridingMethodsMustInvokeSuper.java
@@ -0,0 +1,20 @@
+package javax.annotation;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * When this annotation is applied to a method, it indicates that if this method
+ * is overridden in a subclass, the overriding method should invoke this method
+ * (through method invocation on super).
+ *
+ */
+@Documented
+@Target( { ElementType.METHOD })
+@Retention(RetentionPolicy.RUNTIME)
+public @interface OverridingMethodsMustInvokeSuper {
+
+}
diff --git a/src/javax/annotation/ParametersAreNonnullByDefault.java b/src/javax/annotation/ParametersAreNonnullByDefault.java
new file mode 100644
index 0000000..6424b87
--- /dev/null
+++ b/src/javax/annotation/ParametersAreNonnullByDefault.java
@@ -0,0 +1,27 @@
+package javax.annotation;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+import javax.annotation.meta.TypeQualifierDefault;
+
+/**
+ * This annotation can be applied to a package, class or method to indicate that
+ * the method parameters in that element are nonnull by default unless there is:
+ *
+ * - An explicit nullness annotation
+ *
- The method overrides a method in a superclass (in which case the
+ * annotation of the corresponding parameter in the superclass applies)
+ *
- there is a default parameter annotation applied to a more tightly nested
+ * element.
+ *
+ *
+ */
+@Documented
+@Nonnull
+@TypeQualifierDefault(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface ParametersAreNonnullByDefault {
+}
diff --git a/src/javax/annotation/ParametersAreNullableByDefault.java b/src/javax/annotation/ParametersAreNullableByDefault.java
new file mode 100644
index 0000000..01d4d80
--- /dev/null
+++ b/src/javax/annotation/ParametersAreNullableByDefault.java
@@ -0,0 +1,30 @@
+package javax.annotation;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+import javax.annotation.meta.TypeQualifierDefault;
+
+/**
+ * This annotation can be applied to a package, class or method to indicate that
+ * the method parameters in that element are nullable by default unless there is:
+ *
+ * - An explicit nullness annotation
+ *
- The method overrides a method in a superclass (in which case the
+ * annotation of the corresponding parameter in the superclass applies)
+ *
- there is a default parameter annotation applied to a more tightly nested
+ * element.
+ *
+ * This annotation implies the same "nullness" as no annotation. However, it is different
+ * than having no annotation, as it is inherited and it can override a ParametersAreNonnullByDefault
+ * annotation at an outer scope.
+ *
+ */
+@Documented
+@Nullable
+@TypeQualifierDefault(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface ParametersAreNullableByDefault {
+}
diff --git a/src/javax/annotation/PropertyKey.java b/src/javax/annotation/PropertyKey.java
new file mode 100644
index 0000000..780782d
--- /dev/null
+++ b/src/javax/annotation/PropertyKey.java
@@ -0,0 +1,15 @@
+package javax.annotation;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+import javax.annotation.meta.TypeQualifier;
+import javax.annotation.meta.When;
+
+@Documented
+@TypeQualifier
+@Retention(RetentionPolicy.RUNTIME)
+public @interface PropertyKey {
+ When when() default When.ALWAYS;
+}
diff --git a/src/javax/annotation/RegEx.java b/src/javax/annotation/RegEx.java
new file mode 100644
index 0000000..21697a7
--- /dev/null
+++ b/src/javax/annotation/RegEx.java
@@ -0,0 +1,42 @@
+package javax.annotation;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.regex.Pattern;
+import java.util.regex.PatternSyntaxException;
+
+import javax.annotation.meta.TypeQualifierNickname;
+import javax.annotation.meta.TypeQualifierValidator;
+import javax.annotation.meta.When;
+
+/**
+ * This qualifier is used to denote String values that should be a Regular
+ * expression.
+ *
+ */
+@Documented
+@Syntax("RegEx")
+@TypeQualifierNickname
+@Retention(RetentionPolicy.RUNTIME)
+public @interface RegEx {
+ When when() default When.ALWAYS;
+
+ static class Checker implements TypeQualifierValidator {
+
+ public When forConstantValue(RegEx annotation, Object value) {
+ if (!(value instanceof String))
+ return When.NEVER;
+
+ try {
+ Pattern.compile((String) value);
+ } catch (PatternSyntaxException e) {
+ return When.NEVER;
+ }
+ return When.ALWAYS;
+
+ }
+
+ }
+
+}
diff --git a/src/javax/annotation/Signed.java b/src/javax/annotation/Signed.java
new file mode 100644
index 0000000..2c2fa06
--- /dev/null
+++ b/src/javax/annotation/Signed.java
@@ -0,0 +1,18 @@
+package javax.annotation;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+import javax.annotation.meta.TypeQualifierNickname;
+import javax.annotation.meta.When;
+
+/** Used to annotate a value of unknown sign */
+
+@Documented
+@TypeQualifierNickname
+@Nonnegative(when = When.UNKNOWN)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Signed {
+
+}
diff --git a/src/javax/annotation/Syntax.java b/src/javax/annotation/Syntax.java
new file mode 100644
index 0000000..fa0586d
--- /dev/null
+++ b/src/javax/annotation/Syntax.java
@@ -0,0 +1,44 @@
+package javax.annotation;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+import javax.annotation.meta.TypeQualifier;
+import javax.annotation.meta.When;
+
+/**
+ * This annotation a value that is of a particular syntax, such as Java syntax
+ * or regular expression syntax. This can be used to provide syntax checking of
+ * constant values at compile time, run time checking at runtime, and can assist
+ * IDEs in deciding how to interpret String constants (e.g., should a
+ * refactoring that renames method x() to y() update the String constant "x()").
+ *
+ *
+ */
+@Documented
+@TypeQualifier(applicableTo = CharSequence.class)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Syntax {
+ /**
+ * Value indicating the particular syntax denoted by this annotation.
+ * Different tools will recognize different syntaxes, but some proposed
+ * canonical values are:
+ *
+ * - "Java"
+ *
- "RegEx"
+ *
- "JavaScript"
+ *
- "Ruby"
+ *
- "Groovy"
+ *
- "SQL"
+ *
- "FormatString"
+ *
+ *
+ * Syntax names can be followed by a colon and a list of key value pairs,
+ * separated by commas. For example, "SQL:dialect=Oracle,version=2.3". Tools
+ * should ignore any keys they don't recognize.
+ */
+ String value();
+
+ When when() default When.ALWAYS;
+}
diff --git a/src/javax/annotation/Tainted.java b/src/javax/annotation/Tainted.java
new file mode 100644
index 0000000..6715d70
--- /dev/null
+++ b/src/javax/annotation/Tainted.java
@@ -0,0 +1,16 @@
+package javax.annotation;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+import javax.annotation.meta.TypeQualifierNickname;
+import javax.annotation.meta.When;
+
+@Documented
+@TypeQualifierNickname
+@Untainted(when = When.MAYBE)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Tainted {
+
+}
diff --git a/src/javax/annotation/Untainted.java b/src/javax/annotation/Untainted.java
new file mode 100644
index 0000000..4a26a49
--- /dev/null
+++ b/src/javax/annotation/Untainted.java
@@ -0,0 +1,15 @@
+package javax.annotation;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+import javax.annotation.meta.TypeQualifier;
+import javax.annotation.meta.When;
+
+@Documented
+@TypeQualifier
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Untainted {
+ When when() default When.ALWAYS;
+}
diff --git a/src/javax/annotation/WillClose.java b/src/javax/annotation/WillClose.java
new file mode 100644
index 0000000..9ea70cf
--- /dev/null
+++ b/src/javax/annotation/WillClose.java
@@ -0,0 +1,15 @@
+package javax.annotation;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/**
+ * Used to annotate a method parameter to indicate that this method will close
+ * the resource.
+ */
+public @interface WillClose {
+
+}
diff --git a/src/javax/annotation/WillCloseWhenClosed.java b/src/javax/annotation/WillCloseWhenClosed.java
new file mode 100644
index 0000000..13c927d
--- /dev/null
+++ b/src/javax/annotation/WillCloseWhenClosed.java
@@ -0,0 +1,15 @@
+package javax.annotation;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/**
+ * Used to annotate a constructor/factory parameter to indicate that returned
+ * object (X) will close the resource when X is closed.
+ */
+public @interface WillCloseWhenClosed {
+
+}
diff --git a/src/javax/annotation/WillNotClose.java b/src/javax/annotation/WillNotClose.java
new file mode 100644
index 0000000..d698b7c
--- /dev/null
+++ b/src/javax/annotation/WillNotClose.java
@@ -0,0 +1,15 @@
+package javax.annotation;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/**
+ * Used to annotate a method parameter to indicate that this method will not
+ * close the resource.
+ */
+public @interface WillNotClose {
+
+}
diff --git a/src/javax/annotation/concurrent/GuardedBy.java b/src/javax/annotation/concurrent/GuardedBy.java
new file mode 100644
index 0000000..9d6641d
--- /dev/null
+++ b/src/javax/annotation/concurrent/GuardedBy.java
@@ -0,0 +1,38 @@
+package javax.annotation.concurrent;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/*
+ * Copyright (c) 2005 Brian Goetz
+ * Released under the Creative Commons Attribution License
+ * (http://creativecommons.org/licenses/by/2.5)
+ * Official home: http://www.jcip.net
+ */
+
+/**
+ * GuardedBy
+ *
+ * The field or method to which this annotation is applied can only be accessed
+ * when holding a particular lock, which may be a built-in (synchronization)
+ * lock, or may be an explicit java.util.concurrent.Lock.
+ *
+ * The argument determines which lock guards the annotated field or method: this :
+ * The string literal "this" means that this field is guarded by the class in
+ * which it is defined. class-name.this : For inner classes, it may be necessary
+ * to disambiguate 'this'; the class-name.this designation allows you to specify
+ * which 'this' reference is intended itself : For reference fields only; the
+ * object to which the field refers. field-name : The lock object is referenced
+ * by the (instance or static) field specified by field-name.
+ * class-name.field-name : The lock object is reference by the static field
+ * specified by class-name.field-name. method-name() : The lock object is
+ * returned by calling the named nil-ary method. class-name.class : The Class
+ * object for the specified class should be used as the lock object.
+ */
+@Target( { ElementType.FIELD, ElementType.METHOD })
+@Retention(RetentionPolicy.CLASS)
+public @interface GuardedBy {
+ String value();
+}
diff --git a/src/javax/annotation/concurrent/Immutable.java b/src/javax/annotation/concurrent/Immutable.java
new file mode 100644
index 0000000..03f1cb5
--- /dev/null
+++ b/src/javax/annotation/concurrent/Immutable.java
@@ -0,0 +1,36 @@
+package javax.annotation.concurrent;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/*
+ * Copyright (c) 2005 Brian Goetz
+ * Released under the Creative Commons Attribution License
+ * (http://creativecommons.org/licenses/by/2.5)
+ * Official home: http://www.jcip.net
+ */
+
+/**
+ * Immutable
+ *
+ * The class to which this annotation is applied is immutable. This means that
+ * its state cannot be seen to change by callers. Of necessity this means that
+ * all public fields are final, and that all public final reference fields refer
+ * to other immutable objects, and that methods do not publish references to any
+ * internal state which is mutable by implementation even if not by design.
+ * Immutable objects may still have internal mutable state for purposes of
+ * performance optimization; some state variables may be lazily computed, so
+ * long as they are computed from immutable state and that callers cannot tell
+ * the difference.
+ *
+ * Immutable objects are inherently thread-safe; they may be passed between
+ * threads or published without synchronization.
+ */
+@Documented
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.CLASS)
+public @interface Immutable {
+}
diff --git a/src/javax/annotation/concurrent/NotThreadSafe.java b/src/javax/annotation/concurrent/NotThreadSafe.java
new file mode 100644
index 0000000..d948142
--- /dev/null
+++ b/src/javax/annotation/concurrent/NotThreadSafe.java
@@ -0,0 +1,30 @@
+package javax.annotation.concurrent;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/*
+ * Copyright (c) 2005 Brian Goetz
+ * Released under the Creative Commons Attribution License
+ * (http://creativecommons.org/licenses/by/2.5)
+ * Official home: http://www.jcip.net
+ */
+
+/**
+ * NotThreadSafe
+ *
+ * The class to which this annotation is applied is not thread-safe. This
+ * annotation primarily exists for clarifying the non-thread-safety of a class
+ * that might otherwise be assumed to be thread-safe, despite the fact that it
+ * is a bad idea to assume a class is thread-safe without good reason.
+ *
+ * @see ThreadSafe
+ */
+@Documented
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.CLASS)
+public @interface NotThreadSafe {
+}
diff --git a/src/javax/annotation/concurrent/ThreadSafe.java b/src/javax/annotation/concurrent/ThreadSafe.java
new file mode 100644
index 0000000..3c86128
--- /dev/null
+++ b/src/javax/annotation/concurrent/ThreadSafe.java
@@ -0,0 +1,22 @@
+package javax.annotation.concurrent;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * ThreadSafe
+ *
+ * The class to which this annotation is applied is thread-safe. This means that
+ * no sequences of accesses (reads and writes to public fields, calls to public
+ * methods) may put the object into an invalid state, regardless of the
+ * interleaving of those actions by the runtime, and without requiring any
+ * additional synchronization or coordination on the part of the caller.
+ */
+@Documented
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.CLASS)
+public @interface ThreadSafe {
+}
diff --git a/src/javax/annotation/meta/Exclusive.java b/src/javax/annotation/meta/Exclusive.java
new file mode 100644
index 0000000..d018c33
--- /dev/null
+++ b/src/javax/annotation/meta/Exclusive.java
@@ -0,0 +1,26 @@
+package javax.annotation.meta;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/**
+ * This annotation can be applied to the value() element of an annotation that
+ * is annotated as a TypeQualifier.
+ *
+ * For example, the following defines a type qualifier such that if you know a
+ * value is {@literal @Foo(1)}, then the value cannot be {@literal @Foo(2)} or {{@literal @Foo(3)}.
+ *
+ *
+ * @TypeQualifier @interface Foo {
+ * @Exclusive int value();
+ * }
+ *
+ *
+ */
+
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Exclusive {
+
+}
diff --git a/src/javax/annotation/meta/Exhaustive.java b/src/javax/annotation/meta/Exhaustive.java
new file mode 100644
index 0000000..dc75f06
--- /dev/null
+++ b/src/javax/annotation/meta/Exhaustive.java
@@ -0,0 +1,33 @@
+package javax.annotation.meta;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/**
+ * This annotation can be applied to the value() element of an annotation that
+ * is annotated as a TypeQualifier. This is only appropriate if the value field
+ * returns a value that is an Enumeration.
+ *
+ * Applications of the type qualifier with different values are exclusive, and
+ * the enumeration is an exhaustive list of the possible values.
+ *
+ * For example, the following defines a type qualifier such that if you know a
+ * value is neither {@literal @Foo(Color.Red)} or {@literal @Foo(Color.Blue)},
+ * then the value must be {@literal @Foo(Color.Green)}. And if you know it is
+ * {@literal @Foo(Color.Green)}, you know it cannot be
+ * {@literal @Foo(Color.Red)} or {@literal @Foo(Color.Blue)}
+ *
+ *
+ * @TypeQualifier @interface Foo {
+ * enum Color {RED, BLUE, GREEN};
+ * @Exhaustive Color value();
+ * }
+ *
+ */
+
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Exhaustive {
+
+}
diff --git a/src/javax/annotation/meta/TypeQualifier.java b/src/javax/annotation/meta/TypeQualifier.java
new file mode 100644
index 0000000..99f6312
--- /dev/null
+++ b/src/javax/annotation/meta/TypeQualifier.java
@@ -0,0 +1,27 @@
+package javax.annotation.meta;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * This qualifier is applied to an annotation to denote that the annotation
+ * should be treated as a type qualifier.
+ */
+
+@Documented
+@Target(ElementType.ANNOTATION_TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface TypeQualifier {
+
+ /**
+ * Describes the kinds of values the qualifier can be applied to. If a
+ * numeric class is provided (e.g., Number.class or Integer.class) then the
+ * annotation can also be applied to the corresponding primitive numeric
+ * types.
+ */
+ Class applicableTo() default Object.class;
+
+}
diff --git a/src/javax/annotation/meta/TypeQualifierDefault.java b/src/javax/annotation/meta/TypeQualifierDefault.java
new file mode 100644
index 0000000..0c8bd52
--- /dev/null
+++ b/src/javax/annotation/meta/TypeQualifierDefault.java
@@ -0,0 +1,20 @@
+package javax.annotation.meta;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * This qualifier is applied to an annotation to denote that the annotation
+ * defines a default type qualifier that is visible within the scope of the
+ * element it is applied to.
+ */
+
+@Documented
+@Target(ElementType.ANNOTATION_TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface TypeQualifierDefault {
+ ElementType[] value() default {};
+}
diff --git a/src/javax/annotation/meta/TypeQualifierNickname.java b/src/javax/annotation/meta/TypeQualifierNickname.java
new file mode 100644
index 0000000..40c9983
--- /dev/null
+++ b/src/javax/annotation/meta/TypeQualifierNickname.java
@@ -0,0 +1,33 @@
+package javax.annotation.meta;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Target;
+
+/**
+ *
+ * This annotation is applied to a annotation, and marks the annotation as being
+ * a qualifier nickname. Applying a nickname annotation X to a element Y should
+ * be interpreted as having the same meaning as applying all of annotations of X
+ * (other than QualifierNickname) to Y.
+ *
+ *
+ * Thus, you might define a qualifier SocialSecurityNumber as follows:
+ *
+ *
+ *
+ *
+ @Documented
+ @TypeQualifierNickname @Pattern("[0-9]{3}-[0-9]{2}-[0-9]{4}")
+ @Retention(RetentionPolicy.RUNTIME)
+ public @interface SocialSecurityNumber {
+ }
+
+ *
+ *
+ */
+@Documented
+@Target(ElementType.ANNOTATION_TYPE)
+public @interface TypeQualifierNickname {
+
+}
diff --git a/src/javax/annotation/meta/TypeQualifierValidator.java b/src/javax/annotation/meta/TypeQualifierValidator.java
new file mode 100644
index 0000000..8053011
--- /dev/null
+++ b/src/javax/annotation/meta/TypeQualifierValidator.java
@@ -0,0 +1,21 @@
+package javax.annotation.meta;
+
+import java.lang.annotation.Annotation;
+
+import javax.annotation.Nonnull;
+
+public interface TypeQualifierValidator {
+ /**
+ * Given a type qualifier, check to see if a known specific constant value
+ * is an instance of the set of values denoted by the qualifier.
+ *
+ * @param annotation
+ * the type qualifier
+ * @param value
+ * the value to check
+ * @return a value indicating whether or not the value is an member of the
+ * values denoted by the type qualifier
+ */
+ public @Nonnull
+ When forConstantValue(@Nonnull A annotation, Object value);
+}
diff --git a/src/javax/annotation/meta/When.java b/src/javax/annotation/meta/When.java
new file mode 100644
index 0000000..ec8a1bc
--- /dev/null
+++ b/src/javax/annotation/meta/When.java
@@ -0,0 +1,23 @@
+package javax.annotation.meta;
+
+/**
+ * Used to describe the relationship between a qualifier T and the set of values
+ * S possible on an annotated element.
+ *
+ * In particular, an issues should be reported if an ALWAYS or MAYBE value is
+ * used where a NEVER value is required, or if a NEVER or MAYBE value is used
+ * where an ALWAYS value is required.
+ *
+ *
+ */
+public enum When {
+ /** S is a subset of T */
+ ALWAYS,
+ /** nothing definitive is known about the relation between S and T */
+ UNKNOWN,
+ /** S intersection T is non empty and S - T is nonempty */
+ MAYBE,
+ /** S intersection T is empty */
+ NEVER;
+
+}
diff --git a/src/org/jf/baksmali/Adaptors/AnnotationFormatter.java b/src/org/jf/baksmali/Adaptors/AnnotationFormatter.java
new file mode 100644
index 0000000..2b9614f
--- /dev/null
+++ b/src/org/jf/baksmali/Adaptors/AnnotationFormatter.java
@@ -0,0 +1,65 @@
+/*
+ * [The "BSD licence"]
+ * Copyright (c) 2010 Ben Gruver (JesusFreke)
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.baksmali.Adaptors;
+
+import org.jf.baksmali.Adaptors.EncodedValue.AnnotationEncodedValueAdaptor;
+import org.jf.dexlib2.AnnotationVisibility;
+import org.jf.dexlib2.iface.Annotation;
+import org.jf.util.IndentingWriter;
+
+import java.io.IOException;
+import java.util.Collection;
+
+public class AnnotationFormatter {
+
+ public static void writeTo(IndentingWriter writer,
+ Collection annotations) throws IOException {
+ boolean first = true;
+ for (Annotation annotation: annotations) {
+ if (!first) {
+ writer.write('\n');
+ }
+ first = false;
+
+ writeTo(writer, annotation);
+ }
+ }
+
+ public static void writeTo(IndentingWriter writer, Annotation annotation) throws IOException {
+ writer.write(".annotation ");
+ writer.write(AnnotationVisibility.getVisibility(annotation.getVisibility()));
+ writer.write(' ');
+ writer.write(annotation.getType());
+ writer.write('\n');
+
+ AnnotationEncodedValueAdaptor.writeElementsTo(writer, annotation.getElements());
+
+ writer.write(".end annotation\n");
+ }
+}
diff --git a/src/org/jf/baksmali/Adaptors/BlankMethodItem.java b/src/org/jf/baksmali/Adaptors/BlankMethodItem.java
new file mode 100644
index 0000000..d007849
--- /dev/null
+++ b/src/org/jf/baksmali/Adaptors/BlankMethodItem.java
@@ -0,0 +1,48 @@
+/*
+ * [The "BSD licence"]
+ * Copyright (c) 2010 Ben Gruver (JesusFreke)
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.baksmali.Adaptors;
+
+import org.jf.util.IndentingWriter;
+
+//a "spacer" between instructions
+public class BlankMethodItem extends MethodItem {
+ public BlankMethodItem(int codeAddress) {
+ super(codeAddress);
+ }
+
+ public double getSortOrder() {
+ return Integer.MAX_VALUE;
+ }
+
+ public boolean writeTo(IndentingWriter writer) {
+ //we didn't technically print something, but returning true indicates that a newline should be printed
+ //after this method item, which is the intended functionality
+ return true;
+ }
+}
diff --git a/src/org/jf/baksmali/Adaptors/CatchMethodItem.java b/src/org/jf/baksmali/Adaptors/CatchMethodItem.java
new file mode 100644
index 0000000..6c67d4a
--- /dev/null
+++ b/src/org/jf/baksmali/Adaptors/CatchMethodItem.java
@@ -0,0 +1,97 @@
+/*
+ * [The "BSD licence"]
+ * Copyright (c) 2010 Ben Gruver (JesusFreke)
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.baksmali.Adaptors;
+
+import org.jf.baksmali.baksmaliOptions;
+import org.jf.util.IndentingWriter;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import java.io.IOException;
+
+public class CatchMethodItem extends MethodItem {
+ private final String exceptionType;
+
+ private final LabelMethodItem tryStartLabel;
+ private final LabelMethodItem tryEndLabel;
+ private final LabelMethodItem handlerLabel;
+
+ public CatchMethodItem(@Nonnull baksmaliOptions options, @Nonnull MethodDefinition.LabelCache labelCache,
+ int codeAddress, @Nullable String exceptionType, int startAddress, int endAddress,
+ int handlerAddress) {
+ super(codeAddress);
+ this.exceptionType = exceptionType;
+
+ tryStartLabel = labelCache.internLabel(new LabelMethodItem(options, startAddress, "try_start_"));
+
+ //use the address from the last covered instruction, but make the label
+ //name refer to the address of the next instruction
+ tryEndLabel = labelCache.internLabel(new EndTryLabelMethodItem(options, codeAddress, endAddress));
+
+ if (exceptionType == null) {
+ handlerLabel = labelCache.internLabel(new LabelMethodItem(options, handlerAddress, "catchall_"));
+ } else {
+ handlerLabel = labelCache.internLabel(new LabelMethodItem(options, handlerAddress, "catch_"));
+ }
+ }
+
+ public LabelMethodItem getTryStartLabel() {
+ return tryStartLabel;
+ }
+
+ public LabelMethodItem getTryEndLabel() {
+ return tryEndLabel;
+ }
+
+ public LabelMethodItem getHandlerLabel() {
+ return handlerLabel;
+ }
+
+ public double getSortOrder() {
+ //sort after instruction and end_try label
+ return 102;
+ }
+
+ @Override
+ public boolean writeTo(IndentingWriter writer) throws IOException {
+ if (exceptionType == null) {
+ writer.write(".catchall");
+ } else {
+ writer.write(".catch ");
+ writer.write(exceptionType);
+ }
+ writer.write(" {");
+ tryStartLabel.writeTo(writer);
+ writer.write(" .. ");
+ tryEndLabel.writeTo(writer);
+ writer.write("} ");
+ handlerLabel.writeTo(writer);
+ return true;
+ }
+}
diff --git a/src/org/jf/baksmali/Adaptors/ClassDefinition.java b/src/org/jf/baksmali/Adaptors/ClassDefinition.java
new file mode 100644
index 0000000..a4eb691
--- /dev/null
+++ b/src/org/jf/baksmali/Adaptors/ClassDefinition.java
@@ -0,0 +1,326 @@
+/*
+ * [The "BSD licence"]
+ * Copyright (c) 2010 Ben Gruver (JesusFreke)
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.baksmali.Adaptors;
+
+import com.google.common.collect.Lists;
+import org.jf.baksmali.baksmaliOptions;
+import org.jf.dexlib2.AccessFlags;
+import org.jf.dexlib2.dexbacked.DexBackedClassDef;
+import org.jf.dexlib2.dexbacked.DexBackedDexFile.InvalidItemIndex;
+import org.jf.dexlib2.iface.*;
+import org.jf.dexlib2.iface.instruction.Instruction;
+import org.jf.dexlib2.iface.instruction.formats.Instruction21c;
+import org.jf.dexlib2.iface.reference.FieldReference;
+import org.jf.dexlib2.util.ReferenceUtil;
+import org.jf.util.IndentingWriter;
+import org.jf.util.StringUtils;
+
+import javax.annotation.Nonnull;
+import java.io.IOException;
+import java.util.*;
+
+public class ClassDefinition {
+ @Nonnull public final baksmaliOptions options;
+ @Nonnull public final ClassDef classDef;
+ @Nonnull private final HashSet fieldsSetInStaticConstructor;
+
+ protected boolean validationErrors;
+
+ public ClassDefinition(@Nonnull baksmaliOptions options, @Nonnull ClassDef classDef) {
+ this.options = options;
+ this.classDef = classDef;
+ fieldsSetInStaticConstructor = findFieldsSetInStaticConstructor();
+ }
+
+ public boolean hadValidationErrors() {
+ return validationErrors;
+ }
+
+ @Nonnull
+ private HashSet findFieldsSetInStaticConstructor() {
+ HashSet fieldsSetInStaticConstructor = new HashSet();
+
+ for (Method method: classDef.getDirectMethods()) {
+ if (method.getName().equals("")) {
+ MethodImplementation impl = method.getImplementation();
+ if (impl != null) {
+ for (Instruction instruction: impl.getInstructions()) {
+ switch (instruction.getOpcode()) {
+ case SPUT:
+ case SPUT_BOOLEAN:
+ case SPUT_BYTE:
+ case SPUT_CHAR:
+ case SPUT_OBJECT:
+ case SPUT_SHORT:
+ case SPUT_WIDE: {
+ Instruction21c ins = (Instruction21c)instruction;
+ FieldReference fieldRef = null;
+ try {
+ fieldRef = (FieldReference)ins.getReference();
+ } catch (InvalidItemIndex ex) {
+ // just ignore it for now. We'll deal with it later, when processing the instructions
+ // themselves
+ }
+ if (fieldRef != null &&
+ fieldRef.getDefiningClass().equals((classDef.getType()))) {
+ fieldsSetInStaticConstructor.add(ReferenceUtil.getShortFieldDescriptor(fieldRef));
+ }
+ break;
+ }
+ }
+ }
+ }
+ }
+ }
+ return fieldsSetInStaticConstructor;
+ }
+
+ public void writeTo(IndentingWriter writer) throws IOException {
+ writeClass(writer);
+ writeSuper(writer);
+ writeSourceFile(writer);
+ writeInterfaces(writer);
+ writeAnnotations(writer);
+ Set staticFields = writeStaticFields(writer);
+ writeInstanceFields(writer, staticFields);
+ Set directMethods = writeDirectMethods(writer);
+ writeVirtualMethods(writer, directMethods);
+ }
+
+ private void writeClass(IndentingWriter writer) throws IOException {
+ writer.write(".class ");
+ writeAccessFlags(writer);
+ writer.write(classDef.getType());
+ writer.write('\n');
+ }
+
+ private void writeAccessFlags(IndentingWriter writer) throws IOException {
+ for (AccessFlags accessFlag: AccessFlags.getAccessFlagsForClass(classDef.getAccessFlags())) {
+ writer.write(accessFlag.toString());
+ writer.write(' ');
+ }
+ }
+
+ private void writeSuper(IndentingWriter writer) throws IOException {
+ String superClass = classDef.getSuperclass();
+ if (superClass != null) {
+ writer.write(".super ");
+ writer.write(superClass);
+ writer.write('\n');
+ }
+ }
+
+ private void writeSourceFile(IndentingWriter writer) throws IOException {
+ String sourceFile = classDef.getSourceFile();
+ if (sourceFile != null) {
+ writer.write(".source \"");
+ StringUtils.writeEscapedString(writer, sourceFile);
+ writer.write("\"\n");
+ }
+ }
+
+ private void writeInterfaces(IndentingWriter writer) throws IOException {
+ List interfaces = Lists.newArrayList(classDef.getInterfaces());
+ Collections.sort(interfaces);
+
+ if (interfaces.size() != 0) {
+ writer.write('\n');
+ writer.write("# interfaces\n");
+ for (String interfaceName: interfaces) {
+ writer.write(".implements ");
+ writer.write(interfaceName);
+ writer.write('\n');
+ }
+ }
+ }
+
+ private void writeAnnotations(IndentingWriter writer) throws IOException {
+ Collection classAnnotations = classDef.getAnnotations();
+ if (classAnnotations.size() != 0) {
+ writer.write("\n\n");
+ writer.write("# annotations\n");
+ AnnotationFormatter.writeTo(writer, classAnnotations);
+ }
+ }
+
+ private Set writeStaticFields(IndentingWriter writer) throws IOException {
+ boolean wroteHeader = false;
+ Set writtenFields = new HashSet();
+
+ Iterable staticFields;
+ if (classDef instanceof DexBackedClassDef) {
+ staticFields = ((DexBackedClassDef)classDef).getStaticFields(false);
+ } else {
+ staticFields = classDef.getStaticFields();
+ }
+
+ for (Field field: staticFields) {
+ if (!wroteHeader) {
+ writer.write("\n\n");
+ writer.write("# static fields");
+ wroteHeader = true;
+ }
+ writer.write('\n');
+
+ boolean setInStaticConstructor;
+ IndentingWriter fieldWriter = writer;
+ String fieldString = ReferenceUtil.getShortFieldDescriptor(field);
+ if (!writtenFields.add(fieldString)) {
+ writer.write("# duplicate field ignored\n");
+ fieldWriter = new CommentingIndentingWriter(writer);
+ System.err.println(String.format("Ignoring duplicate field: %s->%s", classDef.getType(), fieldString));
+ setInStaticConstructor = false;
+ } else {
+ setInStaticConstructor = fieldsSetInStaticConstructor.contains(fieldString);
+ }
+ FieldDefinition.writeTo(fieldWriter, field, setInStaticConstructor);
+ }
+ return writtenFields;
+ }
+
+ private void writeInstanceFields(IndentingWriter writer, Set staticFields) throws IOException {
+ boolean wroteHeader = false;
+ Set writtenFields = new HashSet();
+
+ Iterable instanceFields;
+ if (classDef instanceof DexBackedClassDef) {
+ instanceFields = ((DexBackedClassDef)classDef).getInstanceFields(false);
+ } else {
+ instanceFields = classDef.getInstanceFields();
+ }
+
+ for (Field field: instanceFields) {
+ if (!wroteHeader) {
+ writer.write("\n\n");
+ writer.write("# instance fields");
+ wroteHeader = true;
+ }
+ writer.write('\n');
+
+ IndentingWriter fieldWriter = writer;
+ String fieldString = ReferenceUtil.getShortFieldDescriptor(field);
+ if (!writtenFields.add(fieldString)) {
+ writer.write("# duplicate field ignored\n");
+ fieldWriter = new CommentingIndentingWriter(writer);
+ System.err.println(String.format("Ignoring duplicate field: %s->%s", classDef.getType(), fieldString));
+ } else if (staticFields.contains(fieldString)) {
+ System.err.println(String.format("Duplicate static+instance field found: %s->%s",
+ classDef.getType(), fieldString));
+ System.err.println("You will need to rename one of these fields, including all references.");
+
+ writer.write("# There is both a static and instance field with this signature.\n" +
+ "# You will need to rename one of these fields, including all references.\n");
+ }
+ FieldDefinition.writeTo(fieldWriter, field, false);
+ }
+ }
+
+ private Set writeDirectMethods(IndentingWriter writer) throws IOException {
+ boolean wroteHeader = false;
+ Set writtenMethods = new HashSet();
+
+ Iterable directMethods;
+ if (classDef instanceof DexBackedClassDef) {
+ directMethods = ((DexBackedClassDef)classDef).getDirectMethods(false);
+ } else {
+ directMethods = classDef.getDirectMethods();
+ }
+
+ for (Method method: directMethods) {
+ if (!wroteHeader) {
+ writer.write("\n\n");
+ writer.write("# direct methods");
+ wroteHeader = true;
+ }
+ writer.write('\n');
+
+ // TODO: check for method validation errors
+ String methodString = ReferenceUtil.getShortMethodDescriptor(method);
+
+ IndentingWriter methodWriter = writer;
+ if (!writtenMethods.add(methodString)) {
+ writer.write("# duplicate method ignored\n");
+ methodWriter = new CommentingIndentingWriter(writer);
+ }
+
+ MethodImplementation methodImpl = method.getImplementation();
+ if (methodImpl == null) {
+ MethodDefinition.writeEmptyMethodTo(methodWriter, method, options);
+ } else {
+ MethodDefinition methodDefinition = new MethodDefinition(this, method, methodImpl);
+ methodDefinition.writeTo(methodWriter);
+ }
+ }
+ return writtenMethods;
+ }
+
+ private void writeVirtualMethods(IndentingWriter writer, Set directMethods) throws IOException {
+ boolean wroteHeader = false;
+ Set writtenMethods = new HashSet();
+
+ Iterable virtualMethods;
+ if (classDef instanceof DexBackedClassDef) {
+ virtualMethods = ((DexBackedClassDef)classDef).getVirtualMethods(false);
+ } else {
+ virtualMethods = classDef.getVirtualMethods();
+ }
+
+ for (Method method: virtualMethods) {
+ if (!wroteHeader) {
+ writer.write("\n\n");
+ writer.write("# virtual methods");
+ wroteHeader = true;
+ }
+ writer.write('\n');
+
+ // TODO: check for method validation errors
+ String methodString = ReferenceUtil.getShortMethodDescriptor(method);
+
+ IndentingWriter methodWriter = writer;
+ if (!writtenMethods.add(methodString)) {
+ writer.write("# duplicate method ignored\n");
+ methodWriter = new CommentingIndentingWriter(writer);
+ } else if (directMethods.contains(methodString)) {
+ writer.write("# There is both a direct and virtual method with this signature.\n" +
+ "# You will need to rename one of these methods, including all references.\n");
+ System.err.println(String.format("Duplicate direct+virtual method found: %s->%s",
+ classDef.getType(), methodString));
+ System.err.println("You will need to rename one of these methods, including all references.");
+ }
+
+ MethodImplementation methodImpl = method.getImplementation();
+ if (methodImpl == null) {
+ MethodDefinition.writeEmptyMethodTo(methodWriter, method, options);
+ } else {
+ MethodDefinition methodDefinition = new MethodDefinition(this, method, methodImpl);
+ methodDefinition.writeTo(methodWriter);
+ }
+ }
+ }
+}
diff --git a/src/org/jf/baksmali/Adaptors/CommentMethodItem.java b/src/org/jf/baksmali/Adaptors/CommentMethodItem.java
new file mode 100644
index 0000000..8ac4396
--- /dev/null
+++ b/src/org/jf/baksmali/Adaptors/CommentMethodItem.java
@@ -0,0 +1,55 @@
+/*
+ * [The "BSD licence"]
+ * Copyright (c) 2010 Ben Gruver (JesusFreke)
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.baksmali.Adaptors;
+
+import org.jf.util.IndentingWriter;
+
+import java.io.IOException;
+
+public class CommentMethodItem extends MethodItem {
+ //private final StringTemplate template;
+ private final String comment;
+ private final double sortOrder;
+
+ public CommentMethodItem(String comment, int codeAddress, double sortOrder) {
+ super(codeAddress);
+ this.comment = comment;
+ this.sortOrder = sortOrder;
+ }
+
+ public double getSortOrder() {
+ return sortOrder;
+ }
+
+ public boolean writeTo(IndentingWriter writer) throws IOException {
+ writer.write('#');
+ writer.write(comment);
+ return true;
+ }
+}
diff --git a/src/org/jf/baksmali/Adaptors/CommentedOutMethodItem.java b/src/org/jf/baksmali/Adaptors/CommentedOutMethodItem.java
new file mode 100644
index 0000000..aaeb6a6
--- /dev/null
+++ b/src/org/jf/baksmali/Adaptors/CommentedOutMethodItem.java
@@ -0,0 +1,52 @@
+/*
+ * [The "BSD licence"]
+ * Copyright (c) 2010 Ben Gruver (JesusFreke)
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.baksmali.Adaptors;
+
+import org.jf.util.IndentingWriter;
+
+import java.io.IOException;
+
+public class CommentedOutMethodItem extends MethodItem {
+ private final MethodItem commentedOutMethodItem;
+
+ public CommentedOutMethodItem(MethodItem commentedOutMethodItem) {
+ super(commentedOutMethodItem.getCodeAddress());
+ this.commentedOutMethodItem = commentedOutMethodItem;
+ }
+
+ public double getSortOrder() {
+ return commentedOutMethodItem.getSortOrder() + .001;
+ }
+
+ public boolean writeTo(IndentingWriter writer) throws IOException {
+ writer.write('#');
+ commentedOutMethodItem.writeTo(writer);
+ return true;
+ }
+}
diff --git a/src/org/jf/baksmali/Adaptors/CommentingIndentingWriter.java b/src/org/jf/baksmali/Adaptors/CommentingIndentingWriter.java
new file mode 100644
index 0000000..c63da1c
--- /dev/null
+++ b/src/org/jf/baksmali/Adaptors/CommentingIndentingWriter.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright 2013, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ * * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.baksmali.Adaptors;
+
+import org.jf.util.IndentingWriter;
+
+import java.io.IOException;
+import java.io.Writer;
+
+public class CommentingIndentingWriter extends IndentingWriter {
+ public CommentingIndentingWriter(Writer writer) {
+ super(writer);
+ }
+
+ @Override protected void writeIndent() throws IOException {
+ writer.write("# ");
+ super.writeIndent();
+ }
+}
diff --git a/src/org/jf/baksmali/Adaptors/Debug/BeginEpilogueMethodItem.java b/src/org/jf/baksmali/Adaptors/Debug/BeginEpilogueMethodItem.java
new file mode 100644
index 0000000..a1294fc
--- /dev/null
+++ b/src/org/jf/baksmali/Adaptors/Debug/BeginEpilogueMethodItem.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright 2012, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ * * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.baksmali.Adaptors.Debug;
+
+import org.jf.util.IndentingWriter;
+
+import java.io.IOException;
+
+public class BeginEpilogueMethodItem extends DebugMethodItem {
+ public BeginEpilogueMethodItem(int codeAddress, int sortOrder) {
+ super(codeAddress, sortOrder);
+ }
+
+ @Override
+ public boolean writeTo(IndentingWriter writer) throws IOException {
+ writer.write(".prologue");
+ return true;
+ }
+}
diff --git a/src/org/jf/baksmali/Adaptors/Debug/DebugMethodItem.java b/src/org/jf/baksmali/Adaptors/Debug/DebugMethodItem.java
new file mode 100644
index 0000000..86d30f9
--- /dev/null
+++ b/src/org/jf/baksmali/Adaptors/Debug/DebugMethodItem.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright 2012, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ * * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.baksmali.Adaptors.Debug;
+
+import org.jf.baksmali.Adaptors.MethodItem;
+import org.jf.baksmali.Adaptors.RegisterFormatter;
+import org.jf.dexlib2.DebugItemType;
+import org.jf.dexlib2.iface.debug.*;
+import org.jf.util.ExceptionWithContext;
+
+public abstract class DebugMethodItem extends MethodItem {
+ private final int sortOrder;
+
+ protected DebugMethodItem(int codeAddress, int sortOrder) {
+ super(codeAddress);
+ this.sortOrder = sortOrder;
+ }
+
+ @Override public double getSortOrder() { return sortOrder; }
+
+ public static DebugMethodItem build(RegisterFormatter registerFormatter, DebugItem debugItem) {
+ int codeAddress = debugItem.getCodeAddress();
+ switch (debugItem.getDebugItemType()) {
+ case DebugItemType.START_LOCAL:
+ return new StartLocalMethodItem(codeAddress, -1, registerFormatter, (StartLocal)debugItem);
+ case DebugItemType.END_LOCAL:
+ return new EndLocalMethodItem(codeAddress, -1, registerFormatter, (EndLocal)debugItem);
+ case DebugItemType.RESTART_LOCAL:
+ return new RestartLocalMethodItem(codeAddress, -1, registerFormatter, (RestartLocal)debugItem);
+ case DebugItemType.EPILOGUE_BEGIN:
+ return new BeginEpilogueMethodItem(codeAddress, -4);
+ case DebugItemType.PROLOGUE_END:
+ return new EndPrologueMethodItem(codeAddress, -4);
+ case DebugItemType.SET_SOURCE_FILE:
+ return new SetSourceFileMethodItem(codeAddress, -3, (SetSourceFile)debugItem);
+ case DebugItemType.LINE_NUMBER:
+ return new LineNumberMethodItem(codeAddress, -2, (LineNumber)debugItem);
+ default:
+ throw new ExceptionWithContext("Invalid debug item type: %d", debugItem.getDebugItemType());
+ }
+ }
+}
diff --git a/src/org/jf/baksmali/Adaptors/Debug/EndLocalMethodItem.java b/src/org/jf/baksmali/Adaptors/Debug/EndLocalMethodItem.java
new file mode 100644
index 0000000..231e049
--- /dev/null
+++ b/src/org/jf/baksmali/Adaptors/Debug/EndLocalMethodItem.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright 2012, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ * * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.baksmali.Adaptors.Debug;
+
+import org.jf.baksmali.Adaptors.RegisterFormatter;
+import org.jf.dexlib2.iface.debug.EndLocal;
+import org.jf.util.IndentingWriter;
+
+import javax.annotation.Nonnull;
+import java.io.IOException;
+
+public class EndLocalMethodItem extends DebugMethodItem {
+ @Nonnull private final EndLocal endLocal;
+ @Nonnull private final RegisterFormatter registerFormatter;
+
+ public EndLocalMethodItem(int codeAddress, int sortOrder, @Nonnull RegisterFormatter registerFormatter,
+ @Nonnull EndLocal endLocal) {
+ super(codeAddress, sortOrder);
+ this.endLocal = endLocal;
+ this.registerFormatter = registerFormatter;
+ }
+
+ @Override
+ public boolean writeTo(IndentingWriter writer) throws IOException {
+ writer.write(".end local ");
+ registerFormatter.writeTo(writer, endLocal.getRegister());
+
+ String name = endLocal.getName();
+ String type = endLocal.getType();
+ String signature = endLocal.getSignature();
+ if (name != null || type != null || signature != null) {
+ writer.write(" # ");
+ LocalFormatter.writeLocal(writer, name, type, signature);
+ }
+ return true;
+ }
+}
diff --git a/src/org/jf/baksmali/Adaptors/Debug/EndPrologueMethodItem.java b/src/org/jf/baksmali/Adaptors/Debug/EndPrologueMethodItem.java
new file mode 100644
index 0000000..369c38f
--- /dev/null
+++ b/src/org/jf/baksmali/Adaptors/Debug/EndPrologueMethodItem.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright 2012, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ * * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.baksmali.Adaptors.Debug;
+
+import org.jf.util.IndentingWriter;
+
+import java.io.IOException;
+
+public class EndPrologueMethodItem extends DebugMethodItem {
+ public EndPrologueMethodItem(int codeAddress, int sortOrder) {
+ super(codeAddress, sortOrder);
+ }
+
+ @Override
+ public boolean writeTo(IndentingWriter writer) throws IOException {
+ writer.write(".prologue");
+ return true;
+ }
+}
diff --git a/src/org/jf/baksmali/Adaptors/Debug/LineNumberMethodItem.java b/src/org/jf/baksmali/Adaptors/Debug/LineNumberMethodItem.java
new file mode 100644
index 0000000..91473bd
--- /dev/null
+++ b/src/org/jf/baksmali/Adaptors/Debug/LineNumberMethodItem.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright 2012, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ * * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.baksmali.Adaptors.Debug;
+
+import org.jf.dexlib2.iface.debug.LineNumber;
+import org.jf.util.IndentingWriter;
+
+import javax.annotation.Nonnull;
+import java.io.IOException;
+
+public class LineNumberMethodItem extends DebugMethodItem {
+ private final int lineNumber;
+
+ public LineNumberMethodItem(int codeAddress, int sortOrder, @Nonnull LineNumber lineNumber) {
+ super(codeAddress, sortOrder);
+ this.lineNumber = lineNumber.getLineNumber();
+ }
+
+ @Override
+ public boolean writeTo(IndentingWriter writer) throws IOException {
+ writer.write(".line ");
+ writer.printUnsignedIntAsDec(lineNumber);
+ return true;
+ }
+}
diff --git a/src/org/jf/baksmali/Adaptors/Debug/LocalFormatter.java b/src/org/jf/baksmali/Adaptors/Debug/LocalFormatter.java
new file mode 100644
index 0000000..62ed995
--- /dev/null
+++ b/src/org/jf/baksmali/Adaptors/Debug/LocalFormatter.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright 2013, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ * * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.baksmali.Adaptors.Debug;
+
+import org.jf.baksmali.Adaptors.ReferenceFormatter;
+import org.jf.util.IndentingWriter;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import java.io.IOException;
+
+public class LocalFormatter {
+ /**
+ * Writes out the given local info
+ *
+ * The written string will be something like:
+ *
+ * "localVar":Ljava/lang/String;, "SomeSignature"
+ * "localVar":Ljava/lang/String;
+ * "localVar":V, "SomeSignature"
+ * null:Ljava/lang/String;, "SomeSignature"
+ * null:V, "SomeSignature"
+ *
+ * One of name, type or signature must be non-null
+ */
+ public static void writeLocal(@Nonnull IndentingWriter writer, @Nullable String name, @Nullable String type,
+ @Nullable String signature) throws IOException {
+ if (name != null) {
+ ReferenceFormatter.writeStringReference(writer, name);
+ } else {
+ writer.write("null");
+ }
+ writer.write(':');
+ if (type != null) {
+ writer.write(type);
+ } else {
+ writer.write("V");
+ }
+ if (signature != null) {
+ writer.write(", ");
+ ReferenceFormatter.writeStringReference(writer, signature);
+ }
+ }
+}
diff --git a/src/org/jf/baksmali/Adaptors/Debug/RestartLocalMethodItem.java b/src/org/jf/baksmali/Adaptors/Debug/RestartLocalMethodItem.java
new file mode 100644
index 0000000..4461719
--- /dev/null
+++ b/src/org/jf/baksmali/Adaptors/Debug/RestartLocalMethodItem.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright 2012, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ * * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.baksmali.Adaptors.Debug;
+
+import org.jf.baksmali.Adaptors.RegisterFormatter;
+import org.jf.dexlib2.iface.debug.RestartLocal;
+import org.jf.util.IndentingWriter;
+
+import javax.annotation.Nonnull;
+import java.io.IOException;
+
+public class RestartLocalMethodItem extends DebugMethodItem {
+ @Nonnull private final RestartLocal restartLocal;
+ @Nonnull private final RegisterFormatter registerFormatter;
+
+ public RestartLocalMethodItem(int codeAddress, int sortOrder, @Nonnull RegisterFormatter registerFormatter,
+ @Nonnull RestartLocal restartLocal) {
+ super(codeAddress, sortOrder);
+ this.restartLocal = restartLocal;
+ this.registerFormatter = registerFormatter;
+ }
+
+ @Override
+ public boolean writeTo(IndentingWriter writer) throws IOException {
+ writer.write(".restart local ");
+ registerFormatter.writeTo(writer, restartLocal.getRegister());
+
+ String name = restartLocal.getName();
+ String type = restartLocal.getType();
+ String signature = restartLocal.getSignature();
+ if (name != null || type != null || signature != null) {
+ writer.write(" # ");
+ LocalFormatter.writeLocal(writer, name, type, signature);
+ }
+ return true;
+ }
+}
diff --git a/src/org/jf/baksmali/Adaptors/Debug/SetSourceFileMethodItem.java b/src/org/jf/baksmali/Adaptors/Debug/SetSourceFileMethodItem.java
new file mode 100644
index 0000000..faccfdf
--- /dev/null
+++ b/src/org/jf/baksmali/Adaptors/Debug/SetSourceFileMethodItem.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright 2012, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ * * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.baksmali.Adaptors.Debug;
+
+import org.jf.dexlib2.iface.debug.SetSourceFile;
+import org.jf.util.IndentingWriter;
+import org.jf.util.StringUtils;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import java.io.IOException;
+
+public class SetSourceFileMethodItem extends DebugMethodItem {
+ @Nullable private final String sourceFile;
+
+ public SetSourceFileMethodItem(int codeAddress, int sortOrder, @Nonnull SetSourceFile setSourceFile) {
+ super(codeAddress, sortOrder);
+ this.sourceFile = setSourceFile.getSourceFile();
+ }
+
+ @Override
+ public boolean writeTo(IndentingWriter writer) throws IOException {
+ writer.write(".source");
+
+ if (sourceFile != null) {
+ writer.write(" \"");
+ StringUtils.writeEscapedString(writer, sourceFile);
+ writer.write('"');
+ }
+ return true;
+ }
+}
diff --git a/src/org/jf/baksmali/Adaptors/Debug/StartLocalMethodItem.java b/src/org/jf/baksmali/Adaptors/Debug/StartLocalMethodItem.java
new file mode 100644
index 0000000..0cd2d2b
--- /dev/null
+++ b/src/org/jf/baksmali/Adaptors/Debug/StartLocalMethodItem.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright 2012, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ * * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.baksmali.Adaptors.Debug;
+
+import org.jf.baksmali.Adaptors.RegisterFormatter;
+import org.jf.dexlib2.iface.debug.StartLocal;
+import org.jf.util.IndentingWriter;
+
+import javax.annotation.Nonnull;
+import java.io.IOException;
+
+public class StartLocalMethodItem extends DebugMethodItem {
+ @Nonnull private final StartLocal startLocal;
+ @Nonnull private final RegisterFormatter registerFormatter;
+
+ public StartLocalMethodItem(int codeAddress, int sortOrder, @Nonnull RegisterFormatter registerFormatter,
+ @Nonnull StartLocal startLocal) {
+ super(codeAddress, sortOrder);
+ this.startLocal = startLocal;
+ this.registerFormatter = registerFormatter;
+ }
+
+ @Override
+ public boolean writeTo(IndentingWriter writer) throws IOException {
+ writer.write(".local ");
+ registerFormatter.writeTo(writer, startLocal.getRegister());
+
+ String name = startLocal.getName();
+ String type = startLocal.getType();
+ String signature = startLocal.getSignature();
+
+ if (name != null || type != null || signature != null) {
+ writer.write(", ");
+ LocalFormatter.writeLocal(writer, name, type, signature);
+ }
+ return true;
+ }
+}
diff --git a/src/org/jf/baksmali/Adaptors/EncodedValue/AnnotationEncodedValueAdaptor.java b/src/org/jf/baksmali/Adaptors/EncodedValue/AnnotationEncodedValueAdaptor.java
new file mode 100644
index 0000000..66cd506
--- /dev/null
+++ b/src/org/jf/baksmali/Adaptors/EncodedValue/AnnotationEncodedValueAdaptor.java
@@ -0,0 +1,61 @@
+/*
+ * [The "BSD licence"]
+ * Copyright (c) 2010 Ben Gruver (JesusFreke)
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.baksmali.Adaptors.EncodedValue;
+
+import org.jf.dexlib2.iface.AnnotationElement;
+import org.jf.dexlib2.iface.value.AnnotationEncodedValue;
+import org.jf.util.IndentingWriter;
+
+import java.io.IOException;
+import java.util.Collection;
+
+public abstract class AnnotationEncodedValueAdaptor {
+
+ public static void writeTo(IndentingWriter writer, AnnotationEncodedValue annotationEncodedValue)
+ throws IOException {
+ writer.write(".subannotation ");
+ writer.write(annotationEncodedValue.getType());
+ writer.write('\n');
+
+ writeElementsTo(writer, annotationEncodedValue.getElements());
+ writer.write(".end subannotation");
+ }
+
+ public static void writeElementsTo(IndentingWriter writer,
+ Collection annotationElements) throws IOException {
+ writer.indent(4);
+ for (AnnotationElement annotationElement: annotationElements) {
+ writer.write(annotationElement.getName());
+ writer.write(" = ");
+ EncodedValueAdaptor.writeTo(writer, annotationElement.getValue());
+ writer.write('\n');
+ }
+ writer.deindent(4);
+ }
+}
diff --git a/src/org/jf/baksmali/Adaptors/EncodedValue/ArrayEncodedValueAdaptor.java b/src/org/jf/baksmali/Adaptors/EncodedValue/ArrayEncodedValueAdaptor.java
new file mode 100644
index 0000000..8da1b04
--- /dev/null
+++ b/src/org/jf/baksmali/Adaptors/EncodedValue/ArrayEncodedValueAdaptor.java
@@ -0,0 +1,61 @@
+/*
+ * [The "BSD licence"]
+ * Copyright (c) 2010 Ben Gruver (JesusFreke)
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.baksmali.Adaptors.EncodedValue;
+
+import org.jf.util.IndentingWriter;
+import org.jf.dexlib2.iface.value.ArrayEncodedValue;
+import org.jf.dexlib2.iface.value.EncodedValue;
+
+import java.io.IOException;
+import java.util.Collection;
+
+public class ArrayEncodedValueAdaptor {
+ public static void writeTo(IndentingWriter writer, ArrayEncodedValue arrayEncodedValue) throws IOException {
+ writer.write('{');
+ Collection values = arrayEncodedValue.getValue();
+ if (values.size() == 0) {
+ writer.write('}');
+ return;
+ }
+
+ writer.write('\n');
+ writer.indent(4);
+ boolean first = true;
+ for (EncodedValue encodedValue: values) {
+ if (!first) {
+ writer.write(",\n");
+ }
+ first = false;
+
+ EncodedValueAdaptor.writeTo(writer, encodedValue);
+ }
+ writer.deindent(4);
+ writer.write("\n}");
+ }
+}
diff --git a/src/org/jf/baksmali/Adaptors/EncodedValue/EncodedValueAdaptor.java b/src/org/jf/baksmali/Adaptors/EncodedValue/EncodedValueAdaptor.java
new file mode 100644
index 0000000..f4d442e
--- /dev/null
+++ b/src/org/jf/baksmali/Adaptors/EncodedValue/EncodedValueAdaptor.java
@@ -0,0 +1,93 @@
+/*
+ * [The "BSD licence"]
+ * Copyright (c) 2010 Ben Gruver (JesusFreke)
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.baksmali.Adaptors.EncodedValue;
+
+import org.jf.baksmali.Adaptors.ReferenceFormatter;
+import org.jf.dexlib2.ValueType;
+import org.jf.dexlib2.iface.value.*;
+import org.jf.dexlib2.util.ReferenceUtil;
+import org.jf.util.IndentingWriter;
+import org.jf.baksmali.Renderers.*;
+
+import java.io.IOException;
+
+public abstract class EncodedValueAdaptor {
+ public static void writeTo(IndentingWriter writer, EncodedValue encodedValue) throws IOException {
+ switch (encodedValue.getValueType()) {
+ case ValueType.ANNOTATION:
+ AnnotationEncodedValueAdaptor.writeTo(writer, (AnnotationEncodedValue)encodedValue);
+ return;
+ case ValueType.ARRAY:
+ ArrayEncodedValueAdaptor.writeTo(writer, (ArrayEncodedValue)encodedValue);
+ return;
+ case ValueType.BOOLEAN:
+ BooleanRenderer.writeTo(writer, ((BooleanEncodedValue)encodedValue).getValue());
+ return;
+ case ValueType.BYTE:
+ ByteRenderer.writeTo(writer, ((ByteEncodedValue)encodedValue).getValue());
+ return;
+ case ValueType.CHAR:
+ CharRenderer.writeTo(writer, ((CharEncodedValue)encodedValue).getValue());
+ return;
+ case ValueType.DOUBLE:
+ DoubleRenderer.writeTo(writer, ((DoubleEncodedValue)encodedValue).getValue());
+ return;
+ case ValueType.ENUM:
+ writer.write(".enum ");
+ ReferenceUtil.writeFieldDescriptor(writer, ((EnumEncodedValue)encodedValue).getValue());
+ return;
+ case ValueType.FIELD:
+ ReferenceUtil.writeFieldDescriptor(writer, ((FieldEncodedValue)encodedValue).getValue());
+ return;
+ case ValueType.FLOAT:
+ FloatRenderer.writeTo(writer, ((FloatEncodedValue)encodedValue).getValue());
+ return;
+ case ValueType.INT:
+ IntegerRenderer.writeTo(writer, ((IntEncodedValue)encodedValue).getValue());
+ return;
+ case ValueType.LONG:
+ LongRenderer.writeTo(writer, ((LongEncodedValue)encodedValue).getValue());
+ return;
+ case ValueType.METHOD:
+ ReferenceUtil.writeMethodDescriptor(writer, ((MethodEncodedValue)encodedValue).getValue());
+ return;
+ case ValueType.NULL:
+ writer.write("null");
+ return;
+ case ValueType.SHORT:
+ ShortRenderer.writeTo(writer, ((ShortEncodedValue)encodedValue).getValue());
+ return;
+ case ValueType.STRING:
+ ReferenceFormatter.writeStringReference(writer, ((StringEncodedValue)encodedValue).getValue());
+ return;
+ case ValueType.TYPE:
+ writer.write(((TypeEncodedValue)encodedValue).getValue());
+ }
+ }
+}
diff --git a/src/org/jf/baksmali/Adaptors/EndTryLabelMethodItem.java b/src/org/jf/baksmali/Adaptors/EndTryLabelMethodItem.java
new file mode 100644
index 0000000..aed315d
--- /dev/null
+++ b/src/org/jf/baksmali/Adaptors/EndTryLabelMethodItem.java
@@ -0,0 +1,51 @@
+/*
+ * [The "BSD licence"]
+ * Copyright (c) 2010 Ben Gruver (JesusFreke)
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.baksmali.Adaptors;
+
+import org.jf.baksmali.baksmaliOptions;
+
+import javax.annotation.Nonnull;
+
+public class EndTryLabelMethodItem extends LabelMethodItem {
+ private int endTryAddress;
+
+ public EndTryLabelMethodItem(@Nonnull baksmaliOptions options, int codeAddress, int endTryAddress) {
+ super(options, codeAddress, "try_end_");
+ this.endTryAddress = endTryAddress;
+ }
+
+ public double getSortOrder() {
+ //sort after instruction, but before catch directive
+ return 101;
+ }
+
+ public int getLabelAddress() {
+ return endTryAddress;
+ }
+}
diff --git a/src/org/jf/baksmali/Adaptors/FieldDefinition.java b/src/org/jf/baksmali/Adaptors/FieldDefinition.java
new file mode 100644
index 0000000..a71089d
--- /dev/null
+++ b/src/org/jf/baksmali/Adaptors/FieldDefinition.java
@@ -0,0 +1,87 @@
+/*
+ * [The "BSD licence"]
+ * Copyright (c) 2010 Ben Gruver (JesusFreke)
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.baksmali.Adaptors;
+
+import org.jf.baksmali.Adaptors.EncodedValue.EncodedValueAdaptor;
+import org.jf.dexlib2.AccessFlags;
+import org.jf.dexlib2.iface.Annotation;
+import org.jf.dexlib2.iface.Field;
+import org.jf.dexlib2.iface.value.EncodedValue;
+import org.jf.dexlib2.util.EncodedValueUtils;
+import org.jf.util.IndentingWriter;
+
+import java.io.IOException;
+import java.util.Collection;
+
+public class FieldDefinition {
+ public static void writeTo(IndentingWriter writer, Field field, boolean setInStaticConstructor) throws IOException {
+ EncodedValue initialValue = field.getInitialValue();
+ int accessFlags = field.getAccessFlags();
+
+ if (setInStaticConstructor &&
+ AccessFlags.STATIC.isSet(accessFlags) &&
+ AccessFlags.FINAL.isSet(accessFlags) &&
+ initialValue != null) {
+ if (!EncodedValueUtils.isDefaultValue(initialValue)) {
+ writer.write("# The value of this static final field might be set in the static constructor\n");
+ } else {
+ // don't write out the default initial value for static final fields that get set in the static
+ // constructor
+ initialValue = null;
+ }
+ }
+
+ writer.write(".field ");
+ writeAccessFlags(writer, field.getAccessFlags());
+ writer.write(field.getName());
+ writer.write(':');
+ writer.write(field.getType());
+ if (initialValue != null) {
+ writer.write(" = ");
+ EncodedValueAdaptor.writeTo(writer, initialValue);
+ }
+
+ writer.write('\n');
+
+ Collection annotations = field.getAnnotations();
+ if (annotations.size() > 0) {
+ writer.indent(4);
+ AnnotationFormatter.writeTo(writer, annotations);
+ writer.deindent(4);
+ writer.write(".end field\n");
+ }
+ }
+
+ private static void writeAccessFlags(IndentingWriter writer, int accessFlags) throws IOException {
+ for (AccessFlags accessFlag: AccessFlags.getAccessFlagsForField(accessFlags)) {
+ writer.write(accessFlag.toString());
+ writer.write(' ');
+ }
+ }
+}
diff --git a/src/org/jf/baksmali/Adaptors/Format/ArrayDataMethodItem.java b/src/org/jf/baksmali/Adaptors/Format/ArrayDataMethodItem.java
new file mode 100644
index 0000000..1d4957e
--- /dev/null
+++ b/src/org/jf/baksmali/Adaptors/Format/ArrayDataMethodItem.java
@@ -0,0 +1,76 @@
+/*
+ * [The "BSD licence"]
+ * Copyright (c) 2010 Ben Gruver (JesusFreke)
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.baksmali.Adaptors.Format;
+
+import org.jf.baksmali.Adaptors.MethodDefinition;
+import org.jf.baksmali.Renderers.LongRenderer;
+import org.jf.dexlib2.iface.instruction.formats.ArrayPayload;
+import org.jf.util.IndentingWriter;
+
+import java.io.IOException;
+import java.util.List;
+
+public class ArrayDataMethodItem extends InstructionMethodItem {
+ public ArrayDataMethodItem(MethodDefinition methodDef, int codeAddress, ArrayPayload instruction) {
+ super(methodDef, codeAddress, instruction);
+ }
+
+ public boolean writeTo(IndentingWriter writer) throws IOException {
+ int elementWidth = instruction.getElementWidth();
+
+ writer.write(".array-data ");
+ writer.printSignedIntAsDec(instruction.getElementWidth());
+ writer.write('\n');
+
+ writer.indent(4);
+
+ List elements = instruction.getArrayElements();
+
+ String suffix = "";
+ switch (elementWidth) {
+ case 1:
+ suffix = "t";
+ break;
+ case 2:
+ suffix = "s";
+ break;
+ }
+
+ for (Number number: elements) {
+ LongRenderer.writeSignedIntOrLongTo(writer, number.longValue());
+ writer.write(suffix);
+ if (elementWidth == 4)
+ writeResourceId(writer, number.intValue());
+ writer.write("\n");
+ }
+ writer.deindent(4);
+ writer.write(".end array-data");
+ return true;
+ }
+}
diff --git a/src/org/jf/baksmali/Adaptors/Format/InstructionMethodItem.java b/src/org/jf/baksmali/Adaptors/Format/InstructionMethodItem.java
new file mode 100644
index 0000000..300efd8
--- /dev/null
+++ b/src/org/jf/baksmali/Adaptors/Format/InstructionMethodItem.java
@@ -0,0 +1,458 @@
+/*
+ * [The "BSD licence"]
+ * Copyright (c) 2010 Ben Gruver (JesusFreke)
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.baksmali.Adaptors.Format;
+
+import org.jf.baksmali.Adaptors.MethodDefinition;
+import org.jf.baksmali.Adaptors.MethodDefinition.InvalidSwitchPayload;
+import org.jf.baksmali.Adaptors.MethodItem;
+import org.jf.baksmali.Renderers.LongRenderer;
+import org.jf.baksmali.baksmaliOptions;
+import org.jf.dexlib2.Opcode;
+import org.jf.dexlib2.ReferenceType;
+import org.jf.dexlib2.VerificationError;
+import org.jf.dexlib2.dexbacked.DexBackedDexFile.InvalidItemIndex;
+import org.jf.dexlib2.iface.instruction.*;
+import org.jf.dexlib2.iface.instruction.formats.Instruction20bc;
+import org.jf.dexlib2.iface.instruction.formats.Instruction31t;
+import org.jf.dexlib2.iface.instruction.formats.UnknownInstruction;
+import org.jf.dexlib2.iface.reference.Reference;
+import org.jf.dexlib2.util.ReferenceUtil;
+import org.jf.util.ExceptionWithContext;
+import org.jf.util.IndentingWriter;
+
+import javax.annotation.Nonnull;
+import java.io.IOException;
+import java.util.Map;
+
+public class InstructionMethodItem extends MethodItem {
+ @Nonnull protected final MethodDefinition methodDef;
+ @Nonnull protected final T instruction;
+
+ public InstructionMethodItem(@Nonnull MethodDefinition methodDef, int codeAddress, @Nonnull T instruction) {
+ super(codeAddress);
+ this.methodDef = methodDef;
+ this.instruction = instruction;
+ }
+
+ public double getSortOrder() {
+ //instructions should appear after everything except an "end try" label and .catch directive
+ return 100;
+ }
+
+ private boolean isAllowedOdex(@Nonnull Opcode opcode) {
+ baksmaliOptions options = methodDef.classDef.options;
+ if (options.allowOdex) {
+ return true;
+ }
+
+ if (methodDef.classDef.options.apiLevel >= 14) {
+ return false;
+ }
+
+ return opcode.isOdexedInstanceVolatile() || opcode.isOdexedStaticVolatile() ||
+ opcode == Opcode.THROW_VERIFICATION_ERROR;
+ }
+
+ @Override
+ public boolean writeTo(IndentingWriter writer) throws IOException {
+ Opcode opcode = instruction.getOpcode();
+ String verificationErrorName = null;
+ String referenceString = null;
+
+ boolean commentOutInstruction = false;
+
+ if (instruction instanceof Instruction20bc) {
+ int verificationError = ((Instruction20bc)instruction).getVerificationError();
+ verificationErrorName = VerificationError.getVerificationErrorName(verificationError);
+ if (verificationErrorName == null) {
+ writer.write("#was invalid verification error type: ");
+ writer.printSignedIntAsDec(verificationError);
+ writer.write("\n");
+ verificationErrorName = "generic-error";
+ }
+ }
+
+ if (instruction instanceof ReferenceInstruction) {
+ ReferenceInstruction referenceInstruction = (ReferenceInstruction)instruction;
+ try {
+ Reference reference = referenceInstruction.getReference();
+ referenceString = ReferenceUtil.getReferenceString(reference);
+ assert referenceString != null;
+ } catch (InvalidItemIndex ex) {
+ writer.write("#");
+ writer.write(ex.getMessage());
+ writer.write("\n");
+ commentOutInstruction = true;
+
+ referenceString = String.format("%s@%d",
+ ReferenceType.toString(referenceInstruction.getReferenceType()),
+ ex.getInvalidIndex());
+ } catch (ReferenceType.InvalidReferenceTypeException ex) {
+ writer.write("#invalid reference type: ");
+ writer.printSignedIntAsDec(ex.getReferenceType());
+ commentOutInstruction = true;
+
+ referenceString = "invalid_reference";
+ }
+ }
+
+ if (instruction instanceof Instruction31t) {
+ Opcode payloadOpcode;
+ switch (instruction.getOpcode()) {
+ case PACKED_SWITCH:
+ payloadOpcode = Opcode.PACKED_SWITCH_PAYLOAD;
+ break;
+ case SPARSE_SWITCH:
+ payloadOpcode = Opcode.SPARSE_SWITCH_PAYLOAD;
+ break;
+ case FILL_ARRAY_DATA:
+ payloadOpcode = Opcode.ARRAY_PAYLOAD;
+ break;
+ default:
+ throw new ExceptionWithContext("Invalid 31t opcode: %s", instruction.getOpcode());
+ }
+
+ try {
+ methodDef.findSwitchPayload(this.codeAddress + ((Instruction31t)instruction).getCodeOffset(),
+ payloadOpcode);
+ } catch (InvalidSwitchPayload ex) {
+ writer.write("#invalid payload reference");
+ commentOutInstruction = true;
+ }
+ }
+
+ if (opcode.odexOnly()) {
+ if (!isAllowedOdex(opcode)) {
+ writer.write("#disallowed odex opcode\n");
+ commentOutInstruction = true;
+ }
+ }
+
+ if (commentOutInstruction) {
+ writer.write("#");
+ }
+
+ switch (instruction.getOpcode().format) {
+ case Format10t:
+ writeOpcode(writer);
+ writer.write(' ');
+ writeTargetLabel(writer);
+ break;
+ case Format10x:
+ if (instruction instanceof UnknownInstruction) {
+ writer.write("#unknown opcode: 0x");
+ writer.printUnsignedLongAsHex(((UnknownInstruction)instruction).getOriginalOpcode());
+ writer.write('\n');
+ }
+ writeOpcode(writer);
+ break;
+ case Format11n:
+ writeOpcode(writer);
+ writer.write(' ');
+ writeFirstRegister(writer);
+ writer.write(", ");
+ writeLiteral(writer);
+ break;
+ case Format11x:
+ writeOpcode(writer);
+ writer.write(' ');
+ writeFirstRegister(writer);
+ break;
+ case Format12x:
+ writeOpcode(writer);
+ writer.write(' ');
+ writeFirstRegister(writer);
+ writer.write(", ");
+ writeSecondRegister(writer);
+ break;
+ case Format20bc:
+ writeOpcode(writer);
+ writer.write(' ');
+ writer.write(verificationErrorName);
+ writer.write(", ");
+ writer.write(referenceString);
+ break;
+ case Format20t:
+ case Format30t:
+ writeOpcode(writer);
+ writer.write(' ');
+ writeTargetLabel(writer);
+ break;
+ case Format21c:
+ case Format31c:
+ writeOpcode(writer);
+ writer.write(' ');
+ writeFirstRegister(writer);
+ writer.write(", ");
+ writer.write(referenceString);
+ break;
+ case Format21ih:
+ case Format21lh:
+ case Format21s:
+ case Format31i:
+ case Format51l:
+ writeOpcode(writer);
+ writer.write(' ');
+ writeFirstRegister(writer);
+ writer.write(", ");
+ writeLiteral(writer);
+ if (instruction.getOpcode().setsWideRegister() == false)
+ writeResourceId(writer);
+ break;
+ case Format21t:
+ case Format31t:
+ writeOpcode(writer);
+ writer.write(' ');
+ writeFirstRegister(writer);
+ writer.write(", ");
+ writeTargetLabel(writer);
+ break;
+ case Format22b:
+ case Format22s:
+ writeOpcode(writer);
+ writer.write(' ');
+ writeFirstRegister(writer);
+ writer.write(", ");
+ writeSecondRegister(writer);
+ writer.write(", ");
+ writeLiteral(writer);
+ break;
+ case Format22c:
+ writeOpcode(writer);
+ writer.write(' ');
+ writeFirstRegister(writer);
+ writer.write(", ");
+ writeSecondRegister(writer);
+ writer.write(", ");
+ writer.write(referenceString);
+ break;
+ case Format22cs:
+ writeOpcode(writer);
+ writer.write(' ');
+ writeFirstRegister(writer);
+ writer.write(", ");
+ writeSecondRegister(writer);
+ writer.write(", ");
+ writeFieldOffset(writer);
+ break;
+ case Format22t:
+ writeOpcode(writer);
+ writer.write(' ');
+ writeFirstRegister(writer);
+ writer.write(", ");
+ writeSecondRegister(writer);
+ writer.write(", ");
+ writeTargetLabel(writer);
+ break;
+ case Format22x:
+ case Format32x:
+ writeOpcode(writer);
+ writer.write(' ');
+ writeFirstRegister(writer);
+ writer.write(", ");
+ writeSecondRegister(writer);
+ break;
+ case Format23x:
+ writeOpcode(writer);
+ writer.write(' ');
+ writeFirstRegister(writer);
+ writer.write(", ");
+ writeSecondRegister(writer);
+ writer.write(", ");
+ writeThirdRegister(writer);
+ break;
+ case Format35c:
+ writeOpcode(writer);
+ writer.write(' ');
+ writeInvokeRegisters(writer);
+ writer.write(", ");
+ writer.write(referenceString);
+ break;
+ case Format35mi:
+ writeOpcode(writer);
+ writer.write(' ');
+ writeInvokeRegisters(writer);
+ writer.write(", ");
+ writeInlineIndex(writer);
+ break;
+ case Format35ms:
+ writeOpcode(writer);
+ writer.write(' ');
+ writeInvokeRegisters(writer);
+ writer.write(", ");
+ writeVtableIndex(writer);
+ break;
+ case Format3rc:
+ writeOpcode(writer);
+ writer.write(' ');
+ writeInvokeRangeRegisters(writer);
+ writer.write(", ");
+ writer.write(referenceString);
+ break;
+ case Format3rmi:
+ writeOpcode(writer);
+ writer.write(' ');
+ writeInvokeRangeRegisters(writer);
+ writer.write(", ");
+ writeInlineIndex(writer);
+ break;
+ case Format3rms:
+ writeOpcode(writer);
+ writer.write(' ');
+ writeInvokeRangeRegisters(writer);
+ writer.write(", ");
+ writeVtableIndex(writer);
+ break;
+ default:
+ assert false;
+ return false;
+ }
+
+ if (commentOutInstruction) {
+ writer.write("\nnop");
+ }
+
+ return true;
+ }
+
+ protected void writeOpcode(IndentingWriter writer) throws IOException {
+ writer.write(instruction.getOpcode().name);
+ }
+
+ protected void writeTargetLabel(IndentingWriter writer) throws IOException {
+ //this method is overridden by OffsetInstructionMethodItem, and should only be called for the formats that
+ //have a target
+ throw new RuntimeException();
+ }
+
+ protected void writeRegister(IndentingWriter writer, int registerNumber) throws IOException {
+ methodDef.registerFormatter.writeTo(writer, registerNumber);
+ }
+
+ protected void writeFirstRegister(IndentingWriter writer) throws IOException {
+ writeRegister(writer, ((OneRegisterInstruction)instruction).getRegisterA());
+ }
+
+ protected void writeSecondRegister(IndentingWriter writer) throws IOException {
+ writeRegister(writer, ((TwoRegisterInstruction)instruction).getRegisterB());
+ }
+
+ protected void writeThirdRegister(IndentingWriter writer) throws IOException {
+ writeRegister(writer, ((ThreeRegisterInstruction) instruction).getRegisterC());
+ }
+
+ protected void writeInvokeRegisters(IndentingWriter writer) throws IOException {
+ FiveRegisterInstruction instruction = (FiveRegisterInstruction)this.instruction;
+ final int regCount = instruction.getRegisterCount();
+
+ writer.write('{');
+ switch (regCount) {
+ case 1:
+ writeRegister(writer, instruction.getRegisterC());
+ break;
+ case 2:
+ writeRegister(writer, instruction.getRegisterC());
+ writer.write(", ");
+ writeRegister(writer, instruction.getRegisterD());
+ break;
+ case 3:
+ writeRegister(writer, instruction.getRegisterC());
+ writer.write(", ");
+ writeRegister(writer, instruction.getRegisterD());
+ writer.write(", ");
+ writeRegister(writer, instruction.getRegisterE());
+ break;
+ case 4:
+ writeRegister(writer, instruction.getRegisterC());
+ writer.write(", ");
+ writeRegister(writer, instruction.getRegisterD());
+ writer.write(", ");
+ writeRegister(writer, instruction.getRegisterE());
+ writer.write(", ");
+ writeRegister(writer, instruction.getRegisterF());
+ break;
+ case 5:
+ writeRegister(writer, instruction.getRegisterC());
+ writer.write(", ");
+ writeRegister(writer, instruction.getRegisterD());
+ writer.write(", ");
+ writeRegister(writer, instruction.getRegisterE());
+ writer.write(", ");
+ writeRegister(writer, instruction.getRegisterF());
+ writer.write(", ");
+ writeRegister(writer, instruction.getRegisterG());
+ break;
+ }
+ writer.write('}');
+ }
+
+ protected void writeInvokeRangeRegisters(IndentingWriter writer) throws IOException {
+ RegisterRangeInstruction instruction = (RegisterRangeInstruction)this.instruction;
+
+ int regCount = instruction.getRegisterCount();
+ if (regCount == 0) {
+ writer.write("{}");
+ } else {
+ int startRegister = instruction.getStartRegister();
+ methodDef.registerFormatter.writeRegisterRange(writer, startRegister, startRegister+regCount-1);
+ }
+ }
+
+ protected void writeLiteral(IndentingWriter writer) throws IOException {
+ LongRenderer.writeSignedIntOrLongTo(writer, ((WideLiteralInstruction)instruction).getWideLiteral());
+ }
+
+ protected void writeResourceId(IndentingWriter writer) throws IOException {
+ writeResourceId(writer, ((NarrowLiteralInstruction)instruction).getNarrowLiteral());
+ }
+
+ protected void writeResourceId(IndentingWriter writer, int val) throws IOException {
+ Map resourceIds = methodDef.classDef.options.resourceIds;
+ String resource = resourceIds.get(Integer.valueOf(val));
+ if (resource != null) {
+ writer.write(" # ");
+ writer.write(resource);
+ }
+ }
+
+ protected void writeFieldOffset(IndentingWriter writer) throws IOException {
+ writer.write("field@0x");
+ writer.printUnsignedLongAsHex(((FieldOffsetInstruction)instruction).getFieldOffset());
+ }
+
+ protected void writeInlineIndex(IndentingWriter writer) throws IOException {
+ writer.write("inline@");
+ writer.printSignedIntAsDec(((InlineIndexInstruction)instruction).getInlineIndex());
+ }
+
+ protected void writeVtableIndex(IndentingWriter writer) throws IOException {
+ writer.write("vtable@");
+ writer.printSignedIntAsDec(((VtableIndexInstruction)instruction).getVtableIndex());
+ }
+}
diff --git a/src/org/jf/baksmali/Adaptors/Format/InstructionMethodItemFactory.java b/src/org/jf/baksmali/Adaptors/Format/InstructionMethodItemFactory.java
new file mode 100644
index 0000000..429cb69
--- /dev/null
+++ b/src/org/jf/baksmali/Adaptors/Format/InstructionMethodItemFactory.java
@@ -0,0 +1,67 @@
+/*
+ * [The "BSD licence"]
+ * Copyright (c) 2010 Ben Gruver (JesusFreke)
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.baksmali.Adaptors.Format;
+
+import org.jf.baksmali.Adaptors.MethodDefinition;
+import org.jf.dexlib2.analysis.UnresolvedOdexInstruction;
+import org.jf.dexlib2.iface.instruction.Instruction;
+import org.jf.dexlib2.iface.instruction.OffsetInstruction;
+import org.jf.dexlib2.iface.instruction.formats.ArrayPayload;
+import org.jf.dexlib2.iface.instruction.formats.PackedSwitchPayload;
+import org.jf.dexlib2.iface.instruction.formats.SparseSwitchPayload;
+
+public class InstructionMethodItemFactory {
+ private InstructionMethodItemFactory() {
+ }
+
+ public static InstructionMethodItem makeInstructionFormatMethodItem(
+ MethodDefinition methodDef, int codeAddress, Instruction instruction) {
+
+ if (instruction instanceof OffsetInstruction) {
+ return new OffsetInstructionFormatMethodItem(methodDef.classDef.options, methodDef, codeAddress,
+ (OffsetInstruction)instruction);
+ }
+
+ if (instruction instanceof UnresolvedOdexInstruction) {
+ return new UnresolvedOdexInstructionMethodItem(methodDef, codeAddress,
+ (UnresolvedOdexInstruction)instruction);
+ }
+
+ switch (instruction.getOpcode().format) {
+ case ArrayPayload:
+ return new ArrayDataMethodItem(methodDef, codeAddress, (ArrayPayload)instruction);
+ case PackedSwitchPayload:
+ return new PackedSwitchMethodItem(methodDef, codeAddress, (PackedSwitchPayload)instruction);
+ case SparseSwitchPayload:
+ return new SparseSwitchMethodItem(methodDef, codeAddress, (SparseSwitchPayload)instruction);
+ default:
+ return new InstructionMethodItem(methodDef, codeAddress, instruction);
+ }
+ }
+}
diff --git a/src/org/jf/baksmali/Adaptors/Format/OffsetInstructionFormatMethodItem.java b/src/org/jf/baksmali/Adaptors/Format/OffsetInstructionFormatMethodItem.java
new file mode 100644
index 0000000..3ffb4bd
--- /dev/null
+++ b/src/org/jf/baksmali/Adaptors/Format/OffsetInstructionFormatMethodItem.java
@@ -0,0 +1,85 @@
+/*
+ * [The "BSD licence"]
+ * Copyright (c) 2010 Ben Gruver (JesusFreke)
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.baksmali.Adaptors.Format;
+
+import org.jf.baksmali.Adaptors.LabelMethodItem;
+import org.jf.baksmali.Adaptors.MethodDefinition;
+import org.jf.baksmali.baksmaliOptions;
+import org.jf.dexlib2.Opcode;
+import org.jf.dexlib2.iface.instruction.OffsetInstruction;
+import org.jf.util.IndentingWriter;
+
+import javax.annotation.Nonnull;
+import java.io.IOException;
+
+public class OffsetInstructionFormatMethodItem extends InstructionMethodItem {
+ protected LabelMethodItem label;
+
+ public OffsetInstructionFormatMethodItem(@Nonnull baksmaliOptions options, @Nonnull MethodDefinition methodDef,
+ int codeAddress, OffsetInstruction instruction) {
+ super(methodDef, codeAddress, instruction);
+
+ label = new LabelMethodItem(options, codeAddress + instruction.getCodeOffset(), getLabelPrefix());
+ label = methodDef.getLabelCache().internLabel(label);
+ }
+
+ @Override
+ protected void writeTargetLabel(IndentingWriter writer) throws IOException {
+ label.writeTo(writer);
+ }
+
+ public LabelMethodItem getLabel() {
+ return label;
+ }
+
+ private String getLabelPrefix() {
+ Opcode opcode = instruction.getOpcode();
+ switch (opcode.format) {
+ case Format10t:
+ case Format20t:
+ case Format30t:
+ return "goto_";
+ case Format21t:
+ case Format22t:
+ return "cond_";
+ case Format31t:
+ if (opcode == Opcode.FILL_ARRAY_DATA) {
+ return "array_";
+ }
+ if (opcode == Opcode.PACKED_SWITCH) {
+ return "pswitch_data_";
+ }
+ // Opcode.SPARSE_SWITCH;
+ return "sswitch_data_";
+ }
+
+ assert false;
+ return null;
+ }
+}
diff --git a/src/org/jf/baksmali/Adaptors/Format/PackedSwitchMethodItem.java b/src/org/jf/baksmali/Adaptors/Format/PackedSwitchMethodItem.java
new file mode 100644
index 0000000..5d7dea7
--- /dev/null
+++ b/src/org/jf/baksmali/Adaptors/Format/PackedSwitchMethodItem.java
@@ -0,0 +1,123 @@
+/*
+ * [The "BSD licence"]
+ * Copyright (c) 2010 Ben Gruver (JesusFreke)
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.baksmali.Adaptors.Format;
+
+import org.jf.baksmali.Adaptors.LabelMethodItem;
+import org.jf.baksmali.Adaptors.MethodDefinition;
+import org.jf.dexlib2.iface.instruction.SwitchElement;
+import org.jf.dexlib2.iface.instruction.formats.PackedSwitchPayload;
+import org.jf.util.IndentingWriter;
+import org.jf.baksmali.Renderers.IntegerRenderer;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+public class PackedSwitchMethodItem extends InstructionMethodItem {
+ private final List targets;
+ private final int firstKey;
+
+ public PackedSwitchMethodItem(MethodDefinition methodDef, int codeAddress, PackedSwitchPayload instruction) {
+ super(methodDef, codeAddress, instruction);
+
+ int baseCodeAddress = methodDef.getPackedSwitchBaseAddress(codeAddress);
+
+ targets = new ArrayList();
+
+ boolean first = true;
+ //TODO: does dalvik allow switc payloads with no cases?
+ int firstKey = 0;
+ if (baseCodeAddress >= 0) {
+ for (SwitchElement switchElement: instruction.getSwitchElements()) {
+ if (first) {
+ firstKey = switchElement.getKey();
+ first = false;
+ }
+ LabelMethodItem label = methodDef.getLabelCache().internLabel(
+ new LabelMethodItem(methodDef.classDef.options, baseCodeAddress + switchElement.getOffset(),
+ "pswitch_"));
+ targets.add(new PackedSwitchLabelTarget(label));
+ }
+ } else {
+ for (SwitchElement switchElement: instruction.getSwitchElements()) {
+ if (first) {
+ firstKey = switchElement.getKey();
+ first = false;
+ }
+ targets.add(new PackedSwitchOffsetTarget(switchElement.getOffset()));
+ }
+ }
+ this.firstKey = firstKey;
+ }
+
+ @Override
+ public boolean writeTo(IndentingWriter writer) throws IOException {
+ writer.write(".packed-switch ");
+ IntegerRenderer.writeTo(writer, firstKey);
+ writer.indent(4);
+ writer.write('\n');
+ int key = firstKey;
+ for (PackedSwitchTarget target: targets) {
+ target.writeTargetTo(writer);
+ writeResourceId(writer, key);
+ writer.write('\n');
+ key++;
+ }
+ writer.deindent(4);
+ writer.write(".end packed-switch");
+ return true;
+ }
+
+ private static abstract class PackedSwitchTarget {
+ public abstract void writeTargetTo(IndentingWriter writer) throws IOException;
+ }
+
+ private static class PackedSwitchLabelTarget extends PackedSwitchTarget {
+ private final LabelMethodItem target;
+ public PackedSwitchLabelTarget(LabelMethodItem target) {
+ this.target = target;
+ }
+ public void writeTargetTo(IndentingWriter writer) throws IOException {
+ target.writeTo(writer);
+ }
+ }
+
+ private static class PackedSwitchOffsetTarget extends PackedSwitchTarget {
+ private final int target;
+ public PackedSwitchOffsetTarget(int target) {
+ this.target = target;
+ }
+ public void writeTargetTo(IndentingWriter writer) throws IOException {
+ if (target >= 0) {
+ writer.write('+');
+ }
+ writer.printSignedIntAsDec(target);
+ }
+ }
+}
diff --git a/src/org/jf/baksmali/Adaptors/Format/SparseSwitchMethodItem.java b/src/org/jf/baksmali/Adaptors/Format/SparseSwitchMethodItem.java
new file mode 100644
index 0000000..0dee84a
--- /dev/null
+++ b/src/org/jf/baksmali/Adaptors/Format/SparseSwitchMethodItem.java
@@ -0,0 +1,117 @@
+/*
+ * [The "BSD licence"]
+ * Copyright (c) 2010 Ben Gruver (JesusFreke)
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.baksmali.Adaptors.Format;
+
+import org.jf.baksmali.Adaptors.LabelMethodItem;
+import org.jf.baksmali.Adaptors.MethodDefinition;
+import org.jf.dexlib2.iface.instruction.SwitchElement;
+import org.jf.dexlib2.iface.instruction.formats.SparseSwitchPayload;
+import org.jf.util.IndentingWriter;
+import org.jf.baksmali.Renderers.IntegerRenderer;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+public class SparseSwitchMethodItem extends InstructionMethodItem {
+ private final List targets;
+
+ public SparseSwitchMethodItem(MethodDefinition methodDef, int codeAddress, SparseSwitchPayload instruction) {
+ super(methodDef, codeAddress, instruction);
+
+ int baseCodeAddress = methodDef.getSparseSwitchBaseAddress(codeAddress);
+
+ targets = new ArrayList();
+ if (baseCodeAddress >= 0) {
+ for (SwitchElement switchElement: instruction.getSwitchElements()) {
+ LabelMethodItem label = methodDef.getLabelCache().internLabel(
+ new LabelMethodItem( methodDef.classDef.options, baseCodeAddress + switchElement.getOffset(),
+ "sswitch_"));
+ targets.add(new SparseSwitchLabelTarget(switchElement.getKey(), label));
+ }
+ } else {
+ //if we couldn't determine a base address, just use relative offsets rather than labels
+ for (SwitchElement switchElement: instruction.getSwitchElements()) {
+ targets.add(new SparseSwitchOffsetTarget(switchElement.getKey(), switchElement.getOffset()));
+ }
+ }
+ }
+
+ @Override
+ public boolean writeTo(IndentingWriter writer) throws IOException {
+ writer.write(".sparse-switch\n");
+ writer.indent(4);
+ for (SparseSwitchTarget target: targets) {
+ IntegerRenderer.writeTo(writer, target.getKey());
+ writer.write(" -> ");
+ target.writeTargetTo(writer);
+ writeResourceId(writer, target.getKey());
+ writer.write('\n');
+ }
+ writer.deindent(4);
+ writer.write(".end sparse-switch");
+ return true;
+ }
+
+ private static abstract class SparseSwitchTarget {
+ private final int key;
+ public SparseSwitchTarget(int key) {
+ this.key = key;
+ }
+ public int getKey() { return key; }
+ public abstract void writeTargetTo(IndentingWriter writer) throws IOException;
+ }
+
+ private static class SparseSwitchLabelTarget extends SparseSwitchTarget {
+ private final LabelMethodItem target;
+ public SparseSwitchLabelTarget(int key, LabelMethodItem target) {
+ super(key);
+ this.target = target;
+ }
+
+ public void writeTargetTo(IndentingWriter writer) throws IOException {
+ target.writeTo(writer);
+ }
+ }
+
+ private static class SparseSwitchOffsetTarget extends SparseSwitchTarget {
+ private final int target;
+ public SparseSwitchOffsetTarget(int key, int target) {
+ super(key);
+ this.target = target;
+ }
+
+ public void writeTargetTo(IndentingWriter writer) throws IOException {
+ if (target >= 0) {
+ writer.write('+');
+ }
+ writer.printSignedIntAsDec(target);
+ }
+ }
+}
diff --git a/src/org/jf/baksmali/Adaptors/Format/UnresolvedOdexInstructionMethodItem.java b/src/org/jf/baksmali/Adaptors/Format/UnresolvedOdexInstructionMethodItem.java
new file mode 100644
index 0000000..a776881
--- /dev/null
+++ b/src/org/jf/baksmali/Adaptors/Format/UnresolvedOdexInstructionMethodItem.java
@@ -0,0 +1,54 @@
+/*
+ * [The "BSD licence"]
+ * Copyright (c) 2010 Ben Gruver (JesusFreke)
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.baksmali.Adaptors.Format;
+
+import org.jf.baksmali.Adaptors.MethodDefinition;
+import org.jf.dexlib2.analysis.UnresolvedOdexInstruction;
+import org.jf.util.IndentingWriter;
+
+import javax.annotation.Nonnull;
+import java.io.IOException;
+
+public class UnresolvedOdexInstructionMethodItem extends InstructionMethodItem {
+ public UnresolvedOdexInstructionMethodItem(@Nonnull MethodDefinition methodDef, int codeAddress,
+ @Nonnull UnresolvedOdexInstruction instruction) {
+ super(methodDef, codeAddress, instruction);
+ }
+
+ public boolean writeTo(IndentingWriter writer) throws IOException {
+ writeThrowTo(writer);
+ return true;
+ }
+
+ private void writeThrowTo(IndentingWriter writer) throws IOException {
+ writer.write("#Replaced unresolvable odex instruction with a throw\n");
+ writer.write("throw ");
+ writeRegister(writer, instruction.objectRegisterNum);
+ }
+}
diff --git a/src/org/jf/baksmali/Adaptors/LabelMethodItem.java b/src/org/jf/baksmali/Adaptors/LabelMethodItem.java
new file mode 100644
index 0000000..b152bb6
--- /dev/null
+++ b/src/org/jf/baksmali/Adaptors/LabelMethodItem.java
@@ -0,0 +1,102 @@
+/*
+ * [The "BSD licence"]
+ * Copyright (c) 2010 Ben Gruver (JesusFreke)
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.baksmali.Adaptors;
+
+import org.jf.baksmali.baksmaliOptions;
+import org.jf.util.IndentingWriter;
+
+import javax.annotation.Nonnull;
+import java.io.IOException;
+
+public class LabelMethodItem extends MethodItem {
+ private final baksmaliOptions options;
+ private final String labelPrefix;
+ private int labelSequence;
+
+ public LabelMethodItem(@Nonnull baksmaliOptions options, int codeAddress, @Nonnull String labelPrefix) {
+ super(codeAddress);
+ this.options = options;
+ this.labelPrefix = labelPrefix;
+ }
+
+ public double getSortOrder() {
+ return 0;
+ }
+
+ public int compareTo(MethodItem methodItem) {
+ int result = super.compareTo(methodItem);
+
+ if (result == 0) {
+ if (methodItem instanceof LabelMethodItem) {
+ result = labelPrefix.compareTo(((LabelMethodItem)methodItem).labelPrefix);
+ }
+ }
+ return result;
+ }
+
+ public int hashCode() {
+ //force it to call equals when two labels are at the same address
+ return getCodeAddress();
+ }
+
+ public boolean equals(Object o) {
+ if (!(o instanceof LabelMethodItem)) {
+ return false;
+ }
+ return this.compareTo((MethodItem)o) == 0;
+ }
+
+
+ public boolean writeTo(IndentingWriter writer) throws IOException {
+ writer.write(':');
+ writer.write(labelPrefix);
+ if (options.useSequentialLabels) {
+ writer.printUnsignedLongAsHex(labelSequence);
+ } else {
+ writer.printUnsignedLongAsHex(this.getLabelAddress());
+ }
+ return true;
+ }
+
+ public String getLabelPrefix() {
+ return labelPrefix;
+ }
+
+ public int getLabelAddress() {
+ return this.getCodeAddress();
+ }
+
+ public int getLabelSequence() {
+ return labelSequence;
+ }
+
+ public void setLabelSequence(int labelSequence) {
+ this.labelSequence = labelSequence;
+ }
+}
diff --git a/src/org/jf/baksmali/Adaptors/MethodDefinition.java b/src/org/jf/baksmali/Adaptors/MethodDefinition.java
new file mode 100644
index 0000000..3707873
--- /dev/null
+++ b/src/org/jf/baksmali/Adaptors/MethodDefinition.java
@@ -0,0 +1,557 @@
+/*
+ * [The "BSD licence"]
+ * Copyright (c) 2010 Ben Gruver (JesusFreke)
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.baksmali.Adaptors;
+
+import com.google.common.collect.ImmutableList;
+import org.jf.baksmali.Adaptors.Debug.DebugMethodItem;
+import org.jf.baksmali.Adaptors.Format.InstructionMethodItemFactory;
+import org.jf.baksmali.baksmaliOptions;
+import org.jf.dexlib2.AccessFlags;
+import org.jf.dexlib2.Format;
+import org.jf.dexlib2.Opcode;
+import org.jf.dexlib2.ReferenceType;
+import org.jf.dexlib2.analysis.AnalysisException;
+import org.jf.dexlib2.analysis.AnalyzedInstruction;
+import org.jf.dexlib2.analysis.MethodAnalyzer;
+import org.jf.dexlib2.dexbacked.DexBackedDexFile.InvalidItemIndex;
+import org.jf.dexlib2.iface.*;
+import org.jf.dexlib2.iface.debug.DebugItem;
+import org.jf.dexlib2.iface.instruction.Instruction;
+import org.jf.dexlib2.iface.instruction.OffsetInstruction;
+import org.jf.dexlib2.iface.instruction.ReferenceInstruction;
+import org.jf.dexlib2.iface.reference.MethodReference;
+import org.jf.dexlib2.util.InstructionOffsetMap;
+import org.jf.dexlib2.util.InstructionOffsetMap.InvalidInstructionOffset;
+import org.jf.dexlib2.util.ReferenceUtil;
+import org.jf.dexlib2.util.SyntheticAccessorResolver;
+import org.jf.dexlib2.util.TypeUtils;
+import org.jf.util.ExceptionWithContext;
+import org.jf.util.IndentingWriter;
+import org.jf.util.SparseIntArray;
+
+import javax.annotation.Nonnull;
+import java.io.IOException;
+import java.util.*;
+
+public class MethodDefinition {
+ @Nonnull public final ClassDefinition classDef;
+ @Nonnull public final Method method;
+ @Nonnull public final MethodImplementation methodImpl;
+ @Nonnull public final ImmutableList instructions;
+ @Nonnull public final ImmutableList methodParameters;
+ public RegisterFormatter registerFormatter;
+
+ @Nonnull private final LabelCache labelCache = new LabelCache();
+
+ @Nonnull private final SparseIntArray packedSwitchMap;
+ @Nonnull private final SparseIntArray sparseSwitchMap;
+ @Nonnull private final InstructionOffsetMap instructionOffsetMap;
+
+ public MethodDefinition(@Nonnull ClassDefinition classDef, @Nonnull Method method,
+ @Nonnull MethodImplementation methodImpl) {
+ this.classDef = classDef;
+ this.method = method;
+ this.methodImpl = methodImpl;
+
+ try {
+ //TODO: what about try/catch blocks inside the dead code? those will need to be commented out too. ugh.
+
+ instructions = ImmutableList.copyOf(methodImpl.getInstructions());
+ methodParameters = ImmutableList.copyOf(method.getParameters());
+
+ packedSwitchMap = new SparseIntArray(0);
+ sparseSwitchMap = new SparseIntArray(0);
+ instructionOffsetMap = new InstructionOffsetMap(instructions);
+
+ //Logger.log("the method:"+method.getDefiningClass()+":"+method.getName());
+ for (int i=0; i methodParameters = ImmutableList.copyOf(method.getParameters());
+ for (MethodParameter parameter: methodParameters) {
+ writer.write(parameter.getType());
+ }
+ writer.write(")");
+ writer.write(method.getReturnType());
+ writer.write('\n');
+
+ writer.indent(4);
+ writeParameters(writer, method, methodParameters, options);
+ AnnotationFormatter.writeTo(writer, method.getAnnotations());
+ writer.deindent(4);
+ writer.write(".end method\n");
+ }
+
+ public void writeTo(IndentingWriter writer) throws IOException {
+ int parameterRegisterCount = 0;
+ if (!AccessFlags.STATIC.isSet(method.getAccessFlags())) {
+ parameterRegisterCount++;
+ }
+
+ writer.write(".method ");
+ writeAccessFlags(writer, method.getAccessFlags());
+ writer.write(method.getName());
+ writer.write("(");
+ for (MethodParameter parameter: methodParameters) {
+ String type = parameter.getType();
+ writer.write(type);
+ parameterRegisterCount++;
+ if (TypeUtils.isWideType(type)) {
+ parameterRegisterCount++;
+ }
+ }
+ writer.write(")");
+ writer.write(method.getReturnType());
+ writer.write('\n');
+
+ writer.indent(4);
+ if (classDef.options.useLocalsDirective) {
+ writer.write(".locals ");
+ writer.printSignedIntAsDec(methodImpl.getRegisterCount() - parameterRegisterCount);
+ } else {
+ writer.write(".registers ");
+ writer.printSignedIntAsDec(methodImpl.getRegisterCount());
+ }
+ writer.write('\n');
+ writeParameters(writer, method, methodParameters, classDef.options);
+
+ if (registerFormatter == null) {
+ registerFormatter = new RegisterFormatter(classDef.options, methodImpl.getRegisterCount(),
+ parameterRegisterCount);
+ }
+
+ AnnotationFormatter.writeTo(writer, method.getAnnotations());
+
+ writer.write('\n');
+
+ List methodItems = getMethodItems();
+ for (MethodItem methodItem: methodItems) {
+ if (methodItem.writeTo(writer)) {
+ writer.write('\n');
+ }
+ }
+ writer.deindent(4);
+ writer.write(".end method\n");
+ }
+
+ public int findSwitchPayload(int targetOffset, Opcode type) {
+ int targetIndex;
+ try {
+ targetIndex = instructionOffsetMap.getInstructionIndexAtCodeOffset(targetOffset);
+ } catch (InvalidInstructionOffset ex) {
+ throw new InvalidSwitchPayload(targetOffset);
+ }
+
+ //TODO: does dalvik let you pad with multiple nops?
+ //TODO: does dalvik let a switch instruction point to a non-payload instruction?
+
+ Instruction instruction = instructions.get(targetIndex);
+ if (instruction.getOpcode() != type) {
+ // maybe it's pointing to a NOP padding instruction. Look at the next instruction
+ if (instruction.getOpcode() == Opcode.NOP) {
+ targetIndex += 1;
+ if (targetIndex < instructions.size()) {
+ instruction = instructions.get(targetIndex);
+ if (instruction.getOpcode() == type) {
+ return instructionOffsetMap.getInstructionCodeOffset(targetIndex);
+ }
+ }
+ }
+ throw new InvalidSwitchPayload(targetOffset);
+ } else {
+ return targetOffset;
+ }
+ }
+
+ private static void writeAccessFlags(IndentingWriter writer, int accessFlags)
+ throws IOException {
+ for (AccessFlags accessFlag: AccessFlags.getAccessFlagsForMethod(accessFlags)) {
+ writer.write(accessFlag.toString());
+ writer.write(' ');
+ }
+ }
+
+ private static void writeParameters(IndentingWriter writer, Method method,
+ List parameters,
+ baksmaliOptions options) throws IOException {
+ boolean isStatic = AccessFlags.STATIC.isSet(method.getAccessFlags());
+ int registerNumber = isStatic?0:1;
+ for (MethodParameter parameter: parameters) {
+ String parameterType = parameter.getType();
+ String parameterName = parameter.getName();
+ Collection annotations = parameter.getAnnotations();
+ if (parameterName != null || annotations.size() != 0) {
+ writer.write(".param p");
+ writer.printSignedIntAsDec(registerNumber);
+
+ if (parameterName != null && options.outputDebugInfo) {
+ writer.write(", ");
+ ReferenceFormatter.writeStringReference(writer, parameterName);
+ }
+ writer.write(" # ");
+ writer.write(parameterType);
+ writer.write("\n");
+ if (annotations.size() > 0) {
+ writer.indent(4);
+ AnnotationFormatter.writeTo(writer, annotations);
+ writer.deindent(4);
+ writer.write(".end param\n");
+ }
+ }
+
+ registerNumber++;
+ if (TypeUtils.isWideType(parameterType)) {
+ registerNumber++;
+ }
+ }
+ }
+
+ @Nonnull public LabelCache getLabelCache() {
+ return labelCache;
+ }
+
+ public int getPackedSwitchBaseAddress(int packedSwitchPayloadCodeOffset) {
+ return packedSwitchMap.get(packedSwitchPayloadCodeOffset, -1);
+ }
+
+ public int getSparseSwitchBaseAddress(int sparseSwitchPayloadCodeOffset) {
+ return sparseSwitchMap.get(sparseSwitchPayloadCodeOffset, -1);
+ }
+
+ private List getMethodItems() {
+ ArrayList methodItems = new ArrayList();
+
+ if ((classDef.options.registerInfo != 0) || (classDef.options.deodex && needsAnalyzed())) {
+ addAnalyzedInstructionMethodItems(methodItems);
+ } else {
+ addInstructionMethodItems(methodItems);
+ }
+
+ addTries(methodItems);
+ if (classDef.options.outputDebugInfo) {
+ addDebugInfo(methodItems);
+ }
+
+ if (classDef.options.useSequentialLabels) {
+ setLabelSequentialNumbers();
+ }
+
+ for (LabelMethodItem labelMethodItem: labelCache.getLabels()) {
+ methodItems.add(labelMethodItem);
+ }
+
+ Collections.sort(methodItems);
+
+ return methodItems;
+ }
+
+ private boolean needsAnalyzed() {
+ for (Instruction instruction: methodImpl.getInstructions()) {
+ if (instruction.getOpcode().odexOnly()) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ private void addInstructionMethodItems(List methodItems) {
+ int currentCodeAddress = 0;
+ for (int i=0; i methodItems) {
+ MethodAnalyzer methodAnalyzer = new MethodAnalyzer(classDef.options.classPath, method,
+ classDef.options.inlineResolver);
+
+ AnalysisException analysisException = methodAnalyzer.getAnalysisException();
+ if (analysisException != null) {
+ // TODO: need to keep track of whether any errors occurred, so we can exit with a non-zero result
+ methodItems.add(new CommentMethodItem(
+ String.format("AnalysisException: %s", analysisException.getMessage()),
+ analysisException.codeAddress, Integer.MIN_VALUE));
+ analysisException.printStackTrace(System.err);
+ }
+
+ List instructions = methodAnalyzer.getAnalyzedInstructions();
+
+ int currentCodeAddress = 0;
+ for (int i=0; i methodItems) {
+ List> tryBlocks = methodImpl.getTryBlocks();
+ if (tryBlocks.size() == 0) {
+ return;
+ }
+
+ int lastInstructionAddress = instructionOffsetMap.getInstructionCodeOffset(instructions.size() - 1);
+ int codeSize = lastInstructionAddress + instructions.get(instructions.size() - 1).getCodeUnits();
+
+ for (TryBlock tryBlock: tryBlocks) {
+ int startAddress = tryBlock.getStartCodeAddress();
+ int endAddress = startAddress + tryBlock.getCodeUnitCount();
+
+ if (startAddress >= codeSize) {
+ throw new RuntimeException(String.format("Try start offset %d is past the end of the code block.",
+ startAddress));
+ }
+ // Note: not >=. endAddress == codeSize is valid, when the try covers the last instruction
+ if (endAddress > codeSize) {
+ throw new RuntimeException(String.format("Try end offset %d is past the end of the code block.",
+ endAddress));
+ }
+
+ /**
+ * The end address points to the address immediately after the end of the last
+ * instruction that the try block covers. We want the .catch directive and end_try
+ * label to be associated with the last covered instruction, so we need to get
+ * the address for that instruction
+ */
+
+ int lastCoveredIndex = instructionOffsetMap.getInstructionIndexAtCodeOffset(endAddress - 1, false);
+ int lastCoveredAddress = instructionOffsetMap.getInstructionCodeOffset(lastCoveredIndex);
+
+ for (ExceptionHandler handler: tryBlock.getExceptionHandlers()) {
+ int handlerAddress = handler.getHandlerCodeAddress();
+ if (handlerAddress >= codeSize) {
+ throw new ExceptionWithContext(
+ "Exception handler offset %d is past the end of the code block.", handlerAddress);
+ }
+
+ //use the address from the last covered instruction
+ CatchMethodItem catchMethodItem = new CatchMethodItem(classDef.options, labelCache, lastCoveredAddress,
+ handler.getExceptionType(), startAddress, endAddress, handlerAddress);
+ methodItems.add(catchMethodItem);
+ }
+ }
+ }
+
+ private void addDebugInfo(final List methodItems) {
+ for (DebugItem debugItem: methodImpl.getDebugItems()) {
+ methodItems.add(DebugMethodItem.build(registerFormatter, debugItem));
+ }
+ }
+
+ private void setLabelSequentialNumbers() {
+ HashMap nextLabelSequenceByType = new HashMap();
+ ArrayList sortedLabels = new ArrayList(labelCache.getLabels());
+
+ //sort the labels by their location in the method
+ Collections.sort(sortedLabels);
+
+ for (LabelMethodItem labelMethodItem: sortedLabels) {
+ Integer labelSequence = nextLabelSequenceByType.get(labelMethodItem.getLabelPrefix());
+ if (labelSequence == null) {
+ labelSequence = 0;
+ }
+ labelMethodItem.setLabelSequence(labelSequence);
+ nextLabelSequenceByType.put(labelMethodItem.getLabelPrefix(), labelSequence + 1);
+ }
+ }
+
+ public static class LabelCache {
+ protected HashMap labels = new HashMap();
+
+ public LabelCache() {
+ }
+
+ public LabelMethodItem internLabel(LabelMethodItem labelMethodItem) {
+ LabelMethodItem internedLabelMethodItem = labels.get(labelMethodItem);
+ if (internedLabelMethodItem != null) {
+ return internedLabelMethodItem;
+ }
+ labels.put(labelMethodItem, labelMethodItem);
+ return labelMethodItem;
+ }
+
+
+ public Collection getLabels() {
+ return labels.values();
+ }
+ }
+
+ public static class InvalidSwitchPayload extends ExceptionWithContext {
+ private final int payloadOffset;
+
+ public InvalidSwitchPayload(int payloadOffset) {
+ super("No switch payload at offset: %d", payloadOffset);
+ this.payloadOffset = payloadOffset;
+ }
+
+ public int getPayloadOffset() {
+ return payloadOffset;
+ }
+ }
+}
diff --git a/src/org/jf/baksmali/Adaptors/MethodItem.java b/src/org/jf/baksmali/Adaptors/MethodItem.java
new file mode 100644
index 0000000..60358c5
--- /dev/null
+++ b/src/org/jf/baksmali/Adaptors/MethodItem.java
@@ -0,0 +1,59 @@
+/*
+ * [The "BSD licence"]
+ * Copyright (c) 2010 Ben Gruver (JesusFreke)
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.baksmali.Adaptors;
+
+import org.jf.util.IndentingWriter;
+
+import java.io.IOException;
+
+public abstract class MethodItem implements Comparable {
+ protected final int codeAddress;
+
+ protected MethodItem(int codeAddress) {
+ this.codeAddress = codeAddress;
+ }
+
+ public int getCodeAddress() {
+ return codeAddress;
+ }
+
+ //return an arbitrary double that determines how this item will be sorted with others at the same address
+ public abstract double getSortOrder();
+
+ public int compareTo(MethodItem methodItem) {
+ int result = ((Integer) codeAddress).compareTo(methodItem.codeAddress);
+
+ if (result == 0){
+ return ((Double)getSortOrder()).compareTo(methodItem.getSortOrder());
+ }
+ return result;
+ }
+
+ public abstract boolean writeTo(IndentingWriter writer) throws IOException;
+}
diff --git a/src/org/jf/baksmali/Adaptors/PostInstructionRegisterInfoMethodItem.java b/src/org/jf/baksmali/Adaptors/PostInstructionRegisterInfoMethodItem.java
new file mode 100644
index 0000000..812a282
--- /dev/null
+++ b/src/org/jf/baksmali/Adaptors/PostInstructionRegisterInfoMethodItem.java
@@ -0,0 +1,102 @@
+/*
+ * [The "BSD licence"]
+ * Copyright (c) 2010 Ben Gruver
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.baksmali.Adaptors;
+
+import org.jf.baksmali.baksmaliOptions;
+import org.jf.dexlib2.analysis.AnalyzedInstruction;
+import org.jf.dexlib2.analysis.RegisterType;
+import org.jf.util.IndentingWriter;
+
+import javax.annotation.Nonnull;
+import java.io.IOException;
+import java.util.BitSet;
+
+public class PostInstructionRegisterInfoMethodItem extends MethodItem {
+ @Nonnull private final RegisterFormatter registerFormatter;
+ @Nonnull private final AnalyzedInstruction analyzedInstruction;
+
+ public PostInstructionRegisterInfoMethodItem(@Nonnull RegisterFormatter registerFormatter,
+ @Nonnull AnalyzedInstruction analyzedInstruction,
+ int codeAddress) {
+ super(codeAddress);
+ this.registerFormatter = registerFormatter;
+ this.analyzedInstruction = analyzedInstruction;
+ }
+
+ @Override
+ public double getSortOrder() {
+ return 100.1;
+ }
+
+ @Override
+ public boolean writeTo(IndentingWriter writer) throws IOException {
+ int registerInfo = registerFormatter.options.registerInfo;
+ int registerCount = analyzedInstruction.getRegisterCount();
+ BitSet registers = new BitSet(registerCount);
+
+ if ((registerInfo & baksmaliOptions.ALL) != 0) {
+ registers.set(0, registerCount);
+ } else {
+ if ((registerInfo & baksmaliOptions.ALLPOST) != 0) {
+ registers.set(0, registerCount);
+ } else if ((registerInfo & baksmaliOptions.DEST) != 0) {
+ addDestRegs(registers, registerCount);
+ }
+ }
+
+ return writeRegisterInfo(writer, registers);
+ }
+
+ private void addDestRegs(BitSet printPostRegister, int registerCount) {
+ for (int registerNum=0; registerNum= 0; registerNum = registers.nextSetBit(registerNum + 1)) {
+ RegisterType registerType = analyzedInstruction.getPostInstructionRegisterType(registerNum);
+
+ registerFormatter.writeTo(writer, registerNum);
+ writer.write('=');
+ registerType.writeTo(writer);
+ writer.write(';');
+ }
+ return true;
+ }
+}
diff --git a/src/org/jf/baksmali/Adaptors/PreInstructionRegisterInfoMethodItem.java b/src/org/jf/baksmali/Adaptors/PreInstructionRegisterInfoMethodItem.java
new file mode 100644
index 0000000..fa54f09
--- /dev/null
+++ b/src/org/jf/baksmali/Adaptors/PreInstructionRegisterInfoMethodItem.java
@@ -0,0 +1,242 @@
+/*
+ * [The "BSD licence"]
+ * Copyright (c) 2010 Ben Gruver
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.baksmali.Adaptors;
+
+import org.jf.baksmali.baksmaliOptions;
+import org.jf.dexlib2.analysis.AnalyzedInstruction;
+import org.jf.dexlib2.analysis.MethodAnalyzer;
+import org.jf.dexlib2.analysis.RegisterType;
+import org.jf.dexlib2.iface.instruction.*;
+import org.jf.util.IndentingWriter;
+
+import javax.annotation.Nonnull;
+import java.io.IOException;
+import java.util.BitSet;
+
+public class PreInstructionRegisterInfoMethodItem extends MethodItem {
+ private final int registerInfo;
+ @Nonnull private final MethodAnalyzer methodAnalyzer;
+ @Nonnull private final RegisterFormatter registerFormatter;
+ @Nonnull private final AnalyzedInstruction analyzedInstruction;
+
+ public PreInstructionRegisterInfoMethodItem(int registerInfo,
+ @Nonnull MethodAnalyzer methodAnalyzer,
+ @Nonnull RegisterFormatter registerFormatter,
+ @Nonnull AnalyzedInstruction analyzedInstruction,
+ int codeAddress) {
+ super(codeAddress);
+ this.registerInfo = registerInfo;
+ this.methodAnalyzer = methodAnalyzer;
+ this.registerFormatter = registerFormatter;
+ this.analyzedInstruction = analyzedInstruction;
+ }
+
+ @Override
+ public double getSortOrder() {
+ return 99.9;
+ }
+
+ @Override
+ public boolean writeTo(IndentingWriter writer) throws IOException {
+ int registerCount = analyzedInstruction.getRegisterCount();
+ BitSet registers = new BitSet(registerCount);
+ BitSet mergeRegisters = null;
+
+ if ((registerInfo & baksmaliOptions.ALL) != 0) {
+ registers.set(0, registerCount);
+ } else {
+ if ((registerInfo & baksmaliOptions.ALLPRE) != 0) {
+ registers.set(0, registerCount);
+ } else {
+ if ((registerInfo & baksmaliOptions.ARGS) != 0) {
+ addArgsRegs(registers);
+ }
+ if ((registerInfo & baksmaliOptions.MERGE) != 0) {
+ if (analyzedInstruction.isBeginningInstruction()) {
+ addParamRegs(registers, registerCount);
+ }
+ mergeRegisters = new BitSet(registerCount);
+ addMergeRegs(mergeRegisters, registerCount);
+ } else if ((registerInfo & baksmaliOptions.FULLMERGE) != 0 &&
+ (analyzedInstruction.isBeginningInstruction())) {
+ addParamRegs(registers, registerCount);
+ }
+ }
+ }
+
+ if ((registerInfo & baksmaliOptions.FULLMERGE) != 0) {
+ if (mergeRegisters == null) {
+ mergeRegisters = new BitSet(registerCount);
+ addMergeRegs(mergeRegisters, registerCount);
+ }
+ registers.or(mergeRegisters);
+ } else if (mergeRegisters != null) {
+ registers.or(mergeRegisters);
+ mergeRegisters = null;
+ }
+
+ return writeRegisterInfo(writer, registers, mergeRegisters);
+ }
+
+ private void addArgsRegs(BitSet registers) {
+ if (analyzedInstruction.getInstruction() instanceof RegisterRangeInstruction) {
+ RegisterRangeInstruction instruction = (RegisterRangeInstruction)analyzedInstruction.getInstruction();
+
+ registers.set(instruction.getStartRegister(),
+ instruction.getStartRegister() + instruction.getRegisterCount());
+ } else if (analyzedInstruction.getInstruction() instanceof FiveRegisterInstruction) {
+ FiveRegisterInstruction instruction = (FiveRegisterInstruction)analyzedInstruction.getInstruction();
+ int regCount = instruction.getRegisterCount();
+ switch (regCount) {
+ case 5:
+ registers.set(instruction.getRegisterG());
+ //fall through
+ case 4:
+ registers.set(instruction.getRegisterF());
+ //fall through
+ case 3:
+ registers.set(instruction.getRegisterE());
+ //fall through
+ case 2:
+ registers.set(instruction.getRegisterD());
+ //fall through
+ case 1:
+ registers.set(instruction.getRegisterC());
+ }
+ } else if (analyzedInstruction.getInstruction() instanceof ThreeRegisterInstruction) {
+ ThreeRegisterInstruction instruction = (ThreeRegisterInstruction)analyzedInstruction.getInstruction();
+ registers.set(instruction.getRegisterA());
+ registers.set(instruction.getRegisterB());
+ registers.set(instruction.getRegisterC());
+ } else if (analyzedInstruction.getInstruction() instanceof TwoRegisterInstruction) {
+ TwoRegisterInstruction instruction = (TwoRegisterInstruction)analyzedInstruction.getInstruction();
+ registers.set(instruction.getRegisterA());
+ registers.set(instruction.getRegisterB());
+ } else if (analyzedInstruction.getInstruction() instanceof OneRegisterInstruction) {
+ OneRegisterInstruction instruction = (OneRegisterInstruction)analyzedInstruction.getInstruction();
+ registers.set(instruction.getRegisterA());
+ }
+ }
+
+ private void addMergeRegs(BitSet registers, int registerCount) {
+ if (analyzedInstruction.getPredecessorCount() <= 1) {
+ //in the common case of an instruction that only has a single predecessor which is the previous
+ //instruction, the pre-instruction registers will always match the previous instruction's
+ //post-instruction registers
+ return;
+ }
+
+ for (int registerNum=0; registerNum= 0; registerNum = registers.nextSetBit(registerNum + 1)) {
+ boolean fullMerge = fullMergeRegisters!=null && fullMergeRegisters.get(registerNum);
+ if (fullMerge) {
+ if (!firstRegister) {
+ writer.write('\n');
+ writer.write('#');
+ }
+ writeFullMerge(writer, registerNum);
+ previousWasFullMerge = true;
+ } else {
+ if (previousWasFullMerge) {
+ writer.write('\n');
+ writer.write('#');
+ previousWasFullMerge = false;
+ }
+
+ RegisterType registerType = analyzedInstruction.getPreInstructionRegisterType(registerNum);
+
+ registerFormatter.writeTo(writer, registerNum);
+ writer.write('=');
+
+ registerType.writeTo(writer);
+ writer.write(';');
+ }
+
+ firstRegister = false;
+ }
+ return true;
+ }
+}
diff --git a/src/org/jf/baksmali/Adaptors/ReferenceFormatter.java b/src/org/jf/baksmali/Adaptors/ReferenceFormatter.java
new file mode 100644
index 0000000..91d142a
--- /dev/null
+++ b/src/org/jf/baksmali/Adaptors/ReferenceFormatter.java
@@ -0,0 +1,65 @@
+/*
+ * [The "BSD licence"]
+ * Copyright (c) 2010 Ben Gruver
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.baksmali.Adaptors;
+
+import org.jf.dexlib2.ReferenceType;
+import org.jf.dexlib2.iface.reference.*;
+import org.jf.dexlib2.util.ReferenceUtil;
+import org.jf.util.IndentingWriter;
+import org.jf.util.StringUtils;
+
+import java.io.IOException;
+
+public class ReferenceFormatter {
+ public static void writeStringReference(IndentingWriter writer, String item) throws IOException {
+ writer.write('"');
+ StringUtils.writeEscapedString(writer, item);
+ writer.write('"');
+ }
+
+ public static void writeReference(IndentingWriter writer, int referenceType,
+ Reference reference) throws IOException {
+ switch (referenceType) {
+ case ReferenceType.STRING:
+ writeStringReference(writer, ((StringReference)reference).getString());
+ return;
+ case ReferenceType.TYPE:
+ writer.write(((TypeReference)reference).getType());
+ return;
+ case ReferenceType.METHOD:
+ ReferenceUtil.writeMethodDescriptor(writer, (MethodReference)reference);
+ return;
+ case ReferenceType.FIELD:
+ ReferenceUtil.writeFieldDescriptor(writer, (FieldReference)reference);
+ return;
+ default:
+ throw new IllegalStateException("Unknown reference type");
+ }
+ }
+}
diff --git a/src/org/jf/baksmali/Adaptors/RegisterFormatter.java b/src/org/jf/baksmali/Adaptors/RegisterFormatter.java
new file mode 100644
index 0000000..bffcb38
--- /dev/null
+++ b/src/org/jf/baksmali/Adaptors/RegisterFormatter.java
@@ -0,0 +1,99 @@
+/*
+ * [The "BSD licence"]
+ * Copyright (c) 2010 Ben Gruver (JesusFreke)
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.baksmali.Adaptors;
+
+import org.jf.baksmali.baksmaliOptions;
+import org.jf.util.IndentingWriter;
+
+import javax.annotation.Nonnull;
+import java.io.IOException;
+
+/**
+ * This class contains the logic used for formatting registers
+ */
+public class RegisterFormatter {
+ @Nonnull public final baksmaliOptions options;
+ public final int registerCount;
+ public final int parameterRegisterCount;
+
+ public RegisterFormatter(@Nonnull baksmaliOptions options, int registerCount, int parameterRegisterCount) {
+ this.options = options;
+ this.registerCount = registerCount;
+ this.parameterRegisterCount = parameterRegisterCount;
+ }
+
+ /**
+ * Write out the register range value used by Format3rc. If baksmali.noParameterRegisters is true, it will always
+ * output the registers in the v format. But if false, then it will check if *both* registers are parameter
+ * registers, and if so, use the p format for both. If only the last register is a parameter register, it will
+ * use the v format for both, otherwise it would be confusing to have something like {v20 .. p1}
+ * @param writer the IndentingWriter to write to
+ * @param startRegister the first register in the range
+ * @param lastRegister the last register in the range
+ */
+ public void writeRegisterRange(IndentingWriter writer, int startRegister, int lastRegister) throws IOException {
+ if (!options.noParameterRegisters) {
+ assert startRegister <= lastRegister;
+
+ if (startRegister >= registerCount - parameterRegisterCount) {
+ writer.write("{p");
+ writer.printSignedIntAsDec(startRegister - (registerCount - parameterRegisterCount));
+ writer.write(" .. p");
+ writer.printSignedIntAsDec(lastRegister - (registerCount - parameterRegisterCount));
+ writer.write('}');
+ return;
+ }
+ }
+ writer.write("{v");
+ writer.printSignedIntAsDec(startRegister);
+ writer.write(" .. v");
+ writer.printSignedIntAsDec(lastRegister);
+ writer.write('}');
+ }
+
+ /**
+ * Writes a register with the appropriate format. If baksmali.noParameterRegisters is true, then it will always
+ * output a register in the v format. If false, then it determines if the register is a parameter register,
+ * and if so, formats it in the p format instead.
+ *
+ * @param writer the IndentingWriter to write to
+ * @param register the register number
+ */
+ public void writeTo(IndentingWriter writer, int register) throws IOException {
+ if (!options.noParameterRegisters) {
+ if (register >= registerCount - parameterRegisterCount) {
+ writer.write('p');
+ writer.printSignedIntAsDec((register - (registerCount - parameterRegisterCount)));
+ return;
+ }
+ }
+ writer.write('v');
+ writer.printSignedIntAsDec(register);
+ }
+}
diff --git a/src/org/jf/baksmali/Adaptors/SyntheticAccessCommentMethodItem.java b/src/org/jf/baksmali/Adaptors/SyntheticAccessCommentMethodItem.java
new file mode 100644
index 0000000..ef0abb7
--- /dev/null
+++ b/src/org/jf/baksmali/Adaptors/SyntheticAccessCommentMethodItem.java
@@ -0,0 +1,121 @@
+/*
+ * [The "BSD licence"]
+ * Copyright (c) 2011 Ben Gruver
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.baksmali.Adaptors;
+
+import org.jf.dexlib2.ReferenceType;
+import org.jf.dexlib2.util.SyntheticAccessorResolver;
+import org.jf.util.ExceptionWithContext;
+import org.jf.util.IndentingWriter;
+
+import java.io.IOException;
+
+public class SyntheticAccessCommentMethodItem extends MethodItem {
+ private final SyntheticAccessorResolver.AccessedMember accessedMember;
+
+ public SyntheticAccessCommentMethodItem(SyntheticAccessorResolver.AccessedMember accessedMember, int codeAddress) {
+ super(codeAddress);
+ this.accessedMember = accessedMember;
+ }
+
+ public double getSortOrder() {
+ //just before the pre-instruction register information, if any
+ return 99.8;
+ }
+
+ public boolean writeTo(IndentingWriter writer) throws IOException {
+ writer.write("# ");
+ switch (accessedMember.accessedMemberType) {
+ case SyntheticAccessorResolver.METHOD:
+ writer.write("invokes: ");
+ break;
+ case SyntheticAccessorResolver.GETTER:
+ writer.write("getter for: ");
+ break;
+ case SyntheticAccessorResolver.SETTER:
+ writer.write("setter for: ");
+ break;
+ case SyntheticAccessorResolver.PREFIX_INCREMENT:
+ writer.write("++operator for: ");
+ break;
+ case SyntheticAccessorResolver.POSTFIX_INCREMENT:
+ writer.write("operator++ for: ");
+ break;
+ case SyntheticAccessorResolver.PREFIX_DECREMENT:
+ writer.write("--operator for: ");
+ break;
+ case SyntheticAccessorResolver.POSTFIX_DECREMENT:
+ writer.write("operator-- for: ");
+ break;
+ case SyntheticAccessorResolver.ADD_ASSIGNMENT:
+ writer.write("+= operator for: ");
+ break;
+ case SyntheticAccessorResolver.SUB_ASSIGNMENT:
+ writer.write("-= operator for: ");
+ break;
+ case SyntheticAccessorResolver.MUL_ASSIGNMENT:
+ writer.write("*= operator for: ");
+ break;
+ case SyntheticAccessorResolver.DIV_ASSIGNMENT:
+ writer.write("/= operator for: ");
+ break;
+ case SyntheticAccessorResolver.REM_ASSIGNMENT:
+ writer.write("%= operator for: ");
+ break;
+ case SyntheticAccessorResolver.AND_ASSIGNMENT:
+ writer.write("&= operator for: ");
+ break;
+ case SyntheticAccessorResolver.OR_ASSIGNMENT:
+ writer.write("|= operator for: ");
+ break;
+ case SyntheticAccessorResolver.XOR_ASSIGNMENT:
+ writer.write("^= operator for: ");
+ break;
+ case SyntheticAccessorResolver.SHL_ASSIGNMENT:
+ writer.write("<<= operator for: ");
+ break;
+ case SyntheticAccessorResolver.SHR_ASSIGNMENT:
+ writer.write(">>= operator for: ");
+ break;
+ case SyntheticAccessorResolver.USHR_ASSIGNMENT:
+ writer.write(">>>= operator for: ");
+ break;
+ default:
+ throw new ExceptionWithContext("Unknown access type: %d", accessedMember.accessedMemberType);
+ }
+
+ int referenceType;
+ if (accessedMember.accessedMemberType == SyntheticAccessorResolver.METHOD) {
+ referenceType = ReferenceType.METHOD;
+ } else {
+ referenceType = ReferenceType.FIELD;
+ }
+ ReferenceFormatter.writeReference(writer, referenceType, accessedMember.accessedMember);
+ return true;
+ }
+}
diff --git a/src/org/jf/baksmali/Renderers/BooleanRenderer.java b/src/org/jf/baksmali/Renderers/BooleanRenderer.java
new file mode 100644
index 0000000..f181bb4
--- /dev/null
+++ b/src/org/jf/baksmali/Renderers/BooleanRenderer.java
@@ -0,0 +1,43 @@
+/*
+ * [The "BSD licence"]
+ * Copyright (c) 2010 Ben Gruver
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.baksmali.Renderers;
+
+import org.jf.util.IndentingWriter;
+
+import java.io.IOException;
+
+public class BooleanRenderer {
+ public static void writeTo(IndentingWriter writer, boolean val) throws IOException {
+ if (val) {
+ writer.write("true");
+ } else {
+ writer.write("false");
+ }
+ }
+}
diff --git a/src/org/jf/baksmali/Renderers/ByteRenderer.java b/src/org/jf/baksmali/Renderers/ByteRenderer.java
new file mode 100644
index 0000000..9c060fd
--- /dev/null
+++ b/src/org/jf/baksmali/Renderers/ByteRenderer.java
@@ -0,0 +1,53 @@
+/*
+ * [The "BSD licence"]
+ * Copyright (c) 2010 Ben Gruver (JesusFreke)
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.baksmali.Renderers;
+
+import org.jf.util.IndentingWriter;
+
+import java.io.IOException;
+
+public class ByteRenderer {
+ public static void writeTo(IndentingWriter writer, byte val) throws IOException {
+ if (val<0) {
+ writer.write("-0x");
+ writer.printUnsignedLongAsHex(-val);
+ writer.write('t');
+ } else {
+ writer.write("0x");
+ writer.printUnsignedLongAsHex(val);
+ writer.write('t');
+ }
+ }
+
+ public static void writeUnsignedTo(IndentingWriter writer, byte val) throws IOException {
+ writer.write("0x");
+ writer.printUnsignedLongAsHex(val & 0xFF);
+ writer.write('t');
+ }
+}
diff --git a/src/org/jf/baksmali/Renderers/CharRenderer.java b/src/org/jf/baksmali/Renderers/CharRenderer.java
new file mode 100644
index 0000000..daf7634
--- /dev/null
+++ b/src/org/jf/baksmali/Renderers/CharRenderer.java
@@ -0,0 +1,42 @@
+/*
+ * [The "BSD licence"]
+ * Copyright (c) 2010 Ben Gruver (JesusFreke)
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.baksmali.Renderers;
+
+import org.jf.util.IndentingWriter;
+import org.jf.util.StringUtils;
+
+import java.io.IOException;
+
+public class CharRenderer {
+ public static void writeTo(IndentingWriter writer, char val) throws IOException {
+ writer.write('\'');
+ StringUtils.writeEscapedChar(writer, val);
+ writer.write('\'');
+ }
+}
diff --git a/src/org/jf/baksmali/Renderers/DoubleRenderer.java b/src/org/jf/baksmali/Renderers/DoubleRenderer.java
new file mode 100644
index 0000000..03fff64
--- /dev/null
+++ b/src/org/jf/baksmali/Renderers/DoubleRenderer.java
@@ -0,0 +1,39 @@
+/*
+ * [The "BSD licence"]
+ * Copyright (c) 2010 Ben Gruver
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.baksmali.Renderers;
+
+import org.jf.util.IndentingWriter;
+
+import java.io.IOException;
+
+public class DoubleRenderer {
+ public static void writeTo(IndentingWriter writer, double val) throws IOException {
+ writer.write(Double.toString(val));
+ }
+}
diff --git a/src/org/jf/baksmali/Renderers/FloatRenderer.java b/src/org/jf/baksmali/Renderers/FloatRenderer.java
new file mode 100644
index 0000000..a1de2b9
--- /dev/null
+++ b/src/org/jf/baksmali/Renderers/FloatRenderer.java
@@ -0,0 +1,40 @@
+/*
+ * [The "BSD licence"]
+ * Copyright (c) 2010 Ben Gruver (JesusFreke)
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.baksmali.Renderers;
+
+import org.jf.util.IndentingWriter;
+
+import java.io.IOException;
+
+public class FloatRenderer {
+ public static void writeTo(IndentingWriter writer, float val) throws IOException {
+ writer.write(Float.toString(val));
+ writer.write('f');
+ }
+}
diff --git a/src/org/jf/baksmali/Renderers/IntegerRenderer.java b/src/org/jf/baksmali/Renderers/IntegerRenderer.java
new file mode 100644
index 0000000..22beaac
--- /dev/null
+++ b/src/org/jf/baksmali/Renderers/IntegerRenderer.java
@@ -0,0 +1,50 @@
+/*
+ * [The "BSD licence"]
+ * Copyright (c) 2010 Ben Gruver (JesusFreke)
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.baksmali.Renderers;
+
+import org.jf.util.IndentingWriter;
+
+import java.io.IOException;
+
+public class IntegerRenderer {
+ public static void writeTo(IndentingWriter writer, int val) throws IOException {
+ if (val<0) {
+ writer.write("-0x");
+ writer.printUnsignedLongAsHex(-((long) val));
+ } else {
+ writer.write("0x");
+ writer.printUnsignedLongAsHex(val);
+ }
+ }
+
+ public static void writeUnsignedTo(IndentingWriter writer, int val) throws IOException {
+ writer.write("0x");
+ writer.printUnsignedLongAsHex(val & 0xFFFFFFFFL);
+ }
+}
diff --git a/src/org/jf/baksmali/Renderers/LongRenderer.java b/src/org/jf/baksmali/Renderers/LongRenderer.java
new file mode 100644
index 0000000..83076e4
--- /dev/null
+++ b/src/org/jf/baksmali/Renderers/LongRenderer.java
@@ -0,0 +1,63 @@
+/*
+ * [The "BSD licence"]
+ * Copyright (c) 2010 Ben Gruver (JesusFreke)
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.baksmali.Renderers;
+
+import org.jf.util.IndentingWriter;
+
+import java.io.IOException;
+
+public class LongRenderer {
+ public static void writeTo(IndentingWriter writer, long val) throws IOException {
+ if (val<0) {
+ writer.write("-0x");
+ writer.printUnsignedLongAsHex(-val);
+ writer.write('L');
+ } else {
+ writer.write("0x");
+ writer.printUnsignedLongAsHex(val);
+ writer.write('L');
+ }
+ }
+
+ public static void writeSignedIntOrLongTo(IndentingWriter writer, long val) throws IOException {
+ if (val<0) {
+ writer.write("-0x");
+ writer.printUnsignedLongAsHex(-val);
+ if (val < Integer.MIN_VALUE) {
+ writer.write('L');
+ }
+ } else {
+ writer.write("0x");
+ writer.printUnsignedLongAsHex(val);
+ if (val > Integer.MAX_VALUE) {
+ writer.write('L');
+ }
+ }
+ }
+}
diff --git a/src/org/jf/baksmali/Renderers/ShortRenderer.java b/src/org/jf/baksmali/Renderers/ShortRenderer.java
new file mode 100644
index 0000000..3385c6b
--- /dev/null
+++ b/src/org/jf/baksmali/Renderers/ShortRenderer.java
@@ -0,0 +1,47 @@
+/*
+ * [The "BSD licence"]
+ * Copyright (c) 2010 Ben Gruver (JesusFreke)
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.baksmali.Renderers;
+
+import org.jf.util.IndentingWriter;
+
+import java.io.IOException;
+
+public class ShortRenderer {
+ public static void writeTo(IndentingWriter writer, short val) throws IOException {
+ if (val < 0) {
+ writer.write("-0x");
+ writer.printUnsignedLongAsHex(-val);
+ writer.write('s');
+ } else {
+ writer.write("0x");
+ writer.printUnsignedLongAsHex(val);
+ writer.write('s');
+ }
+ }
+}
diff --git a/src/org/jf/baksmali/baksmali.java b/src/org/jf/baksmali/baksmali.java
new file mode 100644
index 0000000..056ff48
--- /dev/null
+++ b/src/org/jf/baksmali/baksmali.java
@@ -0,0 +1,247 @@
+/*
+ * [The "BSD licence"]
+ * Copyright (c) 2010 Ben Gruver (JesusFreke)
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.baksmali;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Ordering;
+import org.jf.baksmali.Adaptors.ClassDefinition;
+import org.jf.dexlib2.analysis.ClassPath;
+import org.jf.dexlib2.analysis.CustomInlineMethodResolver;
+import org.jf.dexlib2.iface.ClassDef;
+import org.jf.dexlib2.iface.DexFile;
+import org.jf.dexlib2.util.SyntheticAccessorResolver;
+import org.jf.util.ClassFileNameHandler;
+import org.jf.util.IndentingWriter;
+import org.xml.sax.Attributes;
+import org.xml.sax.SAXException;
+import org.xml.sax.helpers.DefaultHandler;
+
+import java.io.*;
+import java.util.List;
+import java.util.Map.Entry;
+import java.util.concurrent.*;
+
+import javax.xml.parsers.SAXParser;
+import javax.xml.parsers.SAXParserFactory;
+import javax.xml.parsers.ParserConfigurationException;
+
+public class baksmali {
+
+ public static boolean disassembleDexFile(DexFile dexFile, final baksmaliOptions options) {
+ if (options.registerInfo != 0 || options.deodex) {
+ try {
+ Iterable extraClassPathEntries;
+ if (options.extraClassPathEntries != null) {
+ extraClassPathEntries = options.extraClassPathEntries;
+ } else {
+ extraClassPathEntries = ImmutableList.of();
+ }
+
+ options.classPath = ClassPath.fromClassPath(options.bootClassPathDirs,
+ Iterables.concat(options.bootClassPathEntries, extraClassPathEntries), dexFile,
+ options.apiLevel);
+
+ if (options.customInlineDefinitions != null) {
+ options.inlineResolver = new CustomInlineMethodResolver(options.classPath,
+ options.customInlineDefinitions);
+ }
+ } catch (Exception ex) {
+ System.err.println("\n\nError occurred while loading boot class path files. Aborting.");
+ ex.printStackTrace(System.err);
+ return false;
+ }
+ }
+
+ if (options.resourceIdFileEntries != null) {
+ class PublicHandler extends DefaultHandler {
+ String prefix = null;
+ public PublicHandler(String prefix) {
+ super();
+ this.prefix = prefix;
+ }
+
+ public void startElement(String uri, String localName,
+ String qName, Attributes attr) throws SAXException {
+ if (qName.equals("public")) {
+ String type = attr.getValue("type");
+ String name = attr.getValue("name").replace('.', '_');
+ Integer public_key = Integer.decode(attr.getValue("id"));
+ String public_val = new StringBuffer()
+ .append(prefix)
+ .append(".")
+ .append(type)
+ .append(".")
+ .append(name)
+ .toString();
+ options.resourceIds.put(public_key, public_val);
+ }
+ }
+ };
+
+ for (Entry entry: options.resourceIdFileEntries.entrySet()) {
+ try {
+ SAXParser saxp = SAXParserFactory.newInstance().newSAXParser();
+ String prefix = entry.getValue();
+ saxp.parse(entry.getKey(), new PublicHandler(prefix));
+ } catch (ParserConfigurationException e) {
+ continue;
+ } catch (SAXException e) {
+ continue;
+ } catch (IOException e) {
+ continue;
+ }
+ }
+ }
+
+ File outputDirectoryFile = new File(options.outputDirectory);
+ if (!outputDirectoryFile.exists()) {
+ if (!outputDirectoryFile.mkdirs()) {
+ System.err.println("Can't create the output directory " + options.outputDirectory);
+ return false;
+ }
+ }
+
+ //sort the classes, so that if we're on a case-insensitive file system and need to handle classes with file
+ //name collisions, then we'll use the same name for each class, if the dex file goes through multiple
+ //baksmali/smali cycles for some reason. If a class with a colliding name is added or removed, the filenames
+ //may still change of course
+ List classDefs = Ordering.natural().sortedCopy(dexFile.getClasses());
+
+ if (!options.noAccessorComments) {
+ options.syntheticAccessorResolver = new SyntheticAccessorResolver(classDefs);
+ }
+
+ final ClassFileNameHandler fileNameHandler = new ClassFileNameHandler(outputDirectoryFile, ".smali");
+
+ ExecutorService executor = Executors.newFixedThreadPool(options.jobs);
+ List> tasks = Lists.newArrayList();
+
+ for (final ClassDef classDef: classDefs) {
+ tasks.add(executor.submit(new Callable() {
+ @Override public Boolean call() throws Exception {
+ return disassembleClass(classDef, fileNameHandler, options);
+ }
+ }));
+ }
+
+ boolean errorOccurred = false;
+ try {
+ for (Future task: tasks) {
+ while(true) {
+ try {
+ if (!task.get()) {
+ errorOccurred = true;
+ }
+ } catch (InterruptedException ex) {
+ continue;
+ } catch (ExecutionException ex) {
+ throw new RuntimeException(ex);
+ }
+ break;
+ }
+ }
+ } finally {
+ executor.shutdown();
+ }
+ return !errorOccurred;
+ }
+
+ private static boolean disassembleClass(ClassDef classDef, ClassFileNameHandler fileNameHandler,
+ baksmaliOptions options) {
+ /**
+ * The path for the disassembly file is based on the package name
+ * The class descriptor will look something like:
+ * Ljava/lang/Object;
+ * Where the there is leading 'L' and a trailing ';', and the parts of the
+ * package name are separated by '/'
+ */
+ String classDescriptor = classDef.getType();
+
+ //validate that the descriptor is formatted like we expect
+ if (classDescriptor.charAt(0) != 'L' ||
+ classDescriptor.charAt(classDescriptor.length()-1) != ';') {
+ System.err.println("Unrecognized class descriptor - " + classDescriptor + " - skipping class");
+ return false;
+ }
+
+ File smaliFile = fileNameHandler.getUniqueFilenameForClass(classDescriptor);
+
+ //create and initialize the top level string template
+ ClassDefinition classDefinition = new ClassDefinition(options, classDef);
+
+ //write the disassembly
+ Writer writer = null;
+ try
+ {
+ File smaliParent = smaliFile.getParentFile();
+ if (!smaliParent.exists()) {
+ if (!smaliParent.mkdirs()) {
+ // check again, it's likely it was created in a different thread
+ if (!smaliParent.exists()) {
+ System.err.println("Unable to create directory " + smaliParent.toString() + " - skipping class");
+ return false;
+ }
+ }
+ }
+
+ if (!smaliFile.exists()){
+ if (!smaliFile.createNewFile()) {
+ System.err.println("Unable to create file " + smaliFile.toString() + " - skipping class");
+ return false;
+ }
+ }
+
+ BufferedWriter bufWriter = new BufferedWriter(new OutputStreamWriter(
+ new FileOutputStream(smaliFile), "UTF8"));
+
+ writer = new IndentingWriter(bufWriter);
+ classDefinition.writeTo((IndentingWriter)writer);
+ } catch (Exception ex) {
+ System.err.println("\n\nError occurred while disassembling class " + classDescriptor.replace('/', '.') + " - skipping class");
+ ex.printStackTrace();
+ // noinspection ResultOfMethodCallIgnored
+ smaliFile.delete();
+ return false;
+ }
+ finally
+ {
+ if (writer != null) {
+ try {
+ writer.close();
+ } catch (Throwable ex) {
+ System.err.println("\n\nError occurred while closing file " + smaliFile.toString());
+ ex.printStackTrace();
+ }
+ }
+ }
+ return true;
+ }
+}
diff --git a/src/org/jf/baksmali/baksmaliOptions.java b/src/org/jf/baksmali/baksmaliOptions.java
new file mode 100644
index 0000000..1e83c28
--- /dev/null
+++ b/src/org/jf/baksmali/baksmaliOptions.java
@@ -0,0 +1,100 @@
+/*
+ * Copyright 2013, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ * * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.baksmali;
+
+import com.google.common.collect.Lists;
+import org.jf.dexlib2.analysis.ClassPath;
+import org.jf.dexlib2.analysis.InlineMethodResolver;
+import org.jf.dexlib2.util.SyntheticAccessorResolver;
+
+import java.io.File;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class baksmaliOptions {
+ // register info values
+ public static final int ALL = 1;
+ public static final int ALLPRE = 2;
+ public static final int ALLPOST = 4;
+ public static final int ARGS = 8;
+ public static final int DEST = 16;
+ public static final int MERGE = 32;
+ public static final int FULLMERGE = 64;
+
+ public int apiLevel = 15;
+ public String outputDirectory = "out";
+ public List bootClassPathDirs = Lists.newArrayList();
+
+ public List bootClassPathEntries = Lists.newArrayList();
+ public List extraClassPathEntries = Lists.newArrayList();
+
+ public Map resourceIdFileEntries = new HashMap();
+ public Map resourceIds = new HashMap();
+
+ public boolean noParameterRegisters = false;
+ public boolean useLocalsDirective = false;
+ public boolean useSequentialLabels = false;
+ public boolean outputDebugInfo = true;
+ public boolean addCodeOffsets = false;
+ public boolean noAccessorComments = false;
+ public boolean allowOdex = false;
+ public boolean deodex = false;
+ public boolean ignoreErrors = false;
+ public boolean checkPackagePrivateAccess = false;
+ public File customInlineDefinitions = null;
+ public InlineMethodResolver inlineResolver = null;
+ public int registerInfo = 0;
+ public ClassPath classPath = null;
+ public int jobs = -1;
+
+ public SyntheticAccessorResolver syntheticAccessorResolver = null;
+
+ public void setBootClassPath(String bootClassPath) {
+ bootClassPathEntries = Lists.newArrayList(bootClassPath.split(":"));
+ }
+
+ public void addExtraClassPath(String extraClassPath) {
+ if (extraClassPath.startsWith(":")) {
+ extraClassPath = extraClassPath.substring(1);
+ }
+ extraClassPathEntries.addAll(Arrays.asList(extraClassPath.split(":")));
+ }
+
+ public void setResourceIdFiles(String resourceIdFiles) {
+ for (String resourceIdFile: resourceIdFiles.split(":")) {
+ String[] entry = resourceIdFile.split("=");
+ resourceIdFileEntries.put(entry[1], entry[0]);
+ }
+ }
+}
diff --git a/src/org/jf/baksmali/dump.java b/src/org/jf/baksmali/dump.java
new file mode 100644
index 0000000..bd040e6
--- /dev/null
+++ b/src/org/jf/baksmali/dump.java
@@ -0,0 +1,73 @@
+/*
+ * [The "BSD licence"]
+ * Copyright (c) 2010 Ben Gruver (JesusFreke)
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.baksmali;
+
+import org.jf.dexlib2.Opcodes;
+import org.jf.dexlib2.dexbacked.DexBackedDexFile;
+import org.jf.dexlib2.dexbacked.raw.RawDexFile;
+import org.jf.dexlib2.dexbacked.raw.util.DexAnnotator;
+import org.jf.util.ConsoleUtil;
+
+import java.io.BufferedWriter;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.Writer;
+
+public class dump {
+ public static void dump(DexBackedDexFile dexFile, String dumpFileName, int apiLevel) throws IOException {
+ if (dumpFileName != null) {
+ Writer writer = null;
+
+ try {
+ writer = new BufferedWriter(new FileWriter(dumpFileName));
+
+ int consoleWidth = ConsoleUtil.getConsoleWidth();
+ if (consoleWidth <= 0) {
+ consoleWidth = 120;
+ }
+
+ RawDexFile rawDexFile = new RawDexFile(new Opcodes(apiLevel), dexFile);
+ DexAnnotator annotator = new DexAnnotator(rawDexFile, consoleWidth);
+ annotator.writeAnnotations(writer);
+ } catch (IOException ex) {
+ System.err.println("There was an error while dumping the dex file to " + dumpFileName);
+ ex.printStackTrace(System.err);
+ } finally {
+ if (writer != null) {
+ try {
+ writer.close();
+ } catch (IOException ex) {
+ System.err.println("There was an error while closing the dump file " + dumpFileName);
+ ex.printStackTrace(System.err);
+ }
+ }
+ }
+ }
+ }
+}
diff --git a/src/org/jf/baksmali/main.java b/src/org/jf/baksmali/main.java
new file mode 100644
index 0000000..274f144
--- /dev/null
+++ b/src/org/jf/baksmali/main.java
@@ -0,0 +1,531 @@
+/*
+ * [The "BSD licence"]
+ * Copyright (c) 2010 Ben Gruver (JesusFreke)
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.baksmali;
+
+import com.google.common.collect.Lists;
+import org.apache.commons.cli.*;
+import org.jf.dexlib2.DexFileFactory;
+import org.jf.dexlib2.analysis.InlineMethodResolver;
+import org.jf.dexlib2.dexbacked.DexBackedDexFile;
+import org.jf.dexlib2.dexbacked.DexBackedOdexFile;
+import org.jf.util.ConsoleUtil;
+import org.jf.util.SmaliHelpFormatter;
+
+import javax.annotation.Nonnull;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.List;
+import java.util.Locale;
+import java.util.Properties;
+
+public class main {
+
+ public static final String VERSION;
+
+ private static final Options basicOptions;
+ private static final Options debugOptions;
+ private static final Options options;
+
+ static {
+ options = new Options();
+ basicOptions = new Options();
+ debugOptions = new Options();
+ buildOptions();
+
+ InputStream templateStream = baksmali.class.getClassLoader().getResourceAsStream("baksmali.properties");
+ if (templateStream != null) {
+ Properties properties = new Properties();
+ String version = "(unknown)";
+ try {
+ properties.load(templateStream);
+ version = properties.getProperty("application.version");
+ } catch (IOException ex) {
+ // ignore
+ }
+ VERSION = version;
+ } else {
+ VERSION = "[unknown version]";
+ }
+ }
+
+ /**
+ * This class is uninstantiable.
+ */
+ private main() {
+ }
+
+ /**
+ * Run!
+ */
+ public static void main(String[] args) throws IOException {
+ Locale locale = new Locale("en", "US");
+ Locale.setDefault(locale);
+
+ CommandLineParser parser = new PosixParser();
+ CommandLine commandLine;
+
+ try {
+ commandLine = parser.parse(options, args);
+ } catch (ParseException ex) {
+ usage();
+ return;
+ }
+
+ baksmaliOptions options = new baksmaliOptions();
+
+ boolean disassemble = true;
+ boolean doDump = false;
+ String dumpFileName = null;
+ boolean setBootClassPath = false;
+
+ String[] remainingArgs = commandLine.getArgs();
+ Option[] clOptions = commandLine.getOptions();
+
+ for (int i=0; i 6) {
+ options.jobs = 6;
+ }
+ }
+
+ if (options.apiLevel >= 17) {
+ options.checkPackagePrivateAccess = true;
+ }
+
+ String inputDexFileName = remainingArgs[0];
+
+ File dexFileFile = new File(inputDexFileName);
+ if (!dexFileFile.exists()) {
+ System.err.println("Can't find the file " + inputDexFileName);
+ System.exit(1);
+ }
+
+ //Read in and parse the dex file
+ DexBackedDexFile dexFile = DexFileFactory.loadDexFile(dexFileFile, options.apiLevel);
+
+ if (dexFile.isOdexFile()) {
+ if (!options.deodex) {
+ System.err.println("Warning: You are disassembling an odex file without deodexing it. You");
+ System.err.println("won't be able to re-assemble the results unless you deodex it with the -x");
+ System.err.println("option");
+ options.allowOdex = true;
+ }
+ } else {
+ options.deodex = false;
+ }
+
+ if (!setBootClassPath && (options.deodex || options.registerInfo != 0)) {
+ if (dexFile instanceof DexBackedOdexFile) {
+ options.bootClassPathEntries = ((DexBackedOdexFile)dexFile).getDependencies();
+ } else {
+ options.bootClassPathEntries = getDefaultBootClassPathForApi(options.apiLevel);
+ }
+ }
+
+ if (options.customInlineDefinitions == null && dexFile instanceof DexBackedOdexFile) {
+ options.inlineResolver =
+ InlineMethodResolver.createInlineMethodResolver(((DexBackedOdexFile)dexFile).getOdexVersion());
+ }
+
+ boolean errorOccurred = false;
+ if (disassemble) {
+ errorOccurred = !baksmali.disassembleDexFile(dexFile, options);
+ }
+
+ if (doDump) {
+ if (dumpFileName == null) {
+ dumpFileName = commandLine.getOptionValue(inputDexFileName + ".dump");
+ }
+ dump.dump(dexFile, dumpFileName, options.apiLevel);
+ }
+
+ if (errorOccurred) {
+ System.exit(1);
+ }
+ }
+
+ /**
+ * Prints the usage message.
+ */
+ private static void usage(boolean printDebugOptions) {
+ SmaliHelpFormatter formatter = new SmaliHelpFormatter();
+ int consoleWidth = ConsoleUtil.getConsoleWidth();
+ if (consoleWidth <= 0) {
+ consoleWidth = 80;
+ }
+
+ formatter.setWidth(consoleWidth);
+
+ formatter.printHelp("java -jar baksmali.jar [options] ",
+ "disassembles and/or dumps a dex file", basicOptions, printDebugOptions?debugOptions:null);
+ }
+
+ private static void usage() {
+ usage(false);
+ }
+
+ /**
+ * Prints the version message.
+ */
+ protected static void version() {
+ System.out.println("baksmali " + VERSION + " (http://smali.googlecode.com)");
+ System.out.println("Copyright (C) 2010 Ben Gruver (JesusFreke@JesusFreke.com)");
+ System.out.println("BSD license (http://www.opensource.org/licenses/bsd-license.php)");
+ System.exit(0);
+ }
+
+ @SuppressWarnings("AccessStaticViaInstance")
+ private static void buildOptions() {
+ Option versionOption = OptionBuilder.withLongOpt("version")
+ .withDescription("prints the version then exits")
+ .create("v");
+
+ Option helpOption = OptionBuilder.withLongOpt("help")
+ .withDescription("prints the help message then exits. Specify twice for debug options")
+ .create("?");
+
+ Option outputDirOption = OptionBuilder.withLongOpt("output")
+ .withDescription("the directory where the disassembled files will be placed. The default is out")
+ .hasArg()
+ .withArgName("DIR")
+ .create("o");
+
+ Option noParameterRegistersOption = OptionBuilder.withLongOpt("no-parameter-registers")
+ .withDescription("use the v syntax instead of the p syntax for registers mapped to method " +
+ "parameters")
+ .create("p");
+
+ Option deodexerantOption = OptionBuilder.withLongOpt("deodex")
+ .withDescription("deodex the given odex file. This option is ignored if the input file is not an " +
+ "odex file")
+ .create("x");
+
+ Option useLocalsOption = OptionBuilder.withLongOpt("use-locals")
+ .withDescription("output the .locals directive with the number of non-parameter registers, rather" +
+ " than the .register directive with the total number of register")
+ .create("l");
+
+ Option sequentialLabelsOption = OptionBuilder.withLongOpt("sequential-labels")
+ .withDescription("create label names using a sequential numbering scheme per label type, rather than " +
+ "using the bytecode address")
+ .create("s");
+
+ Option noDebugInfoOption = OptionBuilder.withLongOpt("no-debug-info")
+ .withDescription("don't write out debug info (.local, .param, .line, etc.)")
+ .create("b");
+
+ Option registerInfoOption = OptionBuilder.withLongOpt("register-info")
+ .hasOptionalArgs()
+ .withArgName("REGISTER_INFO_TYPES")
+ .withValueSeparator(',')
+ .withDescription("print the specificed type(s) of register information for each instruction. " +
+ "\"ARGS,DEST\" is the default if no types are specified.\nValid values are:\nALL: all " +
+ "pre- and post-instruction registers.\nALLPRE: all pre-instruction registers\nALLPOST: all " +
+ "post-instruction registers\nARGS: any pre-instruction registers used as arguments to the " +
+ "instruction\nDEST: the post-instruction destination register, if any\nMERGE: Any " +
+ "pre-instruction register has been merged from more than 1 different post-instruction " +
+ "register from its predecessors\nFULLMERGE: For each register that would be printed by " +
+ "MERGE, also show the incoming register types that were merged")
+ .create("r");
+
+ Option classPathOption = OptionBuilder.withLongOpt("bootclasspath")
+ .withDescription("the bootclasspath jars to use, for analysis. Defaults to " +
+ "core.jar:ext.jar:framework.jar:android.policy.jar:services.jar. If the value begins with a " +
+ ":, it will be appended to the default bootclasspath instead of replacing it")
+ .hasOptionalArg()
+ .withArgName("BOOTCLASSPATH")
+ .create("c");
+
+ Option classPathDirOption = OptionBuilder.withLongOpt("bootclasspath-dir")
+ .withDescription("the base folder to look for the bootclasspath files in. Defaults to the current " +
+ "directory")
+ .hasArg()
+ .withArgName("DIR")
+ .create("d");
+
+ Option codeOffsetOption = OptionBuilder.withLongOpt("code-offsets")
+ .withDescription("add comments to the disassembly containing the code offset for each address")
+ .create("f");
+
+ Option noAccessorCommentsOption = OptionBuilder.withLongOpt("no-accessor-comments")
+ .withDescription("don't output helper comments for synthetic accessors")
+ .create("m");
+
+ Option apiLevelOption = OptionBuilder.withLongOpt("api-level")
+ .withDescription("The numeric api-level of the file being disassembled. If not " +
+ "specified, it defaults to 15 (ICS).")
+ .hasArg()
+ .withArgName("API_LEVEL")
+ .create("a");
+
+ Option jobsOption = OptionBuilder.withLongOpt("jobs")
+ .withDescription("The number of threads to use. Defaults to the number of cores available, up to a " +
+ "maximum of 6")
+ .hasArg()
+ .withArgName("NUM_THREADS")
+ .create("j");
+
+ Option resourceIdFilesOption = OptionBuilder.withLongOpt("resource-id-files")
+ .withDescription("the resource ID files to use, for analysis. A colon-separated list of prefix=file " +
+ "pairs. For example R=res/values/public.xml:" +
+ "android.R=$ANDROID_HOME/platforms/android-19/data/res/values/public.xml")
+ .hasArg()
+ .withArgName("FILES")
+ .create("i");
+
+ Option dumpOption = OptionBuilder.withLongOpt("dump-to")
+ .withDescription("dumps the given dex file into a single annotated dump file named FILE" +
+ " (.dump by default), along with the normal disassembly")
+ .hasOptionalArg()
+ .withArgName("FILE")
+ .create("D");
+
+ Option ignoreErrorsOption = OptionBuilder.withLongOpt("ignore-errors")
+ .withDescription("ignores any non-fatal errors that occur while disassembling/deodexing," +
+ " ignoring the class if needed, and continuing with the next class. The default" +
+ " behavior is to stop disassembling and exit once an error is encountered")
+ .create("I");
+
+ Option noDisassemblyOption = OptionBuilder.withLongOpt("no-disassembly")
+ .withDescription("suppresses the output of the disassembly")
+ .create("N");
+
+ Option inlineTableOption = OptionBuilder.withLongOpt("inline-table")
+ .withDescription("specify a file containing a custom inline method table to use for deodexing")
+ .hasArg()
+ .withArgName("FILE")
+ .create("T");
+
+ basicOptions.addOption(versionOption);
+ basicOptions.addOption(helpOption);
+ basicOptions.addOption(outputDirOption);
+ basicOptions.addOption(noParameterRegistersOption);
+ basicOptions.addOption(deodexerantOption);
+ basicOptions.addOption(useLocalsOption);
+ basicOptions.addOption(sequentialLabelsOption);
+ basicOptions.addOption(noDebugInfoOption);
+ basicOptions.addOption(registerInfoOption);
+ basicOptions.addOption(classPathOption);
+ basicOptions.addOption(classPathDirOption);
+ basicOptions.addOption(codeOffsetOption);
+ basicOptions.addOption(noAccessorCommentsOption);
+ basicOptions.addOption(apiLevelOption);
+ basicOptions.addOption(jobsOption);
+ basicOptions.addOption(resourceIdFilesOption);
+
+ debugOptions.addOption(dumpOption);
+ debugOptions.addOption(ignoreErrorsOption);
+ debugOptions.addOption(noDisassemblyOption);
+ debugOptions.addOption(inlineTableOption);
+
+ for (Object option: basicOptions.getOptions()) {
+ options.addOption((Option)option);
+ }
+ for (Object option: debugOptions.getOptions()) {
+ options.addOption((Option)option);
+ }
+ }
+
+ @Nonnull
+ private static List getDefaultBootClassPathForApi(int apiLevel) {
+ if (apiLevel < 9) {
+ return Lists.newArrayList(
+ "/system/framework/core.jar",
+ "/system/framework/ext.jar",
+ "/system/framework/framework.jar",
+ "/system/framework/android.policy.jar",
+ "/system/framework/services.jar");
+ } else if (apiLevel < 12) {
+ return Lists.newArrayList(
+ "/system/framework/core.jar",
+ "/system/framework/bouncycastle.jar",
+ "/system/framework/ext.jar",
+ "/system/framework/framework.jar",
+ "/system/framework/android.policy.jar",
+ "/system/framework/services.jar",
+ "/system/framework/core-junit.jar");
+ } else if (apiLevel < 14) {
+ return Lists.newArrayList(
+ "/system/framework/core.jar",
+ "/system/framework/apache-xml.jar",
+ "/system/framework/bouncycastle.jar",
+ "/system/framework/ext.jar",
+ "/system/framework/framework.jar",
+ "/system/framework/android.policy.jar",
+ "/system/framework/services.jar",
+ "/system/framework/core-junit.jar");
+ } else if (apiLevel < 16) {
+ return Lists.newArrayList(
+ "/system/framework/core.jar",
+ "/system/framework/core-junit.jar",
+ "/system/framework/bouncycastle.jar",
+ "/system/framework/ext.jar",
+ "/system/framework/framework.jar",
+ "/system/framework/android.policy.jar",
+ "/system/framework/services.jar",
+ "/system/framework/apache-xml.jar",
+ "/system/framework/filterfw.jar");
+
+ } else {
+ // this is correct as of api 17/4.2.2
+ return Lists.newArrayList(
+ "/system/framework/core.jar",
+ "/system/framework/core-junit.jar",
+ "/system/framework/bouncycastle.jar",
+ "/system/framework/ext.jar",
+ "/system/framework/framework.jar",
+ "/system/framework/telephony-common.jar",
+ "/system/framework/mms-common.jar",
+ "/system/framework/android.policy.jar",
+ "/system/framework/services.jar",
+ "/system/framework/apache-xml.jar");
+ }
+ }
+}
diff --git a/src/org/jf/dexlib2/AccessFlags.java b/src/org/jf/dexlib2/AccessFlags.java
new file mode 100644
index 0000000..d3cf74c
--- /dev/null
+++ b/src/org/jf/dexlib2/AccessFlags.java
@@ -0,0 +1,185 @@
+/*
+ * Copyright 2012, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ * * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.dexlib2;
+
+import java.util.HashMap;
+
+public enum AccessFlags
+{
+ PUBLIC(0x1, "public", true, true, true),
+ PRIVATE(0x2, "private", true, true, true),
+ PROTECTED(0x4, "protected", true, true, true),
+ STATIC(0x8, "static", true, true, true),
+ FINAL(0x10, "final", true, true, true),
+ SYNCHRONIZED(0x20, "synchronized", false, true, false),
+ VOLATILE(0x40, "volatile", false, false, true),
+ BRIDGE(0x40, "bridge", false, true, false),
+ TRANSIENT(0x80, "transient", false, false, true),
+ VARARGS(0x80, "varargs", false, true, false),
+ NATIVE(0x100, "native", false, true, false),
+ INTERFACE(0x200, "interface", true, false, false),
+ ABSTRACT(0x400, "abstract", true, true, false),
+ STRICTFP(0x800, "strictfp", false, true, false),
+ SYNTHETIC(0x1000, "synthetic", true, true, true),
+ ANNOTATION(0x2000, "annotation", true, false, false),
+ ENUM(0x4000, "enum", true, false, true),
+ CONSTRUCTOR(0x10000, "constructor", false, true, false),
+ DECLARED_SYNCHRONIZED(0x20000, "declared-synchronized", false, true, false);
+
+ private int value;
+ private String accessFlagName;
+ private boolean validForClass;
+ private boolean validForMethod;
+ private boolean validForField;
+
+ //cache the array of all AccessFlags, because .values() allocates a new array for every call
+ private final static AccessFlags[] allFlags;
+
+ private static HashMap accessFlagsByName;
+
+ static {
+ allFlags = AccessFlags.values();
+
+ accessFlagsByName = new HashMap();
+ for (AccessFlags accessFlag: allFlags) {
+ accessFlagsByName.put(accessFlag.accessFlagName, accessFlag);
+ }
+ }
+
+ private AccessFlags(int value, String accessFlagName, boolean validForClass, boolean validForMethod,
+ boolean validForField) {
+ this.value = value;
+ this.accessFlagName = accessFlagName;
+ this.validForClass = validForClass;
+ this.validForMethod = validForMethod;
+ this.validForField = validForField;
+ }
+
+ public boolean isSet(int accessFlags) {
+ return (this.value & accessFlags) != 0;
+ }
+
+ public static AccessFlags[] getAccessFlagsForClass(int accessFlagValue) {
+ int size = 0;
+ for (AccessFlags accessFlag: allFlags) {
+ if (accessFlag.validForClass && (accessFlagValue & accessFlag.value) != 0) {
+ size++;
+ }
+ }
+
+ AccessFlags[] accessFlags = new AccessFlags[size];
+ int accessFlagsPosition = 0;
+ for (AccessFlags accessFlag: allFlags) {
+ if (accessFlag.validForClass && (accessFlagValue & accessFlag.value) != 0) {
+ accessFlags[accessFlagsPosition++] = accessFlag;
+ }
+ }
+ return accessFlags;
+ }
+
+ private static String formatAccessFlags(AccessFlags[] accessFlags) {
+ int size = 0;
+ for (AccessFlags accessFlag: accessFlags) {
+ size += accessFlag.toString().length() + 1;
+ }
+
+ StringBuilder sb = new StringBuilder(size);
+ for (AccessFlags accessFlag: accessFlags) {
+ sb.append(accessFlag.toString());
+ sb.append(" ");
+ }
+ if (accessFlags.length > 0) {
+ sb.delete(sb.length() - 1, sb.length());
+ }
+ return sb.toString();
+ }
+
+ public static String formatAccessFlagsForClass(int accessFlagValue) {
+ return formatAccessFlags(getAccessFlagsForClass(accessFlagValue));
+ }
+
+ public static AccessFlags[] getAccessFlagsForMethod(int accessFlagValue) {
+ int size = 0;
+ for (AccessFlags accessFlag: allFlags) {
+ if (accessFlag.validForMethod && (accessFlagValue & accessFlag.value) != 0) {
+ size++;
+ }
+ }
+
+ AccessFlags[] accessFlags = new AccessFlags[size];
+ int accessFlagsPosition = 0;
+ for (AccessFlags accessFlag: allFlags) {
+ if (accessFlag.validForMethod && (accessFlagValue & accessFlag.value) != 0) {
+ accessFlags[accessFlagsPosition++] = accessFlag;
+ }
+ }
+ return accessFlags;
+ }
+
+ public static String formatAccessFlagsForMethod(int accessFlagValue) {
+ return formatAccessFlags(getAccessFlagsForMethod(accessFlagValue));
+ }
+
+ public static AccessFlags[] getAccessFlagsForField(int accessFlagValue) {
+ int size = 0;
+ for (AccessFlags accessFlag: allFlags) {
+ if (accessFlag.validForField && (accessFlagValue & accessFlag.value) != 0) {
+ size++;
+ }
+ }
+
+ AccessFlags[] accessFlags = new AccessFlags[size];
+ int accessFlagsPosition = 0;
+ for (AccessFlags accessFlag: allFlags) {
+ if (accessFlag.validForField && (accessFlagValue & accessFlag.value) != 0) {
+ accessFlags[accessFlagsPosition++] = accessFlag;
+ }
+ }
+ return accessFlags;
+ }
+
+ public static String formatAccessFlagsForField(int accessFlagValue) {
+ return formatAccessFlags(getAccessFlagsForField(accessFlagValue));
+ }
+
+ public static AccessFlags getAccessFlag(String accessFlag) {
+ return accessFlagsByName.get(accessFlag);
+ }
+
+ public int getValue() {
+ return value;
+ }
+
+ public String toString() {
+ return accessFlagName;
+ }
+}
diff --git a/src/org/jf/dexlib2/AnnotationVisibility.java b/src/org/jf/dexlib2/AnnotationVisibility.java
new file mode 100644
index 0000000..06c4677
--- /dev/null
+++ b/src/org/jf/dexlib2/AnnotationVisibility.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright 2012, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ * * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.dexlib2;
+
+import org.jf.util.ExceptionWithContext;
+
+public final class AnnotationVisibility {
+ public static final int BUILD = 0;
+ public static final int RUNTIME = 1;
+ public static final int SYSTEM = 2;
+
+ private static String[] NAMES = new String[] {"build", "runtime", "system"};
+
+ public static String getVisibility(int visibility) {
+ if (visibility < 0 || visibility >= NAMES.length) {
+ throw new ExceptionWithContext("Invalid annotation visibility %d", visibility);
+ }
+ return NAMES[visibility];
+ }
+
+ public static int getVisibility(String visibility) {
+ visibility = visibility.toLowerCase();
+ if (visibility.equals("build")) {
+ return BUILD;
+ }
+ if (visibility.equals("runtime")) {
+ return RUNTIME;
+ }
+ if (visibility.equals("system")) {
+ return SYSTEM;
+ }
+ throw new ExceptionWithContext("Invalid annotation visibility: %s", visibility);
+ }
+
+ private AnnotationVisibility() {}
+}
diff --git a/src/org/jf/dexlib2/DebugItemType.java b/src/org/jf/dexlib2/DebugItemType.java
new file mode 100644
index 0000000..7f4d887
--- /dev/null
+++ b/src/org/jf/dexlib2/DebugItemType.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright 2012, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ * * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.dexlib2;
+
+public final class DebugItemType {
+ // The debug items that directly correspond with one of the dexlib2.iface.debug interfaces
+ public static final int START_LOCAL = 0x03;
+ public static final int END_LOCAL = 0x05;
+ public static final int RESTART_LOCAL = 0x06;
+ public static final int PROLOGUE_END = 0x07;
+ public static final int EPILOGUE_BEGIN = 0x08;
+ public static final int SET_SOURCE_FILE = 0x09;
+ public static final int LINE_NUMBER = 0x0a;
+
+ // Other items, which are typically handled internally
+ public static final int END_SEQUENCE = 0x00;
+ public static final int ADVANCE_PC = 0x01;
+ public static final int ADVANCE_LINE = 0x02;
+ public static final int START_LOCAL_EXTENDED = 0x04;
+
+ private DebugItemType() {}
+}
diff --git a/src/org/jf/dexlib2/DexFileFactory.java b/src/org/jf/dexlib2/DexFileFactory.java
new file mode 100644
index 0000000..5987d7c
--- /dev/null
+++ b/src/org/jf/dexlib2/DexFileFactory.java
@@ -0,0 +1,133 @@
+/*
+ * Copyright 2012, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ * * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.dexlib2;
+
+import com.google.common.io.ByteStreams;
+import org.jf.dexlib2.dexbacked.DexBackedDexFile;
+import org.jf.dexlib2.dexbacked.DexBackedOdexFile;
+import org.jf.dexlib2.iface.DexFile;
+import org.jf.dexlib2.writer.pool.DexPool;
+import org.jf.util.ExceptionWithContext;
+
+import javax.annotation.Nonnull;
+import java.io.*;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
+
+public final class DexFileFactory {
+ @Nonnull
+ public static DexBackedDexFile loadDexFile(String path, int api) throws IOException {
+ return loadDexFile(new File(path), new Opcodes(api));
+ }
+
+ @Nonnull
+ public static DexBackedDexFile loadDexFile(File dexFile, int api) throws IOException {
+ return loadDexFile(dexFile, new Opcodes(api));
+ }
+
+ @Nonnull
+ public static DexBackedDexFile loadDexFile(File dexFile, @Nonnull Opcodes opcodes) throws IOException {
+ ZipFile zipFile = null;
+ boolean isZipFile = false;
+ try {
+ zipFile = new ZipFile(dexFile);
+ // if we get here, it's safe to assume we have a zip file
+ isZipFile = true;
+
+ ZipEntry zipEntry = zipFile.getEntry("classes.dex");
+ if (zipEntry == null) {
+ throw new NoClassesDexException("zip file %s does not contain a classes.dex file", dexFile.getName());
+ }
+ long fileLength = zipEntry.getSize();
+ if (fileLength < 40) {
+ throw new ExceptionWithContext(
+ "The classes.dex file in %s is too small to be a valid dex file", dexFile.getName());
+ } else if (fileLength > Integer.MAX_VALUE) {
+ throw new ExceptionWithContext("The classes.dex file in %s is too large to read in", dexFile.getName());
+ }
+ byte[] dexBytes = new byte[(int)fileLength];
+ ByteStreams.readFully(zipFile.getInputStream(zipEntry), dexBytes);
+ return new DexBackedDexFile(opcodes, dexBytes);
+ } catch (IOException ex) {
+ // don't continue on if we know it's a zip file
+ if (isZipFile) {
+ throw ex;
+ }
+ } finally {
+ if (zipFile != null) {
+ try {
+ zipFile.close();
+ } catch (IOException ex) {
+ // just eat it
+ }
+ }
+ }
+
+ InputStream inputStream = new BufferedInputStream(new FileInputStream(dexFile));
+
+ try {
+ return DexBackedDexFile.fromInputStream(opcodes, inputStream);
+ } catch (DexBackedDexFile.NotADexFile ex) {
+ // just eat it
+ }
+
+ // Note: DexBackedDexFile.fromInputStream will reset inputStream back to the same position, if it fails
+
+ try {
+ return DexBackedOdexFile.fromInputStream(opcodes, inputStream);
+ } catch (DexBackedOdexFile.NotAnOdexFile ex) {
+ // just eat it
+ }
+
+ throw new ExceptionWithContext("%s is not an apk, dex file or odex file.", dexFile.getPath());
+ }
+
+ public static void writeDexFile(String path, DexFile dexFile) throws IOException {
+ DexPool.writeTo(path, dexFile);
+ }
+
+ private DexFileFactory() {}
+
+ public static class NoClassesDexException extends ExceptionWithContext {
+ public NoClassesDexException(Throwable cause) {
+ super(cause);
+ }
+
+ public NoClassesDexException(Throwable cause, String message, Object... formatArgs) {
+ super(cause, message, formatArgs);
+ }
+
+ public NoClassesDexException(String message, Object... formatArgs) {
+ super(message, formatArgs);
+ }
+ }
+}
diff --git a/src/org/jf/dexlib2/Format.java b/src/org/jf/dexlib2/Format.java
new file mode 100644
index 0000000..d91b743
--- /dev/null
+++ b/src/org/jf/dexlib2/Format.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright 2012, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ * * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.dexlib2;
+
+public enum Format {
+ Format10t(2),
+ Format10x(2),
+ Format11n(2),
+ Format11x(2),
+ Format12x(2),
+ Format20bc(4),
+ Format20t(4),
+ Format21c(4),
+ Format21ih(4),
+ Format21lh(4),
+ Format21s(4),
+ Format21t(4),
+ Format22b(4),
+ Format22c(4),
+ Format22cs(4),
+ Format22s(4),
+ Format22t(4),
+ Format22x(4),
+ Format23x(4),
+ Format30t(6),
+ Format31c(6),
+ Format31i(6),
+ Format31t(6),
+ Format32x(6),
+ Format35c(6),
+ Format35mi(6),
+ Format35ms(6),
+ Format3rc(6),
+ Format3rmi(6),
+ Format3rms(6),
+ Format51l(10),
+ ArrayPayload(-1, true),
+ PackedSwitchPayload(-1, true),
+ SparseSwitchPayload(-1, true),
+ UnresolvedOdexInstruction(-1);
+
+ public final int size;
+ public final boolean isPayloadFormat;
+
+ private Format(int size) {
+ this(size, false);
+ }
+
+ private Format(int size, boolean isPayloadFormat) {
+ this.size = size;
+ this.isPayloadFormat = isPayloadFormat;
+ }
+}
diff --git a/src/org/jf/dexlib2/Opcode.java b/src/org/jf/dexlib2/Opcode.java
new file mode 100644
index 0000000..d0adee8
--- /dev/null
+++ b/src/org/jf/dexlib2/Opcode.java
@@ -0,0 +1,420 @@
+/*
+ * Copyright 2012, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ * * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.dexlib2;
+
+public enum Opcode
+{
+ NOP((short)0x00, "nop", ReferenceType.NONE, Format.Format10x, Opcode.CAN_CONTINUE),
+ MOVE((short)0x01, "move", ReferenceType.NONE, Format.Format12x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ MOVE_FROM16((short)0x02, "move/from16", ReferenceType.NONE, Format.Format22x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ MOVE_16((short)0x03, "move/16", ReferenceType.NONE, Format.Format32x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ MOVE_WIDE((short)0x04, "move-wide", ReferenceType.NONE, Format.Format12x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER | Opcode.SETS_WIDE_REGISTER),
+ MOVE_WIDE_FROM16((short)0x05, "move-wide/from16", ReferenceType.NONE, Format.Format22x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER | Opcode.SETS_WIDE_REGISTER),
+ MOVE_WIDE_16((short)0x06, "move-wide/16", ReferenceType.NONE, Format.Format32x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER | Opcode.SETS_WIDE_REGISTER),
+ MOVE_OBJECT((short)0x07, "move-object", ReferenceType.NONE, Format.Format12x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ MOVE_OBJECT_FROM16((short)0x08, "move-object/from16", ReferenceType.NONE, Format.Format22x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ MOVE_OBJECT_16((short)0x09, "move-object/16", ReferenceType.NONE, Format.Format32x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ MOVE_RESULT((short)0x0a, "move-result", ReferenceType.NONE, Format.Format11x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ MOVE_RESULT_WIDE((short)0x0b, "move-result-wide", ReferenceType.NONE, Format.Format11x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER | Opcode.SETS_WIDE_REGISTER),
+ MOVE_RESULT_OBJECT((short)0x0c, "move-result-object", ReferenceType.NONE, Format.Format11x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ MOVE_EXCEPTION((short)0x0d, "move-exception", ReferenceType.NONE, Format.Format11x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ RETURN_VOID((short)0x0e, "return-void", ReferenceType.NONE, Format.Format10x),
+ RETURN((short)0x0f, "return", ReferenceType.NONE, Format.Format11x),
+ RETURN_WIDE((short)0x10, "return-wide", ReferenceType.NONE, Format.Format11x),
+ RETURN_OBJECT((short)0x11, "return-object", ReferenceType.NONE, Format.Format11x),
+ CONST_4((short)0x12, "const/4", ReferenceType.NONE, Format.Format11n, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ CONST_16((short)0x13, "const/16", ReferenceType.NONE, Format.Format21s, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ CONST((short)0x14, "const", ReferenceType.NONE, Format.Format31i, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ CONST_HIGH16((short)0x15, "const/high16", ReferenceType.NONE, Format.Format21ih, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ CONST_WIDE_16((short)0x16, "const-wide/16", ReferenceType.NONE, Format.Format21s, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER | Opcode.SETS_WIDE_REGISTER),
+ CONST_WIDE_32((short)0x17, "const-wide/32", ReferenceType.NONE, Format.Format31i, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER | Opcode.SETS_WIDE_REGISTER),
+ CONST_WIDE((short)0x18, "const-wide", ReferenceType.NONE, Format.Format51l, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER | Opcode.SETS_WIDE_REGISTER),
+ CONST_WIDE_HIGH16((short)0x19, "const-wide/high16", ReferenceType.NONE, Format.Format21lh, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER | Opcode.SETS_WIDE_REGISTER),
+ CONST_STRING((short)0x1a, "const-string", ReferenceType.STRING, Format.Format21c, Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER, (short)0x1b),
+ CONST_STRING_JUMBO((short)0x1b, "const-string/jumbo", ReferenceType.STRING, Format.Format31c, Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ CONST_CLASS((short)0x1c, "const-class", ReferenceType.TYPE, Format.Format21c, Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ MONITOR_ENTER((short)0x1d, "monitor-enter", ReferenceType.NONE, Format.Format11x, Opcode.CAN_THROW | Opcode.CAN_CONTINUE),
+ MONITOR_EXIT((short)0x1e, "monitor-exit", ReferenceType.NONE, Format.Format11x, Opcode.CAN_THROW | Opcode.CAN_CONTINUE),
+ CHECK_CAST((short)0x1f, "check-cast", ReferenceType.TYPE, Format.Format21c, Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ INSTANCE_OF((short)0x20, "instance-of", ReferenceType.TYPE, Format.Format22c, Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ ARRAY_LENGTH((short)0x21, "array-length", ReferenceType.NONE, Format.Format12x, Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ NEW_INSTANCE((short)0x22, "new-instance", ReferenceType.TYPE, Format.Format21c, Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ NEW_ARRAY((short)0x23, "new-array", ReferenceType.TYPE, Format.Format22c, Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ FILLED_NEW_ARRAY((short)0x24, "filled-new-array", ReferenceType.TYPE, Format.Format35c, Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_RESULT),
+ FILLED_NEW_ARRAY_RANGE((short)0x25, "filled-new-array/range", ReferenceType.TYPE, Format.Format3rc, Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_RESULT),
+ FILL_ARRAY_DATA((short)0x26, "fill-array-data", ReferenceType.NONE, Format.Format31t, Opcode.CAN_CONTINUE),
+ THROW((short)0x27, "throw", ReferenceType.NONE, Format.Format11x, Opcode.CAN_THROW),
+ GOTO((short)0x28, "goto", ReferenceType.NONE, Format.Format10t),
+ GOTO_16((short)0x29, "goto/16", ReferenceType.NONE, Format.Format20t),
+ GOTO_32((short)0x2a, "goto/32", ReferenceType.NONE, Format.Format30t),
+ PACKED_SWITCH((short)0x2b, "packed-switch", ReferenceType.NONE, Format.Format31t, Opcode.CAN_CONTINUE),
+ SPARSE_SWITCH((short)0x2c, "sparse-switch", ReferenceType.NONE, Format.Format31t, Opcode.CAN_CONTINUE),
+ CMPL_FLOAT((short)0x2d, "cmpl-float", ReferenceType.NONE, Format.Format23x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ CMPG_FLOAT((short)0x2e, "cmpg-float", ReferenceType.NONE, Format.Format23x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ CMPL_DOUBLE((short)0x2f, "cmpl-double", ReferenceType.NONE, Format.Format23x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ CMPG_DOUBLE((short)0x30, "cmpg-double", ReferenceType.NONE, Format.Format23x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ CMP_LONG((short)0x31, "cmp-long", ReferenceType.NONE, Format.Format23x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ IF_EQ((short)0x32, "if-eq", ReferenceType.NONE, Format.Format22t, Opcode.CAN_CONTINUE),
+ IF_NE((short)0x33, "if-ne", ReferenceType.NONE, Format.Format22t, Opcode.CAN_CONTINUE),
+ IF_LT((short)0x34, "if-lt", ReferenceType.NONE, Format.Format22t, Opcode.CAN_CONTINUE),
+ IF_GE((short)0x35, "if-ge", ReferenceType.NONE, Format.Format22t, Opcode.CAN_CONTINUE),
+ IF_GT((short)0x36, "if-gt", ReferenceType.NONE, Format.Format22t, Opcode.CAN_CONTINUE),
+ IF_LE((short)0x37, "if-le", ReferenceType.NONE, Format.Format22t, Opcode.CAN_CONTINUE),
+ IF_EQZ((short)0x38, "if-eqz", ReferenceType.NONE, Format.Format21t, Opcode.CAN_CONTINUE),
+ IF_NEZ((short)0x39, "if-nez", ReferenceType.NONE, Format.Format21t, Opcode.CAN_CONTINUE),
+ IF_LTZ((short)0x3a, "if-ltz", ReferenceType.NONE, Format.Format21t, Opcode.CAN_CONTINUE),
+ IF_GEZ((short)0x3b, "if-gez", ReferenceType.NONE, Format.Format21t, Opcode.CAN_CONTINUE),
+ IF_GTZ((short)0x3c, "if-gtz", ReferenceType.NONE, Format.Format21t, Opcode.CAN_CONTINUE),
+ IF_LEZ((short)0x3d, "if-lez", ReferenceType.NONE, Format.Format21t, Opcode.CAN_CONTINUE),
+ AGET((short)0x44, "aget", ReferenceType.NONE, Format.Format23x, Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ AGET_WIDE((short)0x45, "aget-wide", ReferenceType.NONE, Format.Format23x, Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER | Opcode.SETS_WIDE_REGISTER),
+ AGET_OBJECT((short)0x46, "aget-object", ReferenceType.NONE, Format.Format23x, Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ AGET_BOOLEAN((short)0x47, "aget-boolean", ReferenceType.NONE, Format.Format23x, Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ AGET_BYTE((short)0x48, "aget-byte", ReferenceType.NONE, Format.Format23x, Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ AGET_CHAR((short)0x49, "aget-char", ReferenceType.NONE, Format.Format23x, Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ AGET_SHORT((short)0x4a, "aget-short", ReferenceType.NONE, Format.Format23x, Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ APUT((short)0x4b, "aput", ReferenceType.NONE, Format.Format23x, Opcode.CAN_THROW | Opcode.CAN_CONTINUE),
+ APUT_WIDE((short)0x4c, "aput-wide", ReferenceType.NONE, Format.Format23x, Opcode.CAN_THROW | Opcode.CAN_CONTINUE),
+ APUT_OBJECT((short)0x4d, "aput-object", ReferenceType.NONE, Format.Format23x, Opcode.CAN_THROW | Opcode.CAN_CONTINUE),
+ APUT_BOOLEAN((short)0x4e, "aput-boolean", ReferenceType.NONE, Format.Format23x, Opcode.CAN_THROW | Opcode.CAN_CONTINUE),
+ APUT_BYTE((short)0x4f, "aput-byte", ReferenceType.NONE, Format.Format23x, Opcode.CAN_THROW | Opcode.CAN_CONTINUE),
+ APUT_CHAR((short)0x50, "aput-char", ReferenceType.NONE, Format.Format23x, Opcode.CAN_THROW | Opcode.CAN_CONTINUE),
+ APUT_SHORT((short)0x51, "aput-short", ReferenceType.NONE, Format.Format23x, Opcode.CAN_THROW | Opcode.CAN_CONTINUE),
+ IGET((short)0x52, "iget", ReferenceType.FIELD, Format.Format22c, Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ IGET_WIDE((short)0x53, "iget-wide", ReferenceType.FIELD, Format.Format22c, Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER | Opcode.SETS_WIDE_REGISTER),
+ IGET_OBJECT((short)0x54, "iget-object", ReferenceType.FIELD, Format.Format22c, Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ IGET_BOOLEAN((short)0x55, "iget-boolean", ReferenceType.FIELD, Format.Format22c, Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ IGET_BYTE((short)0x56, "iget-byte", ReferenceType.FIELD, Format.Format22c, Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ IGET_CHAR((short)0x57, "iget-char", ReferenceType.FIELD, Format.Format22c, Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ IGET_SHORT((short)0x58, "iget-short", ReferenceType.FIELD, Format.Format22c, Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ IPUT((short)0x59, "iput", ReferenceType.FIELD, Format.Format22c, Opcode.CAN_THROW | Opcode.CAN_CONTINUE),
+ IPUT_WIDE((short)0x5a, "iput-wide", ReferenceType.FIELD, Format.Format22c, Opcode.CAN_THROW | Opcode.CAN_CONTINUE),
+ IPUT_OBJECT((short)0x5b, "iput-object", ReferenceType.FIELD, Format.Format22c, Opcode.CAN_THROW | Opcode.CAN_CONTINUE),
+ IPUT_BOOLEAN((short)0x5c, "iput-boolean", ReferenceType.FIELD, Format.Format22c, Opcode.CAN_THROW | Opcode.CAN_CONTINUE),
+ IPUT_BYTE((short)0x5d, "iput-byte", ReferenceType.FIELD, Format.Format22c, Opcode.CAN_THROW | Opcode.CAN_CONTINUE),
+ IPUT_CHAR((short)0x5e, "iput-char", ReferenceType.FIELD, Format.Format22c, Opcode.CAN_THROW | Opcode.CAN_CONTINUE),
+ IPUT_SHORT((short)0x5f, "iput-short", ReferenceType.FIELD, Format.Format22c, Opcode.CAN_THROW | Opcode.CAN_CONTINUE),
+ SGET((short)0x60, "sget", ReferenceType.FIELD, Format.Format21c, Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ SGET_WIDE((short)0x61, "sget-wide", ReferenceType.FIELD, Format.Format21c, Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER | Opcode.SETS_WIDE_REGISTER),
+ SGET_OBJECT((short)0x62, "sget-object", ReferenceType.FIELD, Format.Format21c, Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ SGET_BOOLEAN((short)0x63, "sget-boolean", ReferenceType.FIELD, Format.Format21c, Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ SGET_BYTE((short)0x64, "sget-byte", ReferenceType.FIELD, Format.Format21c, Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ SGET_CHAR((short)0x65, "sget-char", ReferenceType.FIELD, Format.Format21c, Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ SGET_SHORT((short)0x66, "sget-short", ReferenceType.FIELD, Format.Format21c, Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ SPUT((short)0x67, "sput", ReferenceType.FIELD, Format.Format21c, Opcode.CAN_THROW | Opcode.CAN_CONTINUE),
+ SPUT_WIDE((short)0x68, "sput-wide", ReferenceType.FIELD, Format.Format21c, Opcode.CAN_THROW | Opcode.CAN_CONTINUE),
+ SPUT_OBJECT((short)0x69, "sput-object", ReferenceType.FIELD, Format.Format21c, Opcode.CAN_THROW | Opcode.CAN_CONTINUE),
+ SPUT_BOOLEAN((short)0x6a, "sput-boolean", ReferenceType.FIELD, Format.Format21c, Opcode.CAN_THROW | Opcode.CAN_CONTINUE),
+ SPUT_BYTE((short)0x6b, "sput-byte", ReferenceType.FIELD, Format.Format21c, Opcode.CAN_THROW | Opcode.CAN_CONTINUE),
+ SPUT_CHAR((short)0x6c, "sput-char", ReferenceType.FIELD, Format.Format21c, Opcode.CAN_THROW | Opcode.CAN_CONTINUE),
+ SPUT_SHORT((short)0x6d, "sput-short", ReferenceType.FIELD, Format.Format21c, Opcode.CAN_THROW | Opcode.CAN_CONTINUE),
+ INVOKE_VIRTUAL((short)0x6e, "invoke-virtual", ReferenceType.METHOD, Format.Format35c, Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_RESULT),
+ INVOKE_SUPER((short)0x6f, "invoke-super", ReferenceType.METHOD, Format.Format35c, Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_RESULT),
+ INVOKE_DIRECT((short)0x70, "invoke-direct", ReferenceType.METHOD, Format.Format35c, Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_RESULT | Opcode.CAN_INITIALIZE_REFERENCE),
+ INVOKE_STATIC((short)0x71, "invoke-static", ReferenceType.METHOD, Format.Format35c, Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_RESULT),
+ INVOKE_INTERFACE((short)0x72, "invoke-interface", ReferenceType.METHOD, Format.Format35c, Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_RESULT),
+ INVOKE_VIRTUAL_RANGE((short)0x74, "invoke-virtual/range", ReferenceType.METHOD, Format.Format3rc, Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_RESULT),
+ INVOKE_SUPER_RANGE((short)0x75, "invoke-super/range", ReferenceType.METHOD, Format.Format3rc, Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_RESULT),
+ INVOKE_DIRECT_RANGE((short)0x76, "invoke-direct/range", ReferenceType.METHOD, Format.Format3rc, Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_RESULT | Opcode.CAN_INITIALIZE_REFERENCE),
+ INVOKE_STATIC_RANGE((short)0x77, "invoke-static/range", ReferenceType.METHOD, Format.Format3rc, Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_RESULT),
+ INVOKE_INTERFACE_RANGE((short)0x78, "invoke-interface/range", ReferenceType.METHOD, Format.Format3rc, Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_RESULT),
+ NEG_INT((short)0x7b, "neg-int", ReferenceType.NONE, Format.Format12x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ NOT_INT((short)0x7c, "not-int", ReferenceType.NONE, Format.Format12x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ NEG_LONG((short)0x7d, "neg-long", ReferenceType.NONE, Format.Format12x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER | Opcode.SETS_WIDE_REGISTER),
+ NOT_LONG((short)0x7e, "not-long", ReferenceType.NONE, Format.Format12x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER | Opcode.SETS_WIDE_REGISTER),
+ NEG_FLOAT((short)0x7f, "neg-float", ReferenceType.NONE, Format.Format12x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ NEG_DOUBLE((short)0x80, "neg-double", ReferenceType.NONE, Format.Format12x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER | Opcode.SETS_WIDE_REGISTER),
+ INT_TO_LONG((short)0x81, "int-to-long", ReferenceType.NONE, Format.Format12x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER | Opcode.SETS_WIDE_REGISTER),
+ INT_TO_FLOAT((short)0x82, "int-to-float", ReferenceType.NONE, Format.Format12x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ INT_TO_DOUBLE((short)0x83, "int-to-double", ReferenceType.NONE, Format.Format12x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER | Opcode.SETS_WIDE_REGISTER),
+ LONG_TO_INT((short)0x84, "long-to-int", ReferenceType.NONE, Format.Format12x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ LONG_TO_FLOAT((short)0x85, "long-to-float", ReferenceType.NONE, Format.Format12x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ LONG_TO_DOUBLE((short)0x86, "long-to-double", ReferenceType.NONE, Format.Format12x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER | Opcode.SETS_WIDE_REGISTER),
+ FLOAT_TO_INT((short)0x87, "float-to-int", ReferenceType.NONE, Format.Format12x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ FLOAT_TO_LONG((short)0x88, "float-to-long", ReferenceType.NONE, Format.Format12x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER | Opcode.SETS_WIDE_REGISTER),
+ FLOAT_TO_DOUBLE((short)0x89, "float-to-double", ReferenceType.NONE, Format.Format12x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER | Opcode.SETS_WIDE_REGISTER),
+ DOUBLE_TO_INT((short)0x8a, "double-to-int", ReferenceType.NONE, Format.Format12x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ DOUBLE_TO_LONG((short)0x8b, "double-to-long", ReferenceType.NONE, Format.Format12x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER | Opcode.SETS_WIDE_REGISTER),
+ DOUBLE_TO_FLOAT((short)0x8c, "double-to-float", ReferenceType.NONE, Format.Format12x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ INT_TO_BYTE((short)0x8d, "int-to-byte", ReferenceType.NONE, Format.Format12x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ INT_TO_CHAR((short)0x8e, "int-to-char", ReferenceType.NONE, Format.Format12x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ INT_TO_SHORT((short)0x8f, "int-to-short", ReferenceType.NONE, Format.Format12x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ ADD_INT((short)0x90, "add-int", ReferenceType.NONE, Format.Format23x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ SUB_INT((short)0x91, "sub-int", ReferenceType.NONE, Format.Format23x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ MUL_INT((short)0x92, "mul-int", ReferenceType.NONE, Format.Format23x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ DIV_INT((short)0x93, "div-int", ReferenceType.NONE, Format.Format23x, Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ REM_INT((short)0x94, "rem-int", ReferenceType.NONE, Format.Format23x, Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ AND_INT((short)0x95, "and-int", ReferenceType.NONE, Format.Format23x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ OR_INT((short)0x96, "or-int", ReferenceType.NONE, Format.Format23x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ XOR_INT((short)0x97, "xor-int", ReferenceType.NONE, Format.Format23x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ SHL_INT((short)0x98, "shl-int", ReferenceType.NONE, Format.Format23x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ SHR_INT((short)0x99, "shr-int", ReferenceType.NONE, Format.Format23x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ USHR_INT((short)0x9a, "ushr-int", ReferenceType.NONE, Format.Format23x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ ADD_LONG((short)0x9b, "add-long", ReferenceType.NONE, Format.Format23x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER | Opcode.SETS_WIDE_REGISTER),
+ SUB_LONG((short)0x9c, "sub-long", ReferenceType.NONE, Format.Format23x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER | Opcode.SETS_WIDE_REGISTER),
+ MUL_LONG((short)0x9d, "mul-long", ReferenceType.NONE, Format.Format23x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER | Opcode.SETS_WIDE_REGISTER),
+ DIV_LONG((short)0x9e, "div-long", ReferenceType.NONE, Format.Format23x, Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER | Opcode.SETS_WIDE_REGISTER),
+ REM_LONG((short)0x9f, "rem-long", ReferenceType.NONE, Format.Format23x, Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER | Opcode.SETS_WIDE_REGISTER),
+ AND_LONG((short)0xa0, "and-long", ReferenceType.NONE, Format.Format23x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER | Opcode.SETS_WIDE_REGISTER),
+ OR_LONG((short)0xa1, "or-long", ReferenceType.NONE, Format.Format23x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER | Opcode.SETS_WIDE_REGISTER),
+ XOR_LONG((short)0xa2, "xor-long", ReferenceType.NONE, Format.Format23x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER | Opcode.SETS_WIDE_REGISTER),
+ SHL_LONG((short)0xa3, "shl-long", ReferenceType.NONE, Format.Format23x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER | Opcode.SETS_WIDE_REGISTER),
+ SHR_LONG((short)0xa4, "shr-long", ReferenceType.NONE, Format.Format23x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER | Opcode.SETS_WIDE_REGISTER),
+ USHR_LONG((short)0xa5, "ushr-long", ReferenceType.NONE, Format.Format23x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER | Opcode.SETS_WIDE_REGISTER),
+ ADD_FLOAT((short)0xa6, "add-float", ReferenceType.NONE, Format.Format23x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ SUB_FLOAT((short)0xa7, "sub-float", ReferenceType.NONE, Format.Format23x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ MUL_FLOAT((short)0xa8, "mul-float", ReferenceType.NONE, Format.Format23x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ DIV_FLOAT((short)0xa9, "div-float", ReferenceType.NONE, Format.Format23x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ REM_FLOAT((short)0xaa, "rem-float", ReferenceType.NONE, Format.Format23x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ ADD_DOUBLE((short)0xab, "add-double", ReferenceType.NONE, Format.Format23x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER | Opcode.SETS_WIDE_REGISTER),
+ SUB_DOUBLE((short)0xac, "sub-double", ReferenceType.NONE, Format.Format23x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER | Opcode.SETS_WIDE_REGISTER),
+ MUL_DOUBLE((short)0xad, "mul-double", ReferenceType.NONE, Format.Format23x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER | Opcode.SETS_WIDE_REGISTER),
+ DIV_DOUBLE((short)0xae, "div-double", ReferenceType.NONE, Format.Format23x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER | Opcode.SETS_WIDE_REGISTER),
+ REM_DOUBLE((short)0xaf, "rem-double", ReferenceType.NONE, Format.Format23x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER | Opcode.SETS_WIDE_REGISTER),
+ ADD_INT_2ADDR((short)0xb0, "add-int/2addr", ReferenceType.NONE, Format.Format12x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ SUB_INT_2ADDR((short)0xb1, "sub-int/2addr", ReferenceType.NONE, Format.Format12x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ MUL_INT_2ADDR((short)0xb2, "mul-int/2addr", ReferenceType.NONE, Format.Format12x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ DIV_INT_2ADDR((short)0xb3, "div-int/2addr", ReferenceType.NONE, Format.Format12x, Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ REM_INT_2ADDR((short)0xb4, "rem-int/2addr", ReferenceType.NONE, Format.Format12x, Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ AND_INT_2ADDR((short)0xb5, "and-int/2addr", ReferenceType.NONE, Format.Format12x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ OR_INT_2ADDR((short)0xb6, "or-int/2addr", ReferenceType.NONE, Format.Format12x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ XOR_INT_2ADDR((short)0xb7, "xor-int/2addr", ReferenceType.NONE, Format.Format12x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ SHL_INT_2ADDR((short)0xb8, "shl-int/2addr", ReferenceType.NONE, Format.Format12x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ SHR_INT_2ADDR((short)0xb9, "shr-int/2addr", ReferenceType.NONE, Format.Format12x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ USHR_INT_2ADDR((short)0xba, "ushr-int/2addr", ReferenceType.NONE, Format.Format12x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ ADD_LONG_2ADDR((short)0xbb, "add-long/2addr", ReferenceType.NONE, Format.Format12x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER | Opcode.SETS_WIDE_REGISTER),
+ SUB_LONG_2ADDR((short)0xbc, "sub-long/2addr", ReferenceType.NONE, Format.Format12x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER | Opcode.SETS_WIDE_REGISTER),
+ MUL_LONG_2ADDR((short)0xbd, "mul-long/2addr", ReferenceType.NONE, Format.Format12x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER | Opcode.SETS_WIDE_REGISTER),
+ DIV_LONG_2ADDR((short)0xbe, "div-long/2addr", ReferenceType.NONE, Format.Format12x, Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER | Opcode.SETS_WIDE_REGISTER),
+ REM_LONG_2ADDR((short)0xbf, "rem-long/2addr", ReferenceType.NONE, Format.Format12x, Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER | Opcode.SETS_WIDE_REGISTER),
+ AND_LONG_2ADDR((short)0xc0, "and-long/2addr", ReferenceType.NONE, Format.Format12x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER | Opcode.SETS_WIDE_REGISTER),
+ OR_LONG_2ADDR((short)0xc1, "or-long/2addr", ReferenceType.NONE, Format.Format12x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER | Opcode.SETS_WIDE_REGISTER),
+ XOR_LONG_2ADDR((short)0xc2, "xor-long/2addr", ReferenceType.NONE, Format.Format12x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER | Opcode.SETS_WIDE_REGISTER),
+ SHL_LONG_2ADDR((short)0xc3, "shl-long/2addr", ReferenceType.NONE, Format.Format12x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER | Opcode.SETS_WIDE_REGISTER),
+ SHR_LONG_2ADDR((short)0xc4, "shr-long/2addr", ReferenceType.NONE, Format.Format12x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER | Opcode.SETS_WIDE_REGISTER),
+ USHR_LONG_2ADDR((short)0xc5, "ushr-long/2addr", ReferenceType.NONE, Format.Format12x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER | Opcode.SETS_WIDE_REGISTER),
+ ADD_FLOAT_2ADDR((short)0xc6, "add-float/2addr", ReferenceType.NONE, Format.Format12x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ SUB_FLOAT_2ADDR((short)0xc7, "sub-float/2addr", ReferenceType.NONE, Format.Format12x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ MUL_FLOAT_2ADDR((short)0xc8, "mul-float/2addr", ReferenceType.NONE, Format.Format12x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ DIV_FLOAT_2ADDR((short)0xc9, "div-float/2addr", ReferenceType.NONE, Format.Format12x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ REM_FLOAT_2ADDR((short)0xca, "rem-float/2addr", ReferenceType.NONE, Format.Format12x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ ADD_DOUBLE_2ADDR((short)0xcb, "add-double/2addr", ReferenceType.NONE, Format.Format12x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER | Opcode.SETS_WIDE_REGISTER),
+ SUB_DOUBLE_2ADDR((short)0xcc, "sub-double/2addr", ReferenceType.NONE, Format.Format12x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER | Opcode.SETS_WIDE_REGISTER),
+ MUL_DOUBLE_2ADDR((short)0xcd, "mul-double/2addr", ReferenceType.NONE, Format.Format12x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER | Opcode.SETS_WIDE_REGISTER),
+ DIV_DOUBLE_2ADDR((short)0xce, "div-double/2addr", ReferenceType.NONE, Format.Format12x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER | Opcode.SETS_WIDE_REGISTER),
+ REM_DOUBLE_2ADDR((short)0xcf, "rem-double/2addr", ReferenceType.NONE, Format.Format12x, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER | Opcode.SETS_WIDE_REGISTER),
+ ADD_INT_LIT16((short)0xd0, "add-int/lit16", ReferenceType.NONE, Format.Format22s, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ RSUB_INT((short)0xd1, "rsub-int", ReferenceType.NONE, Format.Format22s, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ MUL_INT_LIT16((short)0xd2, "mul-int/lit16", ReferenceType.NONE, Format.Format22s, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ DIV_INT_LIT16((short)0xd3, "div-int/lit16", ReferenceType.NONE, Format.Format22s, Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ REM_INT_LIT16((short)0xd4, "rem-int/lit16", ReferenceType.NONE, Format.Format22s, Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ AND_INT_LIT16((short)0xd5, "and-int/lit16", ReferenceType.NONE, Format.Format22s, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ OR_INT_LIT16((short)0xd6, "or-int/lit16", ReferenceType.NONE, Format.Format22s, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ XOR_INT_LIT16((short)0xd7, "xor-int/lit16", ReferenceType.NONE, Format.Format22s, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ ADD_INT_LIT8((short)0xd8, "add-int/lit8", ReferenceType.NONE, Format.Format22b, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ RSUB_INT_LIT8((short)0xd9, "rsub-int/lit8", ReferenceType.NONE, Format.Format22b, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ MUL_INT_LIT8((short)0xda, "mul-int/lit8", ReferenceType.NONE, Format.Format22b, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ DIV_INT_LIT8((short)0xdb, "div-int/lit8", ReferenceType.NONE, Format.Format22b, Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ REM_INT_LIT8((short)0xdc, "rem-int/lit8", ReferenceType.NONE, Format.Format22b, Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ AND_INT_LIT8((short)0xdd, "and-int/lit8", ReferenceType.NONE, Format.Format22b, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ OR_INT_LIT8((short)0xde, "or-int/lit8", ReferenceType.NONE, Format.Format22b, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ XOR_INT_LIT8((short)0xdf, "xor-int/lit8", ReferenceType.NONE, Format.Format22b, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ SHL_INT_LIT8((short)0xe0, "shl-int/lit8", ReferenceType.NONE, Format.Format22b, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ SHR_INT_LIT8((short)0xe1, "shr-int/lit8", ReferenceType.NONE, Format.Format22b, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ USHR_INT_LIT8((short)0xe2, "ushr-int/lit8", ReferenceType.NONE, Format.Format22b, Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+
+ IGET_VOLATILE((short)0xe3, "iget-volatile", minApi(9), ReferenceType.FIELD, Format.Format22c, Opcode.ODEX_ONLY | Opcode.ODEXED_INSTANCE_VOLATILE | Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ IPUT_VOLATILE((short)0xe4, "iput-volatile", minApi(9), ReferenceType.FIELD, Format.Format22c, Opcode.ODEX_ONLY | Opcode.ODEXED_INSTANCE_VOLATILE | Opcode.CAN_THROW | Opcode.CAN_CONTINUE),
+ SGET_VOLATILE((short)0xe5, "sget-volatile", minApi(9), ReferenceType.FIELD, Format.Format21c, Opcode.ODEX_ONLY | Opcode.ODEXED_STATIC_VOLATILE | Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ SPUT_VOLATILE((short)0xe6, "sput-volatile", minApi(9), ReferenceType.FIELD, Format.Format21c, Opcode.ODEX_ONLY | Opcode.ODEXED_STATIC_VOLATILE | Opcode.CAN_THROW | Opcode.CAN_CONTINUE),
+ IGET_OBJECT_VOLATILE((short)0xe7, "iget-object-volatile", minApi(9), ReferenceType.FIELD, Format.Format22c, Opcode.ODEX_ONLY | Opcode.ODEXED_INSTANCE_VOLATILE | Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ IGET_WIDE_VOLATILE((short)0xe8, "iget-wide-volatile", minApi(9), ReferenceType.FIELD, Format.Format22c, Opcode.ODEX_ONLY | Opcode.ODEXED_INSTANCE_VOLATILE | Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER | Opcode.SETS_WIDE_REGISTER),
+ IPUT_WIDE_VOLATILE((short)0xe9, "iput-wide-volatile", minApi(9), ReferenceType.FIELD, Format.Format22c, Opcode.ODEX_ONLY | Opcode.ODEXED_INSTANCE_VOLATILE | Opcode.CAN_THROW | Opcode.CAN_CONTINUE),
+ SGET_WIDE_VOLATILE((short)0xea, "sget-wide-volatile", minApi(9), ReferenceType.FIELD, Format.Format21c, Opcode.ODEX_ONLY | Opcode.ODEXED_STATIC_VOLATILE | Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER | Opcode.SETS_WIDE_REGISTER),
+ SPUT_WIDE_VOLATILE((short)0xeb, "sput-wide-volatile", minApi(9), ReferenceType.FIELD, Format.Format21c, Opcode.ODEX_ONLY | Opcode.ODEXED_STATIC_VOLATILE | Opcode.CAN_THROW | Opcode.CAN_CONTINUE),
+
+ THROW_VERIFICATION_ERROR((short)0xed, "throw-verification-error", minApi(5), ReferenceType.NONE, Format.Format20bc, Opcode.ODEX_ONLY | Opcode.CAN_THROW),
+ EXECUTE_INLINE((short)0xee, "execute-inline", ReferenceType.NONE, Format.Format35mi, Opcode.ODEX_ONLY | Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_RESULT),
+ EXECUTE_INLINE_RANGE((short)0xef, "execute-inline/range", minApi(8), ReferenceType.NONE, Format.Format3rmi, Opcode.ODEX_ONLY | Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_RESULT),
+ INVOKE_DIRECT_EMPTY((short)0xf0, "invoke-direct-empty", maxApi(13), ReferenceType.METHOD, Format.Format35c, Opcode.ODEX_ONLY | Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_RESULT | Opcode.CAN_INITIALIZE_REFERENCE),
+ INVOKE_OBJECT_INIT_RANGE((short)0xf0, "invoke-object-init/range", minApi(14), ReferenceType.METHOD, Format.Format3rc, Opcode.ODEX_ONLY | Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_RESULT | Opcode.CAN_INITIALIZE_REFERENCE),
+ RETURN_VOID_BARRIER((short)0xf1, "return-void-barrier", minApi(11), ReferenceType.NONE, Format.Format10x, Opcode.ODEX_ONLY),
+ IGET_QUICK((short)0xf2, "iget-quick", ReferenceType.NONE, Format.Format22cs, Opcode.ODEX_ONLY | Opcode.ODEXED_INSTANCE_QUICK | Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ IGET_WIDE_QUICK((short)0xf3, "iget-wide-quick", ReferenceType.NONE, Format.Format22cs, Opcode.ODEX_ONLY | Opcode.ODEXED_INSTANCE_QUICK | Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER | Opcode.SETS_WIDE_REGISTER),
+ IGET_OBJECT_QUICK((short)0xf4, "iget-object-quick", ReferenceType.NONE, Format.Format22cs, Opcode.ODEX_ONLY | Opcode.ODEXED_INSTANCE_QUICK | Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ IPUT_QUICK((short)0xf5, "iput-quick", ReferenceType.NONE, Format.Format22cs, Opcode.ODEX_ONLY | Opcode.ODEXED_INSTANCE_QUICK | Opcode.CAN_THROW | Opcode.CAN_CONTINUE),
+ IPUT_WIDE_QUICK((short)0xf6, "iput-wide-quick", ReferenceType.NONE, Format.Format22cs, Opcode.ODEX_ONLY | Opcode.ODEXED_INSTANCE_QUICK | Opcode.CAN_THROW | Opcode.CAN_CONTINUE),
+ IPUT_OBJECT_QUICK((short)0xf7, "iput-object-quick", ReferenceType.NONE, Format.Format22cs, Opcode.ODEX_ONLY | Opcode.ODEXED_INSTANCE_QUICK | Opcode.CAN_THROW | Opcode.CAN_CONTINUE),
+ INVOKE_VIRTUAL_QUICK((short)0xf8, "invoke-virtual-quick", ReferenceType.NONE, Format.Format35ms, Opcode.ODEX_ONLY | Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_RESULT),
+ INVOKE_VIRTUAL_QUICK_RANGE((short)0xf9, "invoke-virtual-quick/range", ReferenceType.NONE, Format.Format3rms, Opcode.ODEX_ONLY | Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_RESULT),
+ INVOKE_SUPER_QUICK((short)0xfa, "invoke-super-quick", ReferenceType.NONE, Format.Format35ms, Opcode.ODEX_ONLY | Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_RESULT),
+ INVOKE_SUPER_QUICK_RANGE((short)0xfb, "invoke-super-quick/range", ReferenceType.NONE, Format.Format3rms, Opcode.ODEX_ONLY | Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_RESULT),
+
+ IPUT_OBJECT_VOLATILE((short)0xfc, "iput-object-volatile", minApi(9), ReferenceType.FIELD, Format.Format22c, Opcode.ODEX_ONLY | Opcode.ODEXED_INSTANCE_VOLATILE | Opcode.CAN_THROW | Opcode.CAN_CONTINUE),
+ SGET_OBJECT_VOLATILE((short)0xfd, "sget-object-volatile", minApi(9), ReferenceType.FIELD, Format.Format21c, Opcode.ODEX_ONLY | Opcode.ODEXED_STATIC_VOLATILE | Opcode.CAN_THROW | Opcode.CAN_CONTINUE | Opcode.SETS_REGISTER),
+ SPUT_OBJECT_VOLATILE((short)0xfe, "sput-object-volatile", minApi(9), ReferenceType.FIELD, Format.Format21c, Opcode.ODEX_ONLY | Opcode.ODEXED_STATIC_VOLATILE | Opcode.CAN_THROW | Opcode.CAN_CONTINUE),
+
+ PACKED_SWITCH_PAYLOAD((short)0x100, "packed-switch-payload", ReferenceType.NONE, Format.PackedSwitchPayload, 0),
+ SPARSE_SWITCH_PAYLOAD((short)0x200, "sparse-switch-payload", ReferenceType.NONE, Format.SparseSwitchPayload, 0),
+ ARRAY_PAYLOAD((short)0x300, "array-payload", ReferenceType.NONE, Format.ArrayPayload, 0);
+
+ //if the instruction can throw an exception
+ public static final int CAN_THROW = 0x1;
+ //if the instruction is an odex only instruction
+ public static final int ODEX_ONLY = 0x2;
+ //if execution can continue to the next instruction
+ public static final int CAN_CONTINUE = 0x4;
+ //if the instruction sets the "hidden" result register
+ public static final int SETS_RESULT = 0x8;
+ //if the instruction sets the value of it's first register
+ public static final int SETS_REGISTER = 0x10;
+ //if the instruction sets the value of it's first register to a wide type
+ public static final int SETS_WIDE_REGISTER = 0x20;
+ //if the instruction is an odexed iget-quick/iput-quick instruction
+ public static final int ODEXED_INSTANCE_QUICK = 0x40;
+ //if the instruction is an odexed iget-volatile/iput-volatile instruction
+ public static final int ODEXED_INSTANCE_VOLATILE = 0x80;
+ //if the instruction is an odexed sget-volatile/sput-volatile instruction
+ public static final int ODEXED_STATIC_VOLATILE = 0x100;
+ //if the instruction is a jumbo instruction
+ public static final int JUMBO_OPCODE = 0x200;
+ //if the instruction can initialize an uninitialized object reference
+ public static final int CAN_INITIALIZE_REFERENCE = 0x400;
+
+ private static final int ALL_APIS = 0xFFFF0000;
+
+ private static int minApi(int api) {
+ return 0xFFFF0000 | (api & 0xFFFF);
+ }
+
+ private static int maxApi(int api) {
+ return api << 16;
+ }
+
+ public final short value;
+ public final String name;
+ // high 16-bits is the max api, low 16-bits is the min api
+ public final int apiConstraints;
+ public final int referenceType;
+ public final Format format;
+ public final int flags;
+
+ Opcode(short opcodeValue, String opcodeName, int referenceType, Format format) {
+ this(opcodeValue, opcodeName, ALL_APIS, referenceType, format, 0, (short)-1);
+ }
+
+ Opcode(short opcodeValue, String opcodeName, int referenceType, Format format, int flags) {
+ this(opcodeValue, opcodeName, ALL_APIS, referenceType, format, flags, (short)-1);
+ }
+
+ Opcode(short opcodeValue, String opcodeName, int referenceType, Format format, int flags, short jumboOpcodeValue) {
+ this(opcodeValue, opcodeName, ALL_APIS, referenceType, format, flags, jumboOpcodeValue);
+ }
+
+ Opcode(short opcodeValue, String opcodeName, int apiConstraints, int referenceType, Format format) {
+ this(opcodeValue, opcodeName, apiConstraints, referenceType, format, 0, (short)-1);
+ }
+
+ Opcode(short opcodeValue, String opcodeName, int apiConstraints, int referenceType, Format format, int flags) {
+ this(opcodeValue, opcodeName, apiConstraints, referenceType, format, flags, (short)-1);
+ }
+
+ Opcode(short opcodeValue, String opcodeName, int apiConstraints, int referenceType, Format format, int flags,
+ short jumboOpcodeValue) {
+ this.value = opcodeValue;
+ this.name = opcodeName;
+ this.apiConstraints = apiConstraints;
+ this.referenceType = referenceType;
+ this.format = format;
+ this.flags = flags;
+ // TODO: implement jumbo opcodes for dexlib2 and uncomment
+ // this.jumboOpcode = jumboOpcodeValue;
+ }
+
+ /**
+ * @return the minimum api level that can use this opcode (inclusive)
+ */
+ public int getMinApi() {
+ return apiConstraints & 0xFFFF;
+ }
+
+ /**
+ * @return the maximum api level that can to use this opcode (inclusive)
+ */
+ public int getMaxApi() {
+ return apiConstraints >>> 16;
+ }
+
+ public final boolean canThrow() {
+ return (flags & CAN_THROW) != 0;
+ }
+
+ public final boolean odexOnly() {
+ return (flags & ODEX_ONLY) != 0;
+ }
+
+ public final boolean canContinue() {
+ return (flags & CAN_CONTINUE) != 0;
+ }
+
+ public final boolean setsResult() {
+ return (flags & SETS_RESULT) != 0;
+ }
+
+ public final boolean setsRegister() {
+ return (flags & SETS_REGISTER) != 0;
+ }
+
+ public final boolean setsWideRegister() {
+ return (flags & SETS_WIDE_REGISTER) != 0;
+ }
+
+ public final boolean isOdexedInstanceQuick() {
+ return (flags & ODEXED_INSTANCE_QUICK) != 0;
+ }
+
+ public final boolean isOdexedInstanceVolatile() {
+ return (flags & ODEXED_INSTANCE_VOLATILE) != 0;
+ }
+
+ public final boolean isOdexedStaticVolatile() {
+ return (flags & ODEXED_STATIC_VOLATILE) != 0;
+ }
+
+ public final boolean isJumboOpcode() {
+ return (flags & JUMBO_OPCODE) != 0;
+ }
+
+ public final boolean canInitializeReference() {
+ return (flags & CAN_INITIALIZE_REFERENCE) != 0;
+ }
+}
diff --git a/src/org/jf/dexlib2/Opcodes.java b/src/org/jf/dexlib2/Opcodes.java
new file mode 100644
index 0000000..d6e5532
--- /dev/null
+++ b/src/org/jf/dexlib2/Opcodes.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright 2013, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ * * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.dexlib2;
+
+import com.google.common.collect.Maps;
+
+import javax.annotation.Nullable;
+import java.util.HashMap;
+
+public class Opcodes {
+ private final Opcode[] opcodesByValue;
+ private final HashMap opcodesByName;
+
+ public Opcodes(int api) {
+ opcodesByValue = new Opcode[256];
+ opcodesByName = Maps.newHashMap();
+
+ for (Opcode opcode: Opcode.values()) {
+ if (!opcode.format.isPayloadFormat) {
+ if (api <= opcode.getMaxApi() && api >= opcode.getMinApi()) {
+ opcodesByValue[opcode.value] = opcode;
+ opcodesByName.put(opcode.name.toLowerCase(), opcode);
+ }
+ }
+ }
+ }
+
+ @Nullable
+ public Opcode getOpcodeByName(String opcodeName) {
+ return opcodesByName.get(opcodeName.toLowerCase());
+ }
+
+ @Nullable
+ public Opcode getOpcodeByValue(int opcodeValue) {
+ switch (opcodeValue) {
+ case 0x100:
+ return Opcode.PACKED_SWITCH_PAYLOAD;
+ case 0x200:
+ return Opcode.SPARSE_SWITCH_PAYLOAD;
+ case 0x300:
+ return Opcode.ARRAY_PAYLOAD;
+ default:
+ if (opcodeValue >= 0 && opcodeValue < opcodesByValue.length) {
+ return opcodesByValue[opcodeValue];
+ }
+ return null;
+ }
+ }
+}
diff --git a/src/org/jf/dexlib2/ReferenceType.java b/src/org/jf/dexlib2/ReferenceType.java
new file mode 100644
index 0000000..3371f81
--- /dev/null
+++ b/src/org/jf/dexlib2/ReferenceType.java
@@ -0,0 +1,103 @@
+/*
+ * Copyright 2012, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ * * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.dexlib2;
+
+import org.jf.dexlib2.iface.reference.*;
+import org.jf.util.ExceptionWithContext;
+
+public final class ReferenceType {
+ public static final int STRING = 0;
+ public static final int TYPE = 1;
+ public static final int FIELD = 2;
+ public static final int METHOD = 3;
+ public static final int NONE = 4;
+
+ public static String toString(int referenceType) {
+ switch (referenceType) {
+ case STRING:
+ return "string";
+ case TYPE:
+ return "type";
+ case FIELD:
+ return "field";
+ case METHOD:
+ return "method";
+ default:
+ throw new InvalidReferenceTypeException(referenceType);
+ }
+ }
+
+ public static int getReferenceType(Reference reference) {
+ if (reference instanceof StringReference) {
+ return STRING;
+ } else if (reference instanceof TypeReference) {
+ return TYPE;
+ } else if (reference instanceof FieldReference) {
+ return FIELD;
+ } else if (reference instanceof MethodReference) {
+ return METHOD;
+ } else {
+ throw new IllegalStateException("Invalid reference");
+ }
+ }
+
+ /**
+ * Validate a specific reference type. Note that the NONE placeholder is specifically not considered valid here.
+ *
+ * @throws InvalidReferenceTypeException
+ */
+ public static void validateReferenceType(int referenceType) {
+ if (referenceType < 0 || referenceType > 3) {
+ throw new InvalidReferenceTypeException(referenceType);
+ }
+ }
+
+ public static class InvalidReferenceTypeException extends ExceptionWithContext {
+ private final int referenceType;
+
+ public InvalidReferenceTypeException(int referenceType) {
+ super("Invalid reference type: %d", referenceType);
+ this.referenceType = referenceType;
+ }
+
+ public InvalidReferenceTypeException(int referenceType, String message, Object... formatArgs) {
+ super(message, formatArgs);
+ this.referenceType = referenceType;
+ }
+
+ public int getReferenceType() {
+ return referenceType;
+ }
+ }
+
+ private ReferenceType() {}
+}
\ No newline at end of file
diff --git a/src/org/jf/dexlib2/ValueType.java b/src/org/jf/dexlib2/ValueType.java
new file mode 100644
index 0000000..08710a6
--- /dev/null
+++ b/src/org/jf/dexlib2/ValueType.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright 2012, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ * * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.dexlib2;
+
+public final class ValueType {
+ public static final int BYTE = 0x00;
+ public static final int SHORT = 0x02;
+ public static final int CHAR = 0x03;
+ public static final int INT = 0x04;
+ public static final int LONG = 0x06;
+ public static final int FLOAT = 0x10;
+ public static final int DOUBLE = 0x11;
+ public static final int STRING = 0x17;
+ public static final int TYPE = 0x18;
+ public static final int FIELD = 0x19;
+ public static final int METHOD = 0x1a;
+ public static final int ENUM = 0x1b;
+ public static final int ARRAY = 0x1c;
+ public static final int ANNOTATION = 0x1d;
+ public static final int NULL = 0x1e;
+ public static final int BOOLEAN = 0x1f;
+
+ private ValueType() {}
+}
diff --git a/src/org/jf/dexlib2/VerificationError.java b/src/org/jf/dexlib2/VerificationError.java
new file mode 100644
index 0000000..d0aa029
--- /dev/null
+++ b/src/org/jf/dexlib2/VerificationError.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright 2013, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ * * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.dexlib2;
+
+import com.google.common.collect.Maps;
+import org.jf.util.ExceptionWithContext;
+
+import javax.annotation.Nullable;
+import java.util.HashMap;
+
+public class VerificationError {
+ public static final int GENERIC = 1;
+ public static final int NO_SUCH_CLASS = 2;
+ public static final int NO_SUCH_FIELD = 3;
+ public static final int NO_SUCH_METHOD = 4;
+ public static final int ILLEGAL_CLASS_ACCESS = 5;
+ public static final int ILLEGAL_FIELD_ACCESS = 6;
+ public static final int ILLEGAL_METHOD_ACCESS = 7;
+ public static final int CLASS_CHANGE_ERROR = 8;
+ public static final int INSTANTIATION_ERROR = 9;
+
+ private static final HashMap verificationErrorNames = Maps.newHashMap();
+
+ static {
+ verificationErrorNames.put("generic-error", GENERIC);
+ verificationErrorNames.put("no-such-class", NO_SUCH_CLASS);
+ verificationErrorNames.put("no-such-field", NO_SUCH_FIELD);
+ verificationErrorNames.put("no-such-method", NO_SUCH_METHOD);
+ verificationErrorNames.put("illegal-class-access", ILLEGAL_CLASS_ACCESS);
+ verificationErrorNames.put("illegal-field-access", ILLEGAL_FIELD_ACCESS);
+ verificationErrorNames.put("illegal-method-access", ILLEGAL_METHOD_ACCESS);
+ verificationErrorNames.put("class-change-error", CLASS_CHANGE_ERROR);
+ verificationErrorNames.put("instantiation-error", INSTANTIATION_ERROR);
+ }
+
+ @Nullable
+ public static String getVerificationErrorName(int verificationError) {
+ switch (verificationError) {
+ case GENERIC:
+ return "generic-error";
+ case NO_SUCH_CLASS:
+ return "no-such-class";
+ case NO_SUCH_FIELD:
+ return "no-such-field";
+ case NO_SUCH_METHOD:
+ return "no-such-method";
+ case ILLEGAL_CLASS_ACCESS:
+ return "illegal-class-access";
+ case ILLEGAL_FIELD_ACCESS:
+ return "illegal-field-access";
+ case ILLEGAL_METHOD_ACCESS:
+ return "illegal-method-access";
+ case CLASS_CHANGE_ERROR:
+ return "class-change-error";
+ case INSTANTIATION_ERROR:
+ return "instantiation-error";
+ default:
+ return null;
+ }
+ }
+
+ public static int getVerificationError(String verificationError) {
+ Integer ret = verificationErrorNames.get(verificationError);
+ if (ret == null) {
+ throw new ExceptionWithContext("Invalid verification error: %s", verificationError);
+ }
+ return ret;
+ }
+
+ public static boolean isValidVerificationError(int verificationError) {
+ return verificationError > 0 && verificationError < 10;
+ }
+}
diff --git a/src/org/jf/dexlib2/analysis/AnalysisException.java b/src/org/jf/dexlib2/analysis/AnalysisException.java
new file mode 100644
index 0000000..4ca7b13
--- /dev/null
+++ b/src/org/jf/dexlib2/analysis/AnalysisException.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright 2013, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ * * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.dexlib2.analysis;
+
+import org.jf.util.ExceptionWithContext;
+
+public class AnalysisException extends ExceptionWithContext {
+ public int codeAddress;
+
+ public AnalysisException(Throwable cause) {
+ super(cause);
+ }
+
+ public AnalysisException(Throwable cause, String message, Object... formatArgs) {
+ super(cause, message, formatArgs);
+ }
+
+ public AnalysisException(String message, Object... formatArgs) {
+ super(message, formatArgs);
+ }
+}
diff --git a/src/org/jf/dexlib2/analysis/AnalyzedInstruction.java b/src/org/jf/dexlib2/analysis/AnalyzedInstruction.java
new file mode 100644
index 0000000..30cc906
--- /dev/null
+++ b/src/org/jf/dexlib2/analysis/AnalyzedInstruction.java
@@ -0,0 +1,332 @@
+/*
+ * Copyright 2013, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ * * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.dexlib2.analysis;
+
+import org.jf.dexlib2.iface.instruction.*;
+import org.jf.dexlib2.iface.reference.MethodReference;
+import org.jf.dexlib2.iface.reference.Reference;
+import org.jf.util.ExceptionWithContext;
+
+import javax.annotation.Nonnull;
+import java.util.*;
+
+public class AnalyzedInstruction implements Comparable {
+ /**
+ * The actual instruction
+ */
+ protected Instruction instruction;
+
+ /**
+ * The index of the instruction, where the first instruction in the method is at index 0, and so on
+ */
+ protected final int instructionIndex;
+
+ /**
+ * Instructions that can pass on execution to this one during normal execution
+ */
+ protected final TreeSet predecessors = new TreeSet();
+
+ /**
+ * Instructions that can execution could pass on to next during normal execution
+ */
+ protected final LinkedList successors = new LinkedList();
+
+ /**
+ * This contains the register types *before* the instruction has executed
+ */
+ protected final RegisterType[] preRegisterMap;
+
+ /**
+ * This contains the register types *after* the instruction has executed
+ */
+ protected final RegisterType[] postRegisterMap;
+
+ /**
+ * When deodexing, we might need to deodex this instruction multiple times, when we merge in new register
+ * information. When this happens, we need to restore the original (odexed) instruction, so we can deodex it again
+ */
+ protected final Instruction originalInstruction;
+
+ public AnalyzedInstruction(Instruction instruction, int instructionIndex, int registerCount) {
+ this.instruction = instruction;
+ this.originalInstruction = instruction;
+ this.instructionIndex = instructionIndex;
+ this.postRegisterMap = new RegisterType[registerCount];
+ this.preRegisterMap = new RegisterType[registerCount];
+ RegisterType unknown = RegisterType.getRegisterType(RegisterType.UNKNOWN, null);
+ for (int i=0; i getPredecessors() {
+ return Collections.unmodifiableSortedSet(predecessors);
+ }
+
+ protected boolean addPredecessor(AnalyzedInstruction predecessor) {
+ return predecessors.add(predecessor);
+ }
+
+ protected void addSuccessor(AnalyzedInstruction successor) {
+ successors.add(successor);
+ }
+
+ protected void setDeodexedInstruction(Instruction instruction) {
+ assert originalInstruction.getOpcode().odexOnly();
+ this.instruction = instruction;
+ }
+
+ protected void restoreOdexedInstruction() {
+ assert originalInstruction.getOpcode().odexOnly();
+ instruction = originalInstruction;
+ }
+
+ public int getSuccessorCount() {
+ return successors.size();
+ }
+
+ public List getSuccesors() {
+ return Collections.unmodifiableList(successors);
+ }
+
+ public Instruction getInstruction() {
+ return instruction;
+ }
+
+ public Instruction getOriginalInstruction() {
+ return originalInstruction;
+ }
+
+ /**
+ * Is this instruction a "beginning instruction". A beginning instruction is defined to be an instruction
+ * that can be the first successfully executed instruction in the method. The first instruction is always a
+ * beginning instruction. If the first instruction can throw an exception, and is covered by a try block, then
+ * the first instruction of any exception handler for that try block is also a beginning instruction. And likewise,
+ * if any of those instructions can throw an exception and are covered by try blocks, the first instruction of the
+ * corresponding exception handler is a beginning instruction, etc.
+ *
+ * To determine this, we simply check if the first predecessor is the fake "StartOfMethod" instruction, which has
+ * an instruction index of -1.
+ * @return a boolean value indicating whether this instruction is a beginning instruction
+ */
+ public boolean isBeginningInstruction() {
+ //if this instruction has no predecessors, it is either the fake "StartOfMethod" instruction or it is an
+ //unreachable instruction.
+ if (predecessors.size() == 0) {
+ return false;
+ }
+
+ if (predecessors.first().instructionIndex == -1) {
+ return true;
+ }
+ return false;
+ }
+
+ /*
+ * Merges the given register type into the specified pre-instruction register, and also sets the post-instruction
+ * register type accordingly if it isn't a destination register for this instruction
+ * @param registerNumber Which register to set
+ * @param registerType The register type
+ * @returns true If the post-instruction register type was changed. This might be false if either the specified
+ * register is a destination register for this instruction, or if the pre-instruction register type didn't change
+ * after merging in the given register type
+ */
+ protected boolean mergeRegister(int registerNumber, RegisterType registerType, BitSet verifiedInstructions) {
+ assert registerNumber >= 0 && registerNumber < postRegisterMap.length;
+ assert registerType != null;
+
+ RegisterType oldRegisterType = preRegisterMap[registerNumber];
+ RegisterType mergedRegisterType = oldRegisterType.merge(registerType);
+
+ if (mergedRegisterType.equals(oldRegisterType)) {
+ return false;
+ }
+
+ preRegisterMap[registerNumber] = mergedRegisterType;
+ verifiedInstructions.clear(instructionIndex);
+
+ if (!setsRegister(registerNumber)) {
+ postRegisterMap[registerNumber] = mergedRegisterType;
+ return true;
+ }
+
+ return false;
+ }
+
+ /**
+ * Iterates over the predecessors of this instruction, and merges all the post-instruction register types for the
+ * given register. Any dead, unreachable, or odexed predecessor is ignored
+ * @param registerNumber the register number
+ * @return The register type resulting from merging the post-instruction register types from all predecessors
+ */
+ protected RegisterType mergePreRegisterTypeFromPredecessors(int registerNumber) {
+ RegisterType mergedRegisterType = null;
+ for (AnalyzedInstruction predecessor: predecessors) {
+ RegisterType predecessorRegisterType = predecessor.postRegisterMap[registerNumber];
+ assert predecessorRegisterType != null;
+ mergedRegisterType = predecessorRegisterType.merge(mergedRegisterType);
+ }
+ return mergedRegisterType;
+ }
+
+ /*
+ * Sets the "post-instruction" register type as indicated.
+ * @param registerNumber Which register to set
+ * @param registerType The "post-instruction" register type
+ * @returns true if the given register type is different than the existing post-instruction register type
+ */
+ protected boolean setPostRegisterType(int registerNumber, RegisterType registerType) {
+ assert registerNumber >= 0 && registerNumber < postRegisterMap.length;
+ assert registerType != null;
+
+ RegisterType oldRegisterType = postRegisterMap[registerNumber];
+ if (oldRegisterType.equals(registerType)) {
+ return false;
+ }
+
+ postRegisterMap[registerNumber] = registerType;
+ return true;
+ }
+
+
+ protected boolean isInvokeInit() {
+ if (instruction == null || !instruction.getOpcode().canInitializeReference()) {
+ return false;
+ }
+
+ ReferenceInstruction instruction = (ReferenceInstruction)this.instruction;
+
+ Reference reference = instruction.getReference();
+ if (reference instanceof MethodReference) {
+ return ((MethodReference)reference).getName().equals("");
+ }
+
+ return false;
+ }
+
+ public boolean setsRegister() {
+ return instruction.getOpcode().setsRegister();
+ }
+
+ public boolean setsWideRegister() {
+ return instruction.getOpcode().setsWideRegister();
+ }
+
+ public boolean setsRegister(int registerNumber) {
+ //When constructing a new object, the register type will be an uninitialized reference after the new-instance
+ //instruction, but becomes an initialized reference once the method is called. So even though invoke
+ //instructions don't normally change any registers, calling an method will change the type of its
+ //object register. If the uninitialized reference has been copied to other registers, they will be initialized
+ //as well, so we need to check for that too
+ if (isInvokeInit()) {
+ int destinationRegister;
+ if (instruction instanceof FiveRegisterInstruction) {
+ destinationRegister = ((FiveRegisterInstruction)instruction).getRegisterC();
+ } else {
+ assert instruction instanceof RegisterRangeInstruction;
+ RegisterRangeInstruction rangeInstruction = (RegisterRangeInstruction)instruction;
+ assert rangeInstruction.getRegisterCount() > 0;
+ destinationRegister = rangeInstruction.getStartRegister();
+ }
+
+ if (registerNumber == destinationRegister) {
+ return true;
+ }
+ RegisterType preInstructionDestRegisterType = getPreInstructionRegisterType(registerNumber);
+ if (preInstructionDestRegisterType.category != RegisterType.UNINIT_REF &&
+ preInstructionDestRegisterType.category != RegisterType.UNINIT_THIS) {
+
+ return false;
+ }
+ //check if the uninit ref has been copied to another register
+ if (getPreInstructionRegisterType(registerNumber).equals(preInstructionDestRegisterType)) {
+ return true;
+ }
+ return false;
+ }
+
+ if (!setsRegister()) {
+ return false;
+ }
+ int destinationRegister = getDestinationRegister();
+
+ if (registerNumber == destinationRegister) {
+ return true;
+ }
+ if (setsWideRegister() && registerNumber == (destinationRegister + 1)) {
+ return true;
+ }
+ return false;
+ }
+
+ public int getDestinationRegister() {
+ if (!this.instruction.getOpcode().setsRegister()) {
+ throw new ExceptionWithContext("Cannot call getDestinationRegister() for an instruction that doesn't " +
+ "store a value");
+ }
+ return ((OneRegisterInstruction)instruction).getRegisterA();
+ }
+
+ public int getRegisterCount() {
+ return postRegisterMap.length;
+ }
+
+ @Nonnull
+ public RegisterType getPostInstructionRegisterType(int registerNumber) {
+ return postRegisterMap[registerNumber];
+ }
+
+ @Nonnull
+ public RegisterType getPreInstructionRegisterType(int registerNumber) {
+ return preRegisterMap[registerNumber];
+ }
+
+ public int compareTo(AnalyzedInstruction analyzedInstruction) {
+ if (instructionIndex < analyzedInstruction.instructionIndex) {
+ return -1;
+ } else if (instructionIndex == analyzedInstruction.instructionIndex) {
+ return 0;
+ } else {
+ return 1;
+ }
+ }
+}
+
diff --git a/src/org/jf/dexlib2/analysis/ArrayProto.java b/src/org/jf/dexlib2/analysis/ArrayProto.java
new file mode 100644
index 0000000..8fcfc8c
--- /dev/null
+++ b/src/org/jf/dexlib2/analysis/ArrayProto.java
@@ -0,0 +1,166 @@
+/*
+ * Copyright 2013, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ * * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.dexlib2.analysis;
+
+import com.google.common.base.Strings;
+import org.jf.dexlib2.iface.reference.FieldReference;
+import org.jf.dexlib2.iface.reference.MethodReference;
+import org.jf.dexlib2.immutable.reference.ImmutableFieldReference;
+import org.jf.dexlib2.util.TypeUtils;
+import org.jf.util.ExceptionWithContext;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+public class ArrayProto implements TypeProto {
+ protected final ClassPath classPath;
+ protected final int dimensions;
+ protected final String elementType;
+
+ public ArrayProto(@Nonnull ClassPath classPath, @Nonnull String type) {
+ this.classPath = classPath;
+ int i=0;
+ while (type.charAt(i) == '[') {
+ i++;
+ if (i == type.length()) {
+ throw new ExceptionWithContext("Invalid array type: %s", type);
+ }
+ }
+
+ if (i == 0) {
+ throw new ExceptionWithContext("Invalid array type: %s", type);
+ }
+
+ dimensions = i;
+ elementType = type.substring(i);
+ }
+
+ @Override public String toString() { return getType(); }
+ @Nonnull @Override public ClassPath getClassPath() { return classPath; }
+ @Nonnull @Override public String getType() { return makeArrayType(elementType, dimensions); }
+ public int getDimensions() { return dimensions; }
+ @Override public boolean isInterface() { return false; }
+
+ /**
+ * @return The base element type of this array. E.g. This would return Ljava/lang/String; for [[Ljava/lang/String;
+ */
+ @Nonnull public String getElementType() { return elementType; }
+
+ /**
+ * @return The immediate element type of this array. E.g. This would return [Ljava/lang/String; for
+ * [[Ljava/lang/String;
+ */
+ @Nonnull public String getImmediateElementType() {
+ if (dimensions > 1) {
+ return makeArrayType(elementType, dimensions-1);
+ }
+ return elementType;
+ }
+
+ @Override public boolean implementsInterface(@Nonnull String iface) {
+ return iface.equals("Ljava/lang/Cloneable;") || iface.equals("Ljava/io/Serializable;");
+ }
+
+ @Nullable @Override
+ public String getSuperclass() {
+ return "Ljava/lang/Object;";
+ }
+
+ @Nonnull @Override
+ public TypeProto getCommonSuperclass(@Nonnull TypeProto other) {
+ if (other instanceof ArrayProto) {
+ if (TypeUtils.isPrimitiveType(getElementType()) ||
+ TypeUtils.isPrimitiveType(((ArrayProto)other).getElementType())) {
+ if (dimensions == ((ArrayProto)other).dimensions &&
+ getElementType().equals(((ArrayProto)other).getElementType())) {
+ return this;
+ }
+ return classPath.getClass("Ljava/lang/Object;");
+ }
+
+ if (dimensions == ((ArrayProto)other).dimensions) {
+ TypeProto thisClass = classPath.getClass(elementType);
+ TypeProto otherClass = classPath.getClass(((ArrayProto)other).elementType);
+ TypeProto mergedClass = thisClass.getCommonSuperclass(otherClass);
+ if (thisClass == mergedClass) {
+ return this;
+ }
+ if (otherClass == mergedClass) {
+ return other;
+ }
+ return classPath.getClass(makeArrayType(mergedClass.getType(), dimensions));
+ }
+
+ int dimensions = Math.min(this.dimensions, ((ArrayProto)other).dimensions);
+ return classPath.getClass(makeArrayType("Ljava/lang/Object;", dimensions));
+ }
+
+ if (other instanceof ClassProto) {
+ try {
+ if (other.isInterface()) {
+ if (implementsInterface(other.getType())) {
+ return other;
+ }
+ }
+ } catch (UnresolvedClassException ex) {
+ // ignore
+ }
+ return classPath.getClass("Ljava/lang/Object;");
+ }
+
+ // otherwise, defer to the other class' getCommonSuperclass
+ return other.getCommonSuperclass(this);
+ }
+
+ private static final String BRACKETS = Strings.repeat("[", 256);
+
+ @Nonnull
+ private static String makeArrayType(@Nonnull String elementType, int dimensions) {
+ return BRACKETS.substring(0, dimensions) + elementType;
+ }
+
+
+ @Override
+ @Nullable
+ public FieldReference getFieldByOffset(int fieldOffset) {
+ if (fieldOffset==8) {
+ return new ImmutableFieldReference(getType(), "length", "int");
+ }
+ return null;
+ }
+
+ @Override
+ @Nullable
+ public MethodReference getMethodByVtableIndex(int vtableIndex) {
+ return classPath.getClass("Ljava/lang/Object;").getMethodByVtableIndex(vtableIndex);
+ }
+}
diff --git a/src/org/jf/dexlib2/analysis/ClassPath.java b/src/org/jf/dexlib2/analysis/ClassPath.java
new file mode 100644
index 0000000..c7980e5
--- /dev/null
+++ b/src/org/jf/dexlib2/analysis/ClassPath.java
@@ -0,0 +1,222 @@
+/*
+ * Copyright 2013, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ * * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.dexlib2.analysis;
+
+import com.android.reverse.util.Logger;
+import com.google.common.cache.CacheBuilder;
+import com.google.common.cache.CacheLoader;
+import com.google.common.cache.LoadingCache;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import org.jf.dexlib2.DexFileFactory;
+import org.jf.dexlib2.analysis.reflection.ReflectionClassDef;
+import org.jf.dexlib2.iface.ClassDef;
+import org.jf.dexlib2.iface.DexFile;
+import org.jf.dexlib2.immutable.ImmutableDexFile;
+import org.jf.util.ExceptionWithContext;
+
+import javax.annotation.Nonnull;
+import java.io.File;
+import java.io.IOException;
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class ClassPath {
+ @Nonnull private final TypeProto unknownClass;
+ @Nonnull private HashMap availableClasses = Maps.newHashMap();
+ private int api;
+
+ /**
+ * Creates a new ClassPath instance that can load classes from the given dex files
+ *
+ * @param classPath An array of DexFile objects. When loading a class, these dex files will be searched in order
+ */
+ public ClassPath(DexFile... classPath) throws IOException {
+ this(Lists.newArrayList(classPath), 15);
+ }
+
+ /**
+ * Creates a new ClassPath instance that can load classes from the given dex files
+ *
+ * @param classPath An iterable of DexFile objects. When loading a class, these dex files will be searched in order
+ * @param api API level
+ */
+ public ClassPath(@Nonnull Iterable classPath, int api) {
+ // add fallbacks for certain special classes that must be present
+ Iterable dexFiles = Iterables.concat(classPath, Lists.newArrayList(getBasicClasses()));
+
+ unknownClass = new UnknownClassProto(this);
+ loadedClasses.put(unknownClass.getType(), unknownClass);
+ this.api = api;
+
+ loadPrimitiveType("Z");
+ loadPrimitiveType("B");
+ loadPrimitiveType("S");
+ loadPrimitiveType("C");
+ loadPrimitiveType("I");
+ loadPrimitiveType("J");
+ loadPrimitiveType("F");
+ loadPrimitiveType("D");
+ loadPrimitiveType("L");
+ //Logger.log("add the classinfo by classpath");
+ for (DexFile dexFile: dexFiles) {
+ for (ClassDef classDef: dexFile.getClasses()) {
+ ClassDef prev = availableClasses.get(classDef.getType());
+ if (prev == null) {
+ availableClasses.put(classDef.getType(), classDef);
+ //Logger.log("add the calldef "+classDef.getType());
+ }
+ }
+ }
+ //Logger.log("end the classinfo by classpath");
+ }
+
+ private void loadPrimitiveType(String type) {
+ loadedClasses.put(type, new PrimitiveProto(this, type));
+ }
+
+ private static DexFile getBasicClasses() {
+ // fallbacks for some special classes that we assume are present
+ return new ImmutableDexFile(ImmutableSet.of(
+ new ReflectionClassDef(Class.class),
+ new ReflectionClassDef(Cloneable.class),
+ new ReflectionClassDef(Object.class),
+ new ReflectionClassDef(Serializable.class),
+ new ReflectionClassDef(String.class),
+ new ReflectionClassDef(Throwable.class)));
+ }
+
+ @Nonnull
+ public TypeProto getClass(CharSequence type) {
+ return loadedClasses.getUnchecked(type.toString());
+ }
+
+ private final CacheLoader classLoader = new CacheLoader() {
+ @Override public TypeProto load(String type) throws Exception {
+ if (type.charAt(0) == '[') {
+ return new ArrayProto(ClassPath.this, type);
+ } else {
+ return new ClassProto(ClassPath.this, type);
+ }
+ }
+ };
+
+ @Nonnull private LoadingCache loadedClasses = CacheBuilder.newBuilder().build(classLoader);
+
+ @Nonnull
+ public ClassDef getClassDef(String type) {
+ ClassDef ret = availableClasses.get(type);
+ if (ret == null) {
+ throw new UnresolvedClassException("Could not resolve class %s", type);
+ }
+ return ret;
+ }
+
+ @Nonnull
+ public TypeProto getUnknownClass() {
+ return unknownClass;
+ }
+
+ public int getApi() {
+ return api;
+ }
+
+ @Nonnull
+ public static ClassPath fromClassPath(Iterable classPathDirs, Iterable classPath, DexFile dexFile,
+ int api) {
+ ArrayList dexFiles = Lists.newArrayList();
+
+ for (String classPathEntry: classPath) {
+ dexFiles.add(loadClassPathEntry(classPathDirs, classPathEntry, api));
+ }
+ dexFiles.add(dexFile);
+ return new ClassPath(dexFiles, api);
+ }
+
+ private static final Pattern dalvikCacheOdexPattern = Pattern.compile("@([^@]+)@classes.dex$");
+
+ @Nonnull
+ private static DexFile loadClassPathEntry(@Nonnull Iterable classPathDirs,
+ @Nonnull String bootClassPathEntry, int api) {
+ File rawEntry = new File(bootClassPathEntry);
+ // strip off the path - we only care about the filename
+ String entryName = rawEntry.getName();
+
+ // if it's a dalvik-cache entry, grab the name of the jar/apk
+ if (entryName.endsWith("@classes.dex")) {
+ Matcher m = dalvikCacheOdexPattern.matcher(entryName);
+
+ if (!m.find()) {
+ throw new ExceptionWithContext(String.format("Cannot parse dependency value %s", bootClassPathEntry));
+ }
+
+ entryName = m.group(1);
+ }
+
+ int extIndex = entryName.lastIndexOf(".");
+
+ String baseEntryName;
+ if (extIndex == -1) {
+ baseEntryName = entryName;
+ } else {
+ baseEntryName = entryName.substring(0, extIndex);
+ }
+
+ for (String classPathDir: classPathDirs) {
+ for (String ext: new String[]{"", ".odex", ".jar", ".apk", ".zip"}) {
+ File file = new File(classPathDir, baseEntryName + ext);
+
+ if (file.exists() && file.isFile()) {
+ if (!file.canRead()) {
+ System.err.println(String.format(
+ "warning: cannot open %s for reading. Will continue looking.", file.getPath()));
+ } else {
+ try {
+ return DexFileFactory.loadDexFile(file, api);
+ } catch (DexFileFactory.NoClassesDexException ex) {
+ // ignore and continue
+ } catch (Exception ex) {
+ throw ExceptionWithContext.withContext(ex,
+ "Error while reading boot class path entry \"%s\"", bootClassPathEntry);
+ }
+ }
+ }
+ }
+ }
+ throw new ExceptionWithContext("Cannot locate boot class path file %s", bootClassPathEntry);
+ }
+}
diff --git a/src/org/jf/dexlib2/analysis/ClassProto.java b/src/org/jf/dexlib2/analysis/ClassProto.java
new file mode 100644
index 0000000..0665f0c
--- /dev/null
+++ b/src/org/jf/dexlib2/analysis/ClassProto.java
@@ -0,0 +1,675 @@
+/*
+ * Copyright 2013, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ * * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.dexlib2.analysis;
+
+import com.google.common.base.Predicates;
+import com.google.common.base.Supplier;
+import com.google.common.base.Suppliers;
+import com.google.common.collect.FluentIterable;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import org.jf.dexlib2.AccessFlags;
+import org.jf.dexlib2.analysis.util.TypeProtoUtils;
+import org.jf.dexlib2.iface.ClassDef;
+import org.jf.dexlib2.iface.Field;
+import org.jf.dexlib2.iface.Method;
+import org.jf.dexlib2.iface.reference.FieldReference;
+import org.jf.dexlib2.iface.reference.MethodReference;
+import org.jf.dexlib2.immutable.ImmutableMethod;
+import org.jf.util.ExceptionWithContext;
+import org.jf.util.SparseArray;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.List;
+
+/**
+ * A class "prototype". This contains things like the interfaces, the superclass, the vtable and the instance fields
+ * and their offsets.
+ */
+public class ClassProto implements TypeProto {
+ @Nonnull protected final ClassPath classPath;
+ @Nonnull protected final String type;
+
+ protected boolean vtableFullyResolved = true;
+ protected boolean interfacesFullyResolved = true;
+
+ public ClassProto(@Nonnull ClassPath classPath, @Nonnull String type) {
+ if (type.charAt(0) != 'L') {
+ throw new ExceptionWithContext("Cannot construct ClassProto for non reference type: %s", type);
+ }
+ this.classPath = classPath;
+ this.type = type;
+ }
+
+ @Override public String toString() { return type; }
+ @Nonnull @Override public ClassPath getClassPath() { return classPath; }
+ @Nonnull @Override public String getType() { return type; }
+
+ @Nonnull
+ public ClassDef getClassDef() {
+ return classDefSupplier.get();
+ }
+
+
+ @Nonnull private final Supplier classDefSupplier = Suppliers.memoize(new Supplier() {
+ @Override public ClassDef get() {
+ return classPath.getClassDef(type);
+ }
+ });
+
+ /**
+ * Returns true if this class is an interface.
+ *
+ * If this class is not defined, then this will throw an UnresolvedClassException
+ *
+ * @return True if this class is an interface
+ */
+ public boolean isInterface() {
+ ClassDef classDef = getClassDef();
+ return (classDef.getAccessFlags() & AccessFlags.INTERFACE.getValue()) != 0;
+ }
+
+ /**
+ * Returns the set of interfaces that this class implements as a Map.
+ *
+ * The ClassDef value will be present only for the interfaces that this class directly implements (including any
+ * interfaces transitively implemented), but not for any interfaces that are only implemented by a superclass of
+ * this class
+ *
+ * For any interfaces that are only implemented by a superclass (or the class itself, if the class is an interface),
+ * the value will be null.
+ *
+ * If any interface couldn't be resolved, then the interfacesFullyResolved field will be set to false upon return.
+ *
+ * @return the set of interfaces that this class implements as a Map.
+ */
+ @Nonnull
+ protected LinkedHashMap getInterfaces() {
+ return interfacesSupplier.get();
+ }
+
+ @Nonnull
+ private final Supplier> interfacesSupplier =
+ Suppliers.memoize(new Supplier>() {
+ @Override public LinkedHashMap get() {
+ LinkedHashMap interfaces = Maps.newLinkedHashMap();
+
+ try {
+ for (String interfaceType: getClassDef().getInterfaces()) {
+ if (!interfaces.containsKey(interfaceType)) {
+ ClassDef interfaceDef;
+ try {
+ interfaceDef = classPath.getClassDef(interfaceType);
+ interfaces.put(interfaceType, interfaceDef);
+ } catch (UnresolvedClassException ex) {
+ interfaces.put(interfaceType, null);
+ interfacesFullyResolved = false;
+ }
+
+ ClassProto interfaceProto = (ClassProto) classPath.getClass(interfaceType);
+ for (String superInterface: interfaceProto.getInterfaces().keySet()) {
+ if (!interfaces.containsKey(superInterface)) {
+ interfaces.put(superInterface, interfaceProto.getInterfaces().get(superInterface));
+ }
+ }
+ if (!interfaceProto.interfacesFullyResolved) {
+ interfacesFullyResolved = false;
+ }
+ }
+ }
+ } catch (UnresolvedClassException ex) {
+ interfacesFullyResolved = false;
+ }
+
+ // now add self and super class interfaces, required for common super class lookup
+ // we don't really need ClassDef's for that, so let's just use null
+
+ if (isInterface() && !interfaces.containsKey(getType())) {
+ interfaces.put(getType(), null);
+ }
+
+ try {
+ String superclass = getSuperclass();
+ if (superclass != null) {
+ ClassProto superclassProto = (ClassProto) classPath.getClass(superclass);
+ for (String superclassInterface: superclassProto.getInterfaces().keySet()) {
+ if (!interfaces.containsKey(superclassInterface)) {
+ interfaces.put(superclassInterface, null);
+ }
+ }
+ if (!superclassProto.interfacesFullyResolved) {
+ interfacesFullyResolved = false;
+ }
+ }
+ } catch (UnresolvedClassException ex) {
+ interfacesFullyResolved = false;
+ }
+
+ return interfaces;
+ }
+ });
+
+ /**
+ * Gets the interfaces directly implemented by this class, or the interfaces they transitively implement.
+ *
+ * This does not include any interfaces that are only implemented by a superclass
+ *
+ * @return An iterables of ClassDefs representing the directly or transitively implemented interfaces
+ * @throws UnresolvedClassException if interfaces could not be fully resolved
+ */
+ @Nonnull
+ protected Iterable getDirectInterfaces() {
+ Iterable directInterfaces =
+ FluentIterable.from(getInterfaces().values()).filter(Predicates.notNull());
+
+ if (!interfacesFullyResolved) {
+ throw new UnresolvedClassException("Interfaces for class %s not fully resolved", getType());
+ }
+
+ return directInterfaces;
+ }
+
+ /**
+ * Checks if this class implements the given interface.
+ *
+ * If the interfaces of this class cannot be fully resolved then this
+ * method will either return true or throw an UnresolvedClassException
+ *
+ * @param iface The interface to check for
+ * @return true if this class implements the given interface, otherwise false
+ * @throws UnresolvedClassException if the interfaces for this class could not be fully resolved, and the interface
+ * is not one of the interfaces that were successfully resolved
+ */
+ @Override
+ public boolean implementsInterface(@Nonnull String iface) {
+ if (getInterfaces().containsKey(iface)) {
+ return true;
+ }
+ if (!interfacesFullyResolved) {
+ throw new UnresolvedClassException("Interfaces for class %s not fully resolved", getType());
+ }
+ return false;
+ }
+
+ @Nullable @Override
+ public String getSuperclass() {
+ return getClassDef().getSuperclass();
+ }
+
+ /**
+ * This is a helper method for getCommonSuperclass
+ *
+ * It checks if this class is an interface, and if so, if other implements it.
+ *
+ * If this class is undefined, we go ahead and check if it is listed in other's interfaces. If not, we throw an
+ * UndefinedClassException
+ *
+ * If the interfaces of other cannot be fully resolved, we check the interfaces that can be resolved. If not found,
+ * we throw an UndefinedClassException
+ *
+ * @param other The class to check the interfaces of
+ * @return true if this class is an interface (or is undefined) other implements this class
+ *
+ */
+ private boolean checkInterface(@Nonnull ClassProto other) {
+ boolean isResolved = true;
+ boolean isInterface = true;
+ try {
+ isInterface = isInterface();
+ } catch (UnresolvedClassException ex) {
+ isResolved = false;
+ // if we don't know if this class is an interface or not,
+ // we can still try to call other.implementsInterface(this)
+ }
+ if (isInterface) {
+ try {
+ if (other.implementsInterface(getType())) {
+ return true;
+ }
+ } catch (UnresolvedClassException ex) {
+ // There are 2 possibilities here, depending on whether we were able to resolve this class.
+ // 1. If this class is resolved, then we know it is an interface class. The other class either
+ // isn't defined, or its interfaces couldn't be fully resolved.
+ // In this case, we throw an UnresolvedClassException
+ // 2. If this class is not resolved, we had tried to call implementsInterface anyway. We don't
+ // know for sure if this class is an interface or not. We return false, and let processing
+ // continue in getCommonSuperclass
+ if (isResolved) {
+ throw ex;
+ }
+ }
+ }
+ return false;
+ }
+
+ @Override @Nonnull
+ public TypeProto getCommonSuperclass(@Nonnull TypeProto other) {
+ // use the other type's more specific implementation
+ if (!(other instanceof ClassProto)) {
+ return other.getCommonSuperclass(this);
+ }
+
+ if (this == other || getType().equals(other.getType())) {
+ return this;
+ }
+
+ if (this.getType().equals("Ljava/lang/Object;")) {
+ return this;
+ }
+
+ if (other.getType().equals("Ljava/lang/Object;")) {
+ return other;
+ }
+
+ boolean gotException = false;
+ try {
+ if (checkInterface((ClassProto)other)) {
+ return this;
+ }
+ } catch (UnresolvedClassException ex) {
+ gotException = true;
+ }
+
+ try {
+ if (((ClassProto)other).checkInterface(this)) {
+ return other;
+ }
+ } catch (UnresolvedClassException ex) {
+ gotException = true;
+ }
+ if (gotException) {
+ return classPath.getUnknownClass();
+ }
+
+ List thisChain = Lists.newArrayList(this);
+ Iterables.addAll(thisChain, TypeProtoUtils.getSuperclassChain(this));
+
+ List otherChain = Lists.newArrayList(other);
+ Iterables.addAll(otherChain, TypeProtoUtils.getSuperclassChain(other));
+
+ // reverse them, so that the first entry is either Ljava/lang/Object; or Ujava/lang/Object;
+ thisChain = Lists.reverse(thisChain);
+ otherChain = Lists.reverse(otherChain);
+
+ for (int i=Math.min(thisChain.size(), otherChain.size())-1; i>=0; i--) {
+ TypeProto typeProto = thisChain.get(i);
+ if (typeProto.getType().equals(otherChain.get(i).getType())) {
+ return typeProto;
+ }
+ }
+
+ return classPath.getUnknownClass();
+ }
+
+ @Override
+ @Nullable
+ public FieldReference getFieldByOffset(int fieldOffset) {
+ if (getInstanceFields().size() == 0) {
+ return null;
+ }
+ return getInstanceFields().get(fieldOffset);
+ }
+
+ @Override
+ @Nullable
+ public MethodReference getMethodByVtableIndex(int vtableIndex) {
+ List vtable = getVtable();
+ if (vtableIndex < 0 || vtableIndex >= vtable.size()) {
+ return null;
+ }
+
+ return vtable.get(vtableIndex);
+ }
+
+ @Nonnull SparseArray getInstanceFields() {
+ return instanceFieldsSupplier.get();
+ }
+
+ @Nonnull private final Supplier> instanceFieldsSupplier =
+ Suppliers.memoize(new Supplier>() {
+ @Override public SparseArray get() {
+ //This is a bit of an "involved" operation. We need to follow the same algorithm that dalvik uses to
+ //arrange fields, so that we end up with the same field offsets (which is needed for deodexing).
+ //See mydroid/dalvik/vm/oo/Class.c - computeFieldOffsets()
+
+ final byte REFERENCE = 0;
+ final byte WIDE = 1;
+ final byte OTHER = 2;
+
+ ArrayList fields = getSortedInstanceFields(getClassDef());
+ final int fieldCount = fields.size();
+ //the "type" for each field in fields. 0=reference,1=wide,2=other
+ byte[] fieldTypes = new byte[fields.size()];
+ for (int i=0; i front) {
+ if (fieldTypes[back] == REFERENCE) {
+ swap(fieldTypes, fields, front, back--);
+ break;
+ }
+ back--;
+ }
+ }
+
+ if (fieldTypes[front] != REFERENCE) {
+ break;
+ }
+ }
+
+ int startFieldOffset = 8;
+ String superclassType = getSuperclass();
+ ClassProto superclass = null;
+ if (superclassType != null) {
+ superclass = (ClassProto) classPath.getClass(superclassType);
+ if (superclass != null) {
+ startFieldOffset = superclass.getNextFieldOffset();
+ }
+ }
+
+ int fieldIndexMod;
+ if ((startFieldOffset % 8) == 0) {
+ fieldIndexMod = 0;
+ } else {
+ fieldIndexMod = 1;
+ }
+
+ //next, we need to group all the wide fields after the reference fields. But the wide fields have to be
+ //8-byte aligned. If we're on an odd field index, we need to insert a 32-bit field. If the next field
+ //is already a 32-bit field, use that. Otherwise, find the first 32-bit field from the end and swap it in.
+ //If there are no 32-bit fields, do nothing for now. We'll add padding when calculating the field offsets
+ if (front < fieldCount && (front % 2) != fieldIndexMod) {
+ if (fieldTypes[front] == WIDE) {
+ //we need to swap in a 32-bit field, so the wide fields will be correctly aligned
+ back = fieldCount - 1;
+ while (back > front) {
+ if (fieldTypes[back] == OTHER) {
+ swap(fieldTypes, fields, front++, back);
+ break;
+ }
+ back--;
+ }
+ } else {
+ //there's already a 32-bit field here that we can use
+ front++;
+ }
+ }
+
+ //do the swap thing for wide fields
+ back = fieldCount - 1;
+ for (; front front) {
+ if (fieldTypes[back] == WIDE) {
+ swap(fieldTypes, fields, front, back--);
+ break;
+ }
+ back--;
+ }
+ }
+
+ if (fieldTypes[front] != WIDE) {
+ break;
+ }
+ }
+
+ SparseArray superFields;
+ if (superclass != null) {
+ superFields = superclass.getInstanceFields();
+ } else {
+ superFields = new SparseArray();
+ }
+ int superFieldCount = superFields.size();
+
+ //now the fields are in the correct order. Add them to the SparseArray and lookup, and calculate the offsets
+ int totalFieldCount = superFieldCount + fieldCount;
+ SparseArray instanceFields = new SparseArray(totalFieldCount);
+
+ int fieldOffset;
+
+ if (superclass != null && superFieldCount > 0) {
+ for (int i=0; i getSortedInstanceFields(@Nonnull ClassDef classDef) {
+ ArrayList fields = Lists.newArrayList(classDef.getInstanceFields());
+ Collections.sort(fields);
+ return fields;
+ }
+
+ private byte getFieldType(@Nonnull FieldReference field) {
+ switch (field.getType().charAt(0)) {
+ case '[':
+ case 'L':
+ return 0; //REFERENCE
+ case 'J':
+ case 'D':
+ return 1; //WIDE
+ default:
+ return 2; //OTHER
+ }
+ }
+
+ private void swap(byte[] fieldTypes, List fields, int position1, int position2) {
+ byte tempType = fieldTypes[position1];
+ fieldTypes[position1] = fieldTypes[position2];
+ fieldTypes[position2] = tempType;
+
+ Field tempField = fields.set(position1, fields.get(position2));
+ fields.set(position2, tempField);
+ }
+ });
+
+ private int getNextFieldOffset() {
+ SparseArray instanceFields = getInstanceFields();
+ if (instanceFields.size() == 0) {
+ return 8;
+ }
+
+ int lastItemIndex = instanceFields.size()-1;
+ int fieldOffset = instanceFields.keyAt(lastItemIndex);
+ FieldReference lastField = instanceFields.valueAt(lastItemIndex);
+
+ switch (lastField.getType().charAt(0)) {
+ case 'J':
+ case 'D':
+ return fieldOffset + 8;
+ default:
+ return fieldOffset + 4;
+ }
+ }
+
+ @Nonnull List