安卓逆向系列教程（一）Dalvik 指令集

作者：飞龙

寄存器

Dalvik 指令集完全基于寄存器，也就是说，没有栈。

所有寄存器都是 32 位，无类型的。也就是说，虽然编译器会为每个局部变量分配一个寄存器，但是理论上一个寄存器中可以存放一个int，之后存放一个String（的引用），之后再存放一个别的东西。

如果要处理 64 位的值，需要连续的两个寄存器，但是代码中仍然只写一个寄存器。这种情况下，你在代码中看到的vx实际上是指vx和vx + 1。

寄存器有两种命名方法。v命名法简单直接。假设一共分配了 10 个寄存器，那么我们可以用v0到v9来命名它们。

除此之外，还可以用p命名法来命名参数所用的寄存器，参数会占用后面的几个寄存器。假如上面那个方法是共有两个参数的静态方法，那么，我们就可以使用p0和p1取代v8和v9。如果是实例方法，那么可以用p0 ~ p2取代v7 ~ v9，其中p0是this引用。

但在实际的代码中，一般不会声明所有寄存器的数量，而是直接声明局部变量所用的寄存器（后面会看到）。也就是说局部变量和参数的寄存器是分开声明的。我们无需关心vx是不是py，只需知道所有寄存器的数量是局部变量与参数数量的和。

数据类型

Dalvik 拥有独特的数据类型表示方法，并且和 Java 类型一一对应：

其中对象类型由L<包名>/<类名>;（完全限定名称）表示，要注意末尾有个分号，比如String表示为Ljava/lang/String;。

数组类型是[加上元素类型，比如int[]表示为[I。左方括号的个数也就是数组的维数，比如int[][]表示为[[I。

类定义

一个 smali 文件中存放一个类，文件开头保存类的各种信息。类的定义是这样的。

1. .class <权限修饰符> <非权限修饰符> <完全限定名称>
2. .super <超类的完全限定名称>
3. .source <源文件名>

比如这是某个MainActivity：

1. .class public Lnet/flygon/myapplication/MainActivity;
2. .super Landroid/app/Activity;
3. .source "MainActivity.java"

我们可以看到该类是public的，完整名称是net.flygon.myapplication.MainActivity，继承了android.app.Activity，在源码中是MainActivity.java。如果类是abstract或者final的，会在public/private/protected后面表示。

类可以实现接口，如果类实现了接口，那么这三条语句下面会出现.implements <接口的完全限定名称>。比如通常用于回调的匿名类中会出现.implements Landroid/view/View$OnClickListener;。

类还可以拥有注解，同样，这三条语句下方出现这样的代码：

1. .annotation <完全限定名称>
2. 键 = 值
3. ...
4. .end annotation

这些语句下面就是类拥有的字段和方法。

字段定义

字段定义如下：

1. .field <权限修饰符> <非权限修饰符> <名称>:<类型>

其中非权限修饰符可以为final或者abstract。

比如我在MainActivity中定义一个按钮：

1. .field private button1:Landroid/widget/Button;

方法定义

方法定义如下：

1. .method <权限修饰符> <非权限修饰符> <名称>(<参数类型>)<返回值类型>
2. ...
3. .end method

要注意如果有多个参数，参数之间是紧密挨着的，没有逗号也没有空格。如果某个方法的参数是int, int, String，那么应该表示为IILjava/lang/String;。

.locals

方法里面可以包含很多很多东西，可以说是反编译的重点。首先，方法开头处可能会含有局部变量个数声明和参数声明。.locals <个数>可以用于变量个数声明，比如声明了.locals 10之后，我们就可以直接使用v0到v9的寄存器。

.param

另外，参数虽然也占用寄存器，但是声明是不在一起的。.param px,"<名称>"用于声明参数。不知道是不是必需的。

.prologue

之后.prologue的下面是方法中的代码。代码是接下来要讲的东西。

.line

代码之间可能会出现.line <行号>，用来标识 Java 代码中对应的行，不过这个是非强制性的，修改之后对应不上也无所谓。

.local

还可能出现局部变量声明，.local vx, "<名称>":<类型>。这个也是非强制性的，只是为了让你清楚哪些是具名变量，哪些是临时变量。临时变量没有这种声明，照样正常工作。甚至你把它改成不匹配的类型（int改成Object），也可以正常运行。

数据定义

这些指令会在我们给变量赋字面值的时候用到。下面我们来看看这些指令如何与 Java 代码对应，以下我定义了所有相关类型的变量。

1. boolean z = true;
2. z = false;
3. byte b = 1;
4. short s = 2;
5. int i = 3;
6. long l = 4;
7. float f = 0.1f;
8. double d = 0.2;
9. String str = "test";
10. Class c = Object.class;

编译之后的代码可能是这样：

1. const/4 v10, 0x1
2. const/4 v10, 0x0
3. const/4 v0, 0x1
4. const/4 v8, 0x2
5. const/4 v5, 0x3
6. const-wide/16 v6, 0x4
7. const v4, 0x3dcccccd    # 0.1f
8. const-wide v2, 0x3fc999999999999aL    # 0.2
9. const-string v9, "test"
10. const-class v1, Ljava/lang/Object;

我们可以看到，boolean、byte、short、int都是使用const系列指令来加载的。我们在这里为其赋了比较小的值，所以它用了const/4。如果我们选择一个更大的值，编译器会采用const/16或者const指令。然后我们可以看到const-wide/16用于为long赋值，说明const-wide系列指令用于处理long。

接下来，float使用const指令处理，double使用const-wide指令处理。以float为例，它的const语句的字面值是0x3dcccccd，比较费解。实际上它是保持二进制数据不变，将其表示为int得到的。

我们可以用这段 c 代码来验证。

1. int main() {
2. int i = 0x3dcccccd;
3. float f = *(float *)&i;
4. printf("%f", f);
5. return 0;
6. }

结果是0.100000，的确是我们当初赋值的 0.1。

最后，const-string用于加载字符串，const-class用于加载类对象。虽然文档中写着“字符串的 ID”，但实际的反编译代码中是字符串字面值，比较方便。对于类对象来说，代码中出现的是完全先定名称。

数据移动

数据移动指令就是大名鼎鼎的move：

move系列指令以及move-result用于处理小于等于 32 位的基本类型。move-wide系列指令和move-result-wide用于处理long和double类型。move-object系列指令和move-result-object用于处理对象引用。

另外不同后缀（无、/from16、/16）只影响字节码的位数和寄存器的范围，不影响指令的逻辑。

数据运算

二元运算

二元运算指令格式为<运算类型>-<数据类型> vx,vy,vz。其中算术运算的type可以为int、long、float、double四种（short、byte按int处理），位运算的只支持int、long，下同。

我们可以查看如下代码：

1. int a = 5,
2. b = 2,
3. c = a + b,
4. d = a - b,
5. e = a * b,
6. f = a / b,
7. g = a % b,
8. h = a & b,
9. i = a | b,
10. j = a ^ b,
11. k = a << b,
12. l = a >> b,
13. m = a >>> b;

编译后的代码可能为：

1. const/4 v0, 0x5
2. const/4 v1, 0x2
3. add-int v2, v0, v1
4. sub-int v3, v0, v1
5. mul-int v4, v0, v1
6. div-int v5, v0, v1
7. rem-int v6, v0, v1
8. and-int v7, v0, v1
9. or-int v8, v0, v1
10. xor-int v9, v0, v1
11. shl-int v10, v0, v1
12. shr-int v11, v0, v1
13. ushr-int v12, v0, v1

这里有个特例，当操作数类型是int，并且第二个操作数是字面值的时候，有一组特化的指令：

其中<litn>可以为lit8或lit16，即 8 位或 16 位的整数字面值。比如int a = 0; a += 2;可能编译为const/4 v0, 0和add-int/lit8 v0, v0, 0x2。

二元运算赋值

二元运算赋值指令格式为<运算类型>-<数据类型>/2 vx,vy,vz。

我们可以查看这段代码：

1. int a = 5,
2. b = 2;
3. a += b;
4. a -= b;
5. a *= b;
6. a /= b;
7. a %= b;
8. a &= b;
9. a |= b;
10. a ^= b;
11. a <<= b;
12. a >>= b;
13. a >>>= b;

可能会编译成：

1. const/4 v0, 0x5
2. const/4 v1, 0x2
3. add-int/2addr v0, v1
4. sub-int/2addr v0, v1
5. mul-int/2addr v0, v1
6. div-int/2addr v0, v1
7. rem-int/2addr v0, v1
8. and-int/2addr v0, v1
9. or-int/2addr v0, v1
10. xor-int/2addr v0, v1
11. shl-int/2addr v0, v1
12. shr-int/2addr v0, v1
13. ushr-int/2addr v0, v1

一元运算

简单来说，如果代码为int a = 5, b = -a, c = ~a，并且变量依次分配给v0, v1, v2的话，我们会得到const/4 v0, 0x5、neg-int v1, v0和not-int v2, v0。

跳转

无条件

Java 里面没有goto，但是 Smali 里面有，一般来说和if以及for配合的可能性很大，还有一个作用就是用于代码混淆。

target在 Smali 中是标签，以冒号开头，使用方式是这样：

1. goto :label

3. # 一些语句

5. :label

这三个指令在使用形式上都一样，就是位数越大的语句支持的距离也越长。

条件跳转

if系列指令可用于int（以及short、char、byte、boolean甚至是对象引用）：

看一下这段代码：

1. int a = 10
2. if(a > 0)
3. a = 1;
4. else
5. a = 0;

可能的编译结果是：

1. const/4 v0, 0xa
2. if-lez v0, :cond_0 # if 块开始
3. const/4 v0, 0x1
4. goto :cond_1       # if 块结束
5. :cond_0            # else 块开始
6. const/4 v0, 0x0
7. :cond_1            # else 块结束

我们会看到用于比较逻辑是反着的，Java 里是大于，Smali 中就变成了小于等于，这个要注意。也有一些情况下，逻辑不是反着的，但是if块和else块会对调。还有，标签不一定是一样的，后面的数字会变，但是多数情况下都是两个标签，一个相对跳一个绝对跳。

如果只有if：

1. int a = 10;
2. if(a > 0)
3. a = 1;

相对来说就简单一些，只需要在条件不满足时跳过if块即可：

1. const/4 v0, 0xa
2. if-lez v0, :cond_0 # if 块开始
3. const/4 v0, 0x1
4. :cond_0            # if 块结束

比较

对于long、float和double又该如何比较呢？Dalvik 提供了下面这些指令：

其中sgn(x)是符号函数，定义为：x > 0时值为 1，x = 0时值为 0，x < 0时值为 -1。

我们把之前例子中的int改为float：

1. float a = 10;
2. if(a > 0)
3. a = 1;
4. else
5. a = 0;

我们会得到：

1. const v0, 0x41200000 # float 10
2. const v1, 0x0
3. cmp-float v2, v0, v1
4. if-lez v2, :cond_0   # if 块开始
5. const v0, 0x3f800000 # float 1
6. goto :goto_0         # if 块结束
7. :cond_0              # else 块开始
8. const/4 v0, 0x0
9. :goto_0              # else 块结束

由于cmpg更类似平时使用的比较器，用起来更加顺手，但是cmpl也需要了解。

switch

Dalvik 共支持两种switch，密集和稀疏。先来看密集switch，密集的意思是case的序号是挨着的：

1. int a = 10;
2. switch (a){
3. case 0:
4. a = 1;
5. break;
6. case 1:
7. a = 5;
8. break;
9. case 2:
10. a = 10;
11. break;
12. case 3:
13. a = 20;
14. break;
15. }

编译为：

1. const/16 v0, 0xa

3. packed-switch v0, :pswitch_data_0 # switch 开始

5. :pswitch_0                        # case 0
6. const/4 v0, 0x1
7. goto :goto_0

9. :pswitch_1                        # case 1
10. const/4 v0, 0x5
11. goto :goto_0

13. :pswitch_2                        # case 2
14. const/16 v0, 0xa
15. goto :goto_0

17. :pswitch_3                        # case 3
18. const/16 v0, 0x14
19. goto :goto_0

21. :goto_0                           # switch 结束
22. return-void

24. :pswitch_data_0                   # 跳转表开始
25. .packed-switch 0x0                # 从 0 开始
26. :pswitch_0
27. :pswitch_1
28. :pswitch_2
29. :pswitch_3
30. .end packed-switch                # 跳转表结束

然后是稀疏switch：

1. int a = 10;
2. switch (a){
3. case 0:
4. a = 1;
5. break;
6. case 10:
7. a = 5;
8. break;
9. case 20:
10. a = 10;
11. break;
12. case 30:
13. a = 20;
14. break;
15. }

编译为：

1. const/16 v0, 0xa

3. sparse-switch v0, :sswitch_data_0 # switch 开始

5. :sswitch_0                        # case 0
6. const/4 v0, 0x1
7. goto :goto_0

9. :sswitch_1                        # case 10
10. const/4 v0, 0x5

12. goto :goto_0

14. :sswitch_2                        # case 20
15. const/16 v0, 0xa
16. goto :goto_0

18. :sswitch_3                        # case 15
19. const/16 v0, 0x14
20. goto :goto_0

22. :goto_0                           # switch 结束
23. return-void

25. .line 55
26. :sswitch_data_0                   # 跳转表开始
27. .sparse-switch
28. 0x0 -> :sswitch_0
29. 0xa -> :sswitch_1
30. 0x14 -> :sswitch_2
31. 0x1e -> :sswitch_3
32. .end sparse-switch                # 跳转表结束

数组操作

数组拥有一套特化的指令。

创建

对于第一条指令，如果我们这样写：

1. int[] arr = new int[10];

就可以使用该指令编译：

1. const/4 v1, 0xa
2. new-array v0, v1, I

但如果我们直接使用数组字面值给一个数组赋值：

1. int[] arr = {1, 2, 3, 4, 5};
2. // 或者
3. arr = new int[]{1, 2, 3, 4, 5};

可以使用第二条指令编写如下：

1. const/4 v1, 0x1
2. const/4 v2, 0x2
3. const/4 v3, 0x3
4. const/4 v4, 0x4
5. const/4 v5, 0x5
6. filled-new-array {v1, v2, v3, v4, v5}, I
7. move-result v0

我们这里的寄存器是连续的，实际上不一定是这样，如果寄存器是连续的，还可以改写为第三条指令：

1. const/4 v1, 0x1
2. const/4 v2, 0x2
3. const/4 v3, 0x3
4. const/4 v4, 0x4
5. const/4 v5, 0x5
6. filled-new-array-range {v1..v5}, I
7. move-result v0

元素操作

aget系列指令用于读取数组元素，效果为vx = vy[vz]：

1. aget vx,vy,vz
2. aget-wide vx,vy,vz
3. aget-object vx,vy,vz
4. aget-boolean vx,vy,vz
5. aget-byte vx,vy,vz
6. aget-char vx,vy,vz
7. aget-short vx,vy,vz

有两个指令需要说明，aget用于获取int和float，aget-wide用于获取long和double。

同样，aput系列指令用于写入数组元素，效果为vy[vz] = vx：

1. aget vx,vy,vz
2. aget-wide vx,vy,vz
3. aget-object vx,vy,vz
4. aget-boolean vx,vy,vz
5. aget-byte vx,vy,vz
6. aget-char vx,vy,vz
7. aget-short vx,vy,vz

如果我们编写以下代码：

1. int[] arr = new int[2];
2. int b = arr[0];
3. arr[1] = b;

可能会编译成：

1. const/4 v0, 0x2
2. new-array v1, v0, I
3. const/4 v0, 0x0
4. aget-int v2, v1, v0
5. const/4 v0, 0x1
6. aput-int v2, v1, v0

对象操作

对象创建

new-instance用于创建实例，但之后还需要调用构造器<init>，比如：

1. Object obj = new Object();

会编译成：

1. new-instance v0, Ljava/lang/Object;
2. invoke-direct-empty {v0}, Ljava/lang/Object;-><init>()V

方法调用后面再讲。

字段操作

sget系列指令用于获取静态字段，效果为vx = class.field：

1. sget vx, type->field:field_type
2. sget-wide vx, type->field:field_type
3. sget-object vx, type->field:field_type
4. sget-boolean vx, type->field:field_type
5. sget-byte vx, type->field:field_type
6. sget-char vx, type->field:field_type
7. sget-short vx, type->field:field_type

sput系列指令用于设置静态字段，效果为class.field = vx：

1. sput vx, type->field:field_type
2. sput-wide vx, type->field:field_type
3. sput-object vx, type->field:field_type
4. sput-boolean vx, type->field:field_type
5. sput-byte vx, type->field:field_type
6. sput-char vx, type->field:field_type
7. sput-short vx, type->field:field_type

我们在这里创建一个类：

1. public class Test
2. {
3. private static int staticField;

5. public static int getStaticField() {
6. return staticField;
7. }

9. public static void setStaticField(int staticField) {
10. Test.staticField = staticField;
11. }
12. }

编译之后，我们可以在getStaticField中找到：

1. sget v0, Lnet/flygon/myapplication/Test;->staticField:I
2. return v0

在setStaticField中可以找到：

1. sput p0, Lnet/flygon/myapplication/Test;->staticField:I
2. return-void

iget系列指令用于获取实例字段，效果为vx = vy.field：

1. iget vx, vy, type->field:field_type
2. iget-wide vx, vy, type->field:field_type
3. iget-object vx, vy, type->field:field_type
4. iget-boolean vx, vy, type->field:field_type
5. iget-byte vx, vy, type->field:field_type
6. iget-char vx, vy, type->field:field_type
7. iget-short vx, vy, type->field:field_type

iput系列指令用于设置实例字段，效果为vy.field = vx：

1. iput vx, vy, type->field:field_type
2. iput-wide vx, vy, type->field:field_type
3. iput-object vx, vy, type->field:field_type
4. iput-boolean vx, vy, type->field:field_type
5. iput-byte vx, vy, type->field:field_type
6. iput-char vx, vy, type->field:field_type
7. iput-short vx, vy, type->field:field_type

我们将之前的类修改一下：

1. public class Test
2. {
3. private int instanceField;

5. public int getInstanceField() {
6. return instanceField;
7. }

9. public void setInstanceField(int instanceField) {
10. this.instanceField = instanceField;
11. }
12. }

反编译之后，我们可以在getInstanceField中找到：·

1. iget v0, p0, Lnet/flygon/myapplication/Test;->instanceField:I
2. return v0

在setInstanceField中可以找到：

1. iset p1, p0, Lnet/flygon/myapplication/Test;->instanceField:I
2. return-void

在实例方法中，this引用永远是p0。第一个参数从p1开始。

方法调用

有五类方法调用指令：

这些指令的格式均为：

1. invoke-* {params}, type->method(params_type)return_type

如果需要传递this引用，将其放置在param的第一个位置。

那么这些指令有什么不同呢？首先要分辨两个概念，虚方法和直接方法（JVM 里面叫特殊方法）。其实 Java 是没有虚方法这个概念的，但是 DVM 里面有，直接方法是指类的（type为某个类）所有实例构造器和private实例方法。反之protected或者public方法都叫做虚方法。

invoke-static比较好分辨，当且仅当调用静态方法时，才会使用它。

invoke-direct（在 JVM 中叫做invokespecial）用于调用直接方法，invoke-virtual用于调用虚方法。除了一种情况，显式使用super调用超类的虚方法时，使用invoke-super（直接方法仍然使用invoke-direct）。

就比如说，每个Activity的onCreate中要调用super.onCreate，该方法属于虚方法，于是我们会看到：

1. invoke-super {p0, p1}, Landroid/app/Activity;->onCreate(Landroid/os/Bundle;)V

但是呢，每个Activity构造器里面要调用super的无参构造器，它属于直接方法，那么我们会看到：

1. invoke-direct {p0}, Landroid/app/Activity;-><init>()V

invoke-interface用于调用接口方法，接口方法就是接口的方法，type一定为某个接口，而不是类。换句话说，类中实现的方法仍然是虚方法。比如我们在某个对象上调用Map.get，属于接口方法，但是调用HashMap.get，属于虚方法。这个指令一般在向上转型为接口类型的时候出现。

此外，五类指令中每一个都有对应的invoke-*-range指令，格式为：

1. invoke-*-range {vx..vy},type->method(params_type)return_type

如果参数所在的寄存器的连续的，可以替换为这条指令。

对象转换

对象转换有自己的一套检测方式，DVM 使用以下指令来实现：

instance-of指令对应 Java 的instanceof运算符。如果我们编写：

1. String s = "test";
2. boolean b = s instanceof String;

可能会编译为：

1. const-string v0, "test"
2. instance-of v1, v0, Ljava/lang/String;

check-cast用于对象类型强制转换的情况，如果我们编写：

1. String s = "test";
2. Object o = (Object)s;

那么就会：

1. const-string v0, "test"
2. check-cast v0, Ljava/lang/Object;
3. move-object v1, v0

返回

1. return-void
2. return vx
3. return-wide vx
4. return-object vx

如果函数无返回值，那么使用return-void，注意在 Java 中，无返回值函数结尾处的return可以省，而 Smali 不可以。

如果函数需要返回对象，使用return-object；需要返回long或者double，使用return-wide；除此之外所有情况都使用return。

异常指令

异常指令实际上只有一条，但是代码结构相当复杂。

我们需要看看 Smali 如何处理异常。

try-catch

不失一般性，我们构造以下语句：

1. int a = 10;
2. try {
3. callSomeMethod();
4. } catch (Exception e) {
5. a = 0;
6. }
7. callAnotherMethod();

可能会编译成这样，这些语句每个都不一样，可以按照特征来定位：

1. const/16 v0, 0xa

3. :try_start_0            # try 块开始
4. invoke-direct {p0}, Lnet/flygon/myapplication/SubActivity;->callSomeMethod()V
5. :try_end_0              # try 块结束

7. .catch Ljava/lang/Exception; {:try_start_0 .. :try_end_0} :catch_0

9. :goto_0
10. invoke-direct {p0}, Lnet/flygon/myapplication/SubActivity;->callAnotherMethod()V
11. return-void

13. :catch_0                # catch 块开始
14. move-exception v1
15. const/4 v0, 0x0
16. goto :goto_0            # catch 块结束

我们可以看到，:try_start_0和:try_end_0之间的语句如果存在异常，则会向下寻找.catch（或者.catch-all）语句，符合条件时跳到标签的位置，这里是:catch_0，结束之后会有个goto跳回去。

try-finally

1. int a = 10;
2. try {
3. callSomeMethod();
4. } finally {
5. a = 0;
6. }
7. callAnotherMethod();

编译之后是这样：

1. const/16 v0, 0xa

3. :try_start_0            # try 块开始
4. invoke-direct {p0}, Lnet/flygon/myapplication/SubActivity;->callSomeMethod()V
5. :try_end_0              # try 块结束

7. .catchall {:try_start_0 .. :try_end_0} :catchall_0

9. const/4 v0, 0x0         # 复制一份到外面
10. invoke-direct {p0}, Lnet/flygon/myapplication/SubActivity;->callAnotherMethod()V
11. return-void

13. :catchall_0             # finally 块开始
14. move-exception v1
15. const/4 v0, 0x0
16. throw v1                # finally 块结束

我们可以看到，编译器把finally编译成了重新抛出的.catch-all，这在逻辑上也是说得通的。但是，finally中的逻辑在无异常情况下也会执行，所以需要复制一份到finally块的后面。

try-catch-finally

下面看看如果把这两个叠加起来会怎么样。

1. int a = 10;
2. try {
3. callSomeMethod();
4. } catch (Exception e) {
5. a = 1;
6. }
7. finally {
8. a = 0;
9. }
10. callAnotherMethod();

1. const/16 v0, 0xa

3. :try_start_0            # try 块开始
4. invoke-direct {p0}, Lnet/flygon/myapplication/SubActivity;->callSomeMethod()V
5. :try_end_0              # try 块结束

7. .catch Ljava/lang/Exception; {:try_start_0 .. :try_end_0} :catch_0
8. .catchall {:try_start_0 .. :try_end_0} :catchall_0

10. const/4 v0, 0x0         # 复制一份到外面

12. :goto_0
13. invoke-direct {p0}, Lnet/flygon/myapplication/SubActivity;->callAnotherMethod()V
14. return-void

16. :catch_0                # catch 块开始
17. move-exception v1
18. const/4 v0, 0x1
19. const/4 v0, 0x0         # 复制一份到 catch 块里面
20. goto :goto_0            # catch 块结束

22. :catchall_0             # finally 块开始
23. move-exception v2
24. const/4 v0, 0x0
25. throw v2                # finally 块结束

我们可以看到，其中同时含有.catch块和.catchall块。有一些不同之处在于，finally块中的语句异常发生时也要执行，并且如果把finally编译成.catchall，那么和.catch就是互斥的，所以要复制一份到catch块里面。特别是finally块中的语句一多，就容易乱。

锁

对应 Java 的synchronized语句。而synchronized一般是被try-finally包起来的。

如果你编写：

1. int a = 1;
2. synchronized(this) {
3. a = 2;
4. }

就相当于

1. int a = 1;
2. // monitor-enter this
3. try {
4. a = 2;
5. } finally {
6. // monitor-exit this
7. }

此外 Java 中没有与这两条指令相对应的方法，所以这两条指令一定成对出现。

数据转换

整数与浮点以及浮点与浮点

1. int-to-float vx, vy
2. int-to-double vx, vy
3. long-to-float vx, vy
4. long-to-double vx, vy
5. float-to-int vx, vy
6. float-to-long vx,vy
7. float-to-double vx, vy
8. double-to-int vx, vy
9. double-to-long vx, vy
10. double-to-float vx, vy

因为它们的表示方式不同，所以要保持表示的值不变，重新计算二进制位。如果不转换的话，就相当于二进制位不变，而表示的值改变，结果毫无意义。比如前面的0.1f如果不转换为直接使用，就会表示0x3dcccccd。

整数之间的向上转换

这种转换方式相当直接，int向long转换，long的第一个寄存器完全复制，第二个寄存器以int的最高位填充。除此之外没有其它的指令了，因为比int小的整数其实都是 32 位表示的，只是有效范围是 8 位或 16 位罢了（见数据定义）。

1. int-to-long vx,vy

整数之间的向下转换

其规则是数据位截断，符号位保留。每个整数的最高位都是符号位，其余是数据位。以int转short为例，int的低 15 位复制给short，然后int的最高位（符号位）复制给short的最高位。其它同理。如果不转换而直接使用的话，会直接截断低 16 位，符号可能不能保留。

1. long-to-int vx,vy
2. int-to-byte vx,vy
3. int-to-char vx,vy
4. int-to-short vx,vy

NOP

nop指令表示无操作。在一些场合下，不能修改二进制代码的字节数和偏移，需要用nop来填充，但是安卓逆向中几乎用不到。

参考

• Bytecode for the Dalvik VM
• Dalvik字节码含义查询表
• DVM 指令集图解