阅读 1322

全网最全 Dalvik 指令集解析 !

为什么是全网最全,因为根本没人整理 Dalvik 指令集。。

本文档纯粹作为一个 Dalvik 指令集速查表,相信一定有需要的同学。

文末扫码关注公众号,回复 Dalvik 获取本文档 pdf 版本 !

首先说明 Dalvik 虚拟机的基本约定 。

  • Dalvik 寄存器都是 32 位的,64 位数据使用相邻两个寄存器来存储
  • 下表中提到的寄存器对均指相邻两个寄存器。如寄存器对 vAA,指寄存器 vAA,vAA+1
  • 常规类型的 32 位运算码未做任何标记
  • 64 位操作码以 -wide 作为后缀
  • 一般指令中目标寄存器在前,源寄存器在后
  • 寄存器最大数量为 65536
  • 一个大写字母表示 4 位。如 vA 表示前 16 个寄存器之内,vBB 表示前 256 个寄存器之内,vCCCC 表示前 65536 个寄存器之内

下面解释一下表格中的每项内容。

操作码 :十六进制,范围 00 - ff

格式码 :一般三个字符,前两个为数字,最后为字母。第一个数字表示指令有多少个 16 位的字组成。第二个数字表示指令最多使用的寄存器个数。第三个字母是类型码,表示指令所使用的额外数据的类型。

语法 :助记符,smali 语法中就这么表示

说明 : 指令解释

下表为 00 - ff 的所有 Dalvik 指令 :

操作码 格式码 语法 说明
00 10x nop 空指令
01 12x move vA, vB 将寄存器 vB 的内容赋给寄存器 vA
02 22x move/from16 vAA, vBBBB 将寄存器 vBBBB 的内容赋给寄存器 vAA。vAA 范围是 0-255,vBBBB 范围是 0-65535
03 32x move/16 vAAAA, vBBBB 将寄存器 vBBBB 的内容赋给寄存器 vAAAA。两个寄存器范围都是 0-65535
04 12x move-wide vA, vB 将寄存器对 vB 的内容赋给寄存器对 vA
05 22x move-wide/from16 vAA, vBBBB 将寄存器对 vBBBB 的内容赋给寄存器对 vAA
06 32x move-wide/16 vAAAA, vBBBB 将寄存器对 vBBBB 的内容赋给寄存器对 vAAAA
07 12x move-object vA, vB 将寄存器 vB 中的对象引用赋给寄存去 vA
08 22x move-object/from16 vAA, vBBBB 将寄存器 vBBBB 中的对象引用赋给寄存对 vAA
09 32x move-object/16 vAAAA, vBBBB 将寄存器 vBBBB 中的对象引用赋给寄存去 vAAAA
0a 11x move-result vAA 将上一个 invoke-kind 指令的单字非对象结果存入寄存器 vAA
0b 11x move-result-wide vAA 将上一个 invoke-kind 指令的双字非对象结果存入寄存器 vAA,vAA+1
0c 11x move-result-object vAA 将上一个 invoke-kind 指令的对象结果存入寄存器 vAA
0d 11x move-exception vAA 将方法执行过程中抛出的异常存入寄存器 vAA
0e 10x return-void 返回 void
0f 11x return vAA 返回 32 位非对象值
10 11x return-wide vAA 返回 64 位非对象值
11 11x return-object vAA 返回对象引用
12 11n const/4 vA, #+B 将给定的 4 位字面值符号扩展为 32 位之后赋给寄存器 vA
13 21s const/16 vAA, #+BBBB 将给定的 16 位字面值符号扩展为 32 位之后赋给寄存器 vAA
14 31i const vAA, #+BBBB 将给定的字面值赋给寄存器 vAA
15 21h const/high16 vAA, #+BBBB0000 将给定的字面值右零扩展为 32 位之后赋给寄存器 vAA,vAA+1
16 21s const-wide/16 vAA, #+BBBB 将给定的 16 位字面值符号扩展为 64 位之后赋给寄存器 vAA,vAA+1
17 31i const-wide/32 vAA, #+BBBBBBBB 将给定的 32 位字面值符号扩展为 64 位之后赋给寄存器 vAA,vAA+1
18 51l const-wide vAA, #+BBBBBBBBBBBBBBBB 将给定的 64 位字面值赋给寄存器 vAA,vAA+1
19 21h const-wide/high16 vAA, #+vBBBB000000000000 将给定的 16 位字面值右零扩展为 64 位之后赋给寄存器对 vAA
1a 21c const-string vAA, string@BBBB 将字符串索引 BBBB 指向的字符串引用赋给寄存器 vAA
1b 31c const-string/jumbo vAA, string@BBBBBBBB 将字符串索引 BBBBBBBB 指向的字符串引用赋给寄存器 vAA
1c 21c const-class vAA, type@BBBB 将类型索引 BBBB 指向的类引用赋给寄存器 vAA
1d 11x monitor-enter vAA 获取寄存器 vAA 中对象的监视锁
1e 11x monitor-exit vAA 释放寄存器 vAA 中对象的监视锁
1f 21c check-cast vAA type@BBBB 将寄存器 vAA 中的对象引用转化为 type@BBBB 指定的类型,若失败抛出 ClassCastException
20 22c instance-of vA, vB type@CCCC 判断寄存器 vB 中的对象引用是否为类型 type@CCCC 的实例。如果是给寄存器 vA 赋值为 1,否则赋值为 0
21 12x array-length vA, vB 获取寄存器 vB 中的数组的长度并赋给寄存器 vA
22 21c new-instance vAA, type@vBBBB 构建指定类型 type@BBBB 的实例对象,并将对象引用赋给寄存器 vAA
23 22c new-array vA, vB, type@CCCC 构建指定类型 type@CCCC 和指定大小 vB 的数组,并将数组引用赋给寄存器 vA
24 35c filled-new-array {vC,vD,vE,vF,vG} type@vBBBB 构建指定类型 type@BBBB 和指定大小的数组,并使用提供的内容 vC-vG 填充数组。由于数组内容是给定的,所以无需再使用一个寄存器 vA 指定数组大小
25 3rc filled-new-array/range {vCCCC..vNNNN} type@BBBB 同上,区别是使用一定范围内的寄存器内容来填充数组,数组大小为 N-C+1
26 31t fill-array-data vAA, +BBBB 使用给定数据 BBBB 填充寄存器 vAA 存储的数组,只能是基本类型数组。BBBB 有特定的格式
27 11x throw vAA 抛出寄存器 vAA 指定的异常
28 10t goto +AA 无条件跳转至指定偏移处,偏移量 AA 为 8 位
29 20t goto/16 +AAAA 无条件跳转至指定偏移处,偏移量 AAAA 为 16 位
2a 30t goto/32 +AAAAAAAA 无条件跳转至指定偏移处,偏移量 AAAAAAAA 为 32 位
2b 31t packed-switch vAA, +BBBBBBBB 寄存器 vAA 存储的是是希望跳转的偏移量,BBBBBBBB 是一个偏移量表。基于偏移量表查找匹配项,如果存在则跳转,不存在跳转到下一指令
2c 31t sparse-switch vAA, +BBBBBBBB
2d 23x cmpl-float vAA, vBB, vCC 比较两个单精度浮点数。如果寄存器 vBB 的值大于寄存器 vCC 的值,结果为 -1;如果等于,结果为 0;如果小于,结果为 1。NaN 比较返回 -1。结果赋给寄存器 vAA
2e 23x cmpg-float vAA, vBB, vCC 比较两个单精度浮点数。如果寄存器 vBB 的值大于寄存器 vCC 的值,结果为 1;如果等于,结果为 0;如果小于,结果为 -1。NaN 比较返回 1。结果赋给寄存器 vAA
2f 23x cmpl-double vAA, vBB, vCC 比较两个双精度浮点数。如果寄存器 vBB 的值大于寄存器 vCC 的值,结果为 -1;如果等于,结果为 0;如果小于,结果为 1。NaN 比较返回 -1。结果赋给寄存器 vAA
30 23x cmpg-double vAA, vBB, vCC 比较两个双精度浮点数。如果寄存器 vBB 的值大于寄存器 vCC 的值,结果为 1;如果等于,结果为 0;如果小于,结果为 -1。NaN 比较返回 1。结果赋给寄存器 vAA
31 23x cmp-long vAA, vBB, vCC 比较两个长整型数。如果寄存器 vBB 的值大于寄存器 vCC 的值,结果为 1;如果等于,结果为 0;如果小于,结果为 -1。结果赋给寄存器 vAA
32 22t if-eq vA, vB, +CCCC 如果寄存器 vA 的值等于 vB 的值,则跳转到指定偏移处,偏移量为 CCCC
33 22t if-ne vA, vB, +CCCC 如果寄存器 vA 的值不等于 vB 的值,则跳转到指定偏移处,偏移量为 CCCC
34 22t if-lt vA, vB, +CCCC 如果寄存器 vA 的值小于 vB 的值,则跳转到指定偏移处,偏移量为 CCCC
35 22t if-ge vA, vB, +CCCC 如果寄存器 vA 的值大于等于 vB 的值,则跳转到指定偏移处,偏移量为 CCCC
36 22t if-gt vA, vB, +CCCC 如果寄存器 vA 的值大于 vB 的值,则跳转到指定偏移处,偏移量为 CCCC
37 22t if-le vA, vB, +CCCC 如果寄存器 vA 的值小于等于 vB 的值,则跳转到指定偏移处,偏移量为 CCCC
38 21t if-eqz vAA, +BBBB 如果寄存器 vAA 的值等于 0,则跳转到指定偏移处,偏移量为 BBBB
39 21t if-nez vAA, +BBBB 如果寄存器 vAA 的值不等于 0,则跳转到指定偏移处,偏移量为 BBBB
3a 21t if-ltz vAA, +BBBB 如果寄存器 vAA 的值小于 0,则跳转到指定偏移处,偏移量为 BBBB
3b 21t if-gez vAA, +BBBB 如果寄存器 vAA 的值大于等于 0,则跳转到指定偏移处,偏移量为 BBBB
3c 21t if-gtz vAA, +BBBB 如果寄存器 vAA 的值大于 0,则跳转到指定偏移处,偏移量为 BBBB
3d 21t if-lez vAA, +BBBB 如果寄存器 vAA 的值小于等于 0,则跳转到指定偏移处,偏移量为 BBBB
3e 10x unused
3f 10x unused
40 10x unused
41 10x unused
42 10x unused
43 10x unused
44 23x aget vAA, vBB, vCC 获取寄存器 vBB 存储的数组指定索引处的元素并赋给寄存器 vAA。寄存器 vCC 的值为指定索引
45 23x aget-wide vAA, vBB, vCC 获取寄存器 vBB 存储的数组指定索引处的元素(64 位)并赋给寄存器对 vAA。寄存器 vCC 的值为指定索引
46 23x aget-object vAA, vBB, vCC 获取寄存器 vBB 存储的对象类型数组指定索引处的元素并赋给寄存器 vAA。寄存器 vCC 的值为指定索引
47 23x aget-boolean vAA, vBB, vCC 获取寄存器 vBB 存储的布尔类型数组指定索引处的元素并赋给寄存器 vAA。寄存器 vCC 的值为指定索引
48 23x aget-byte vAA, vBB, vCC 获取寄存器 vBB 存储的 byte 类型数组指定索引处的元素并赋给寄存器 vAA。寄存器 vCC 的值为指定索引
49 23x aget-char vAA, vBB, vCC 获取寄存器 vBB 存储的 char 类型数组指定索引处的元素并赋给寄存器 vAA。寄存器 vCC 的值为指定索引
4a 23x aget-short vAA, vBB, vCC 获取寄存器 vBB 存储的 short 类型数组指定索引处的元素并赋给寄存器 vAA。寄存器 vCC 的值为指定索引
4b 23x aput vAA, vBB, vCC 将寄存器 vAA 的值赋给寄存器 vBB 存储的数组的指定索引处。寄存器 vCC 存储的值为指定索引
4c 23x aput-wide vAA, vBB, vCC 将寄存器对 vAA 的值(64 位)赋给寄存器 vBB 存储的数组的指定索引处。寄存器 vCC 存储的值为指定索引
4d 23x aput-object vAA, vBB, vCC 将寄存器 vAA 存储的对象赋给寄存器 vBB 存储的数组的指定索引处。寄存器 vCC 存储的值为指定索引
4e 23x aput-boolean vAA, vBB, vCC 将寄存器 vAA 存储的布尔值赋给寄存器 vBB 存储的数组的指定索引处。寄存器 vCC 存储的值为指定索引
4f 23x aput-byte vAA, vBB, vCC 将寄存器 vAA 存储的 byte 值赋给寄存器 vBB 存储的数组的指定索引处。寄存器 vCC 存储的值为指定索引
50 23x aput-char vAA, vBB, vCC 将寄存器 vAA 存储的 char 值赋给寄存器 vBB 存储的数组的指定索引处。寄存器 vCC 存储的值为指定索引
51 23x aput-short vAA, vBB, vCC 将寄存器 vAA 存储的 short 值赋给寄存器 vBB 存储的数组的指定索引处。寄存器 vCC 存储的值为指定索引
52 22c iget vA, vB, field@CCCC 获取寄存器 vB 存储的实例的字段,并存入寄存器 vA。字段类型是 CCCC
53 22c iget-wide vA, vB, field@CCCC 获取寄存器 vB 存储的实例的字段,并存入寄存器对 vA。字段类型是 CCCC
54 22c iget-object vA, vB, field@CCCC 获取寄存器 vB 存储的实例的对象类型字段,并存入寄存器 vA。字段类型是 CCCC
55 22c iget-boolean vA, vB, field@CCCC 获取寄存器 vB 存储的实例的 boolean 类型字段,并存入寄存器 vA。字段类型是 CCCC
56 22c iget-byte vA, vB, field@CCCC 获取寄存器 vB 存储的实例的 byte 类型字段,并存入寄存器 vA。字段类型是 CCCC
57 22c iget-char vA, vB, field@CCCC 获取寄存器 vB 存储的实例的 char 类型字段,并存入寄存器 vA。字段类型是 CCCC
58 22c iget-short vA, vB, field@CCCC 获取寄存器 vB 存储的实例的 short 类型字段,并存入寄存器 vA。字段类型是 CCCC
59 22c iput vA, vB, field@CCCC 将寄存器 vA 存储的值赋给寄存器 vB 存储的实例的字段。字段类型是 CCCC
5a 22c iput-wide vA, vB, field@CCCC 将寄存器对 vA 存储的值(64位)赋给寄存器 vB 存储的实例的字段。字段类型是 CCCC
5b 22c iput-object vA, vB, field@CCCC 将寄存器 vA 存储的对象类型值赋给寄存器 vB 存储的实例的字段。字段类型是 CCCC
5c 22c iput-boolean vA, vB, field@CCCC 将寄存器 vA 存储的 boolean 类型值赋给寄存器 vB 存储的实例的字段。字段类型是 CCCC
5d 22c iput-byte vA, vB, field@CCCC 将寄存器 vA 存储的 byte 类型值赋给寄存器 vB 存储的实例的字段。字段类型是 CCCC
5e 22c iput-char vA, vB, field@CCCC 将寄存器 vA 存储的 char 类型值赋给寄存器 vB 存储的实例的字段。字段类型是 CCCC
5f 22c iput-short vA, vB, field@CCCC 将寄存器 vA 存储的 short 类型值赋给寄存器 vB 存储的实例的字段。字段类型是 CCCC
60 21c sget vA, vB, field@CCCC 获取寄存器 vB 存储的实例的静态字段,并存入寄存器 vA。字段类型是 CCCC
61 21c sget-wide vA, vB, field@CCCC 获取寄存器 vB 存储的实例的静态字段,并存入寄存器对 vA。字段类型是 CCCC
62 21c sget-object vA, vB, field@CCCC 获取寄存器 vB 存储的实例的对象类型静态字段,并存入寄存器 vA。字段类型是 CCCC
63 21c sget-boolean vA, vB, field@CCCC 获取寄存器 vB 存储的实例的 boolean 类型静态字段,并存入寄存器 vA。字段类型是 CCCC
64 21c sget-byte vA, vB, field@CCCC 获取寄存器 vB 存储的实例的 byte 类型静态字段,并存入寄存器 vA。字段类型是 CCCC
65 21c sget-char vA, vB, field@CCCC 获取寄存器 vB 存储的实例的 char 类型静态字段,并存入寄存器 vA。字段类型是 CCCC
66 21c sget-short vA, vB, field@CCCC 获取寄存器 vB 存储的实例的 short 类型静态字段,并存入寄存器 vA。字段类型是 CCCC
67 21c sput vA, vB, field@CCCC 将寄存器 vA 存储的值赋给寄存器 vB 存储的实例的静态字段。字段类型是 CCCC
68 21c sput-wide vA, vB, field@CCCC 将寄存器对 vA 存储的值(64位)赋给寄存器 vB 存储的实例的静态字段。字段类型是 CCCC
69 21c sput-object vA, vB, field@CCCC 将寄存器 vA 存储的对象类型值赋给寄存器 vB 存储的实例的静态字段。字段类型是 CCCC
6a 21c sput-boolean vA, vB, field@CCCC 将寄存器 vA 存储的 boolean 类型值赋给寄存器 vB 存储的实例的静态字段。字段类型是 CCCC
6b 21c sput-byte vA, vB, field@CCCC 将寄存器 vA 存储的 byte 类型值赋给寄存器 vB 存储的实例的静态字段。字段类型是 CCCC
6c 21c sput-char vA, vB, field@CCCC 将寄存器 vA 存储的 char 类型值赋给寄存器 vB 存储的实例的静态字段。字段类型是 CCCC
6d 21c sput-short vA, vB, field@CCCC 将寄存器 vA 存储的 short 类型值赋给寄存器 vB 存储的实例的静态字段。字段类型是 CCCC
6e 35c invoke-virtual {vC,vD,vE,vF,vG} meth@BBBB 调用实例的虚方法,C~G 是参数寄存器
6f 35c invoke-super {vC,vD,vE,vF,vG} meth@BBBB 调用实例的父类方法,C~G 是参数寄存器
70 35c invoke-direct {vC,vD,vE,vF,vG} meth@BBBB 调用实例的 private 方法或者构造函数,C~G 是参数寄存器
71 35c invoke-static {vC,vD,vE,vF,vG} meth@BBBB 调用实例的 static 方法,C~G 是参数寄存器
72 35c invoke-interface {vC,vD,vE,vF,vG} meth@BBBB 调用实例的接口方法,C~G 是参数寄存器
73 10x unused
74 3rc invoke-virtual/range {vCCCC..vNNNN} meth@BBBB 同上。只是参数寄存器表示方式不一样。这里直接使用 vCCCC 到 vNNNN 之间的寄存器,而不是单独指定每个寄存器
75 3rc invoke-super/range {vCCCC..vNNNN} meth@BBBB
76 3rc invoke-direct/range {vCCCC..vNNNN} meth@BBBB
77 3rc invoke-static/range {vCCCC..vNNNN} meth@BBBB
78 3rc invoke-interface/range {vCCCC..vNNNN} meth@BBBB
79 10x unused
7a 10x unused
7b 12x neg-int vA, vB 对寄存器 vB 存储的整型数求补并存入寄存器 vA
7c 12x not-int vA, vB 对寄存器 vB 存储的整型数求反并存入寄存器 vA
7d 12x neg-long vA, vB 对寄存器对 vB 存储的长整型数求补并存入寄存器对 vA
7e 12x not-long vA, vB 对寄存器对 vB 存储的长整型数求反并存入寄存器对 vA
7f 12x neg-float vA, vB 对寄存器 vB 存储的单精度浮点数求补并存入寄存器 vA
80 12x neg-double vA, vB 对寄存器对 vB 存储的双精度浮点数求补并存入寄存器对 vA
81 12x int-to-long vA, vB 将寄存器 vB 中的整型数转换为长整型数,并存入寄存器对 vA
82 12x int-to-float vA, vB 将寄存器 vB 中的整型数转换为单精度浮点数,并存入寄存器 vA
83 12x int-to-double vA, vB 将寄存器 vB 中的整型数转换为双精度浮点数,并存入寄存器对 vA
84 12x long-to-int vA, vB 将寄存器对 vB 中的长整型数转换为整型数,并存入寄存器 vA
85 12x long-to-float vA, vB 将寄存器对 vB 中的长整型数转换为单精度浮点数,并存入寄存器 vA
86 12x long-to-double vA, vB 将寄存器对 vB 中的长整型数转换为双精度浮点数,并存入寄存器对 vA
87 12x float-to-int vA, vB 将寄存器 vB 中的单精度浮点数转换为整型数,并存入寄存器 vA
88 12x float-to-long vA, vB 将寄存器 vB 中的单精度浮点数转换为长整型数,并存入寄存器对 vA
89 12x float-to-double vA, vB 将寄存器 vB 中的单精度浮点数转换为双精度浮点数,并存入寄存器 vA
8a 12x double-to-int vA, vB 将寄存器对 vB 中的双精度浮点数转换为整型数,并存入寄存器 vA
8b 12x double-to-long vA, vB 将寄存器对 vB 中的双精度浮点数转换为长整型数,并存入寄存器对 vA
8c 12x double-to-float vA, vB 将寄存器对 vB 中的双精度浮点数转换为单精度浮点数,并存入寄存器 vA
8d 12x int-to-byte vA, vB 将寄存器对 vB 中的整型数转换为 byte,并存入寄存器 vA
8e 12x int-to-char vA, vB 将寄存器对 vB 中的整型数转换为 char,并存入寄存器 vA
8f 12x int-to-short vA, vB 将寄存器对 vB 中的整型数转换为 short,并存入寄存器 vA
90 23x add-int vAA, vBB, vCC 将寄存器 vBB 中的整型数加上寄存器 vCC 中的整型数,结果存入寄存器 vAA
91 23x sub-int vAA, vBB, vCC 将寄存器 vBB 中的整型数减去寄存器 vCC 中的整型数,结果存入寄存器 vAA
92 23x mul-int vAA, vBB, vCC 将寄存器 vBB 中的整型数乘以寄存器 vCC 中的整型数,结果存入寄存器 vAA
93 23x div-int vAA, vBB, vCC 将寄存器 vBB 中的整型数除以寄存器 vCC 中的整型数,结果存入寄存器 vAA
94 23x rem-int vAA, vBB, vCC 将寄存器 vBB 中的整型数和寄存器 vCC 中的整型数进行模运算,结果存入寄存器 vAA
95 23x and-int vAA, vBB, vCC 将寄存器 vBB 中的整型数和寄存器 vCC 中的整型数进行与运算,结果存入寄存器 vAA
96 23x or-int vAA, vBB, vCC 将寄存器 vBB 中的整型数和寄存器 vCC 中的整型数进行或运算,结果存入寄存器 vAA
97 23x xor-int vAA, vBB, vCC 将寄存器 vBB 中的整型数和寄存器 vCC 中的整型数进行异或运算,结果存入寄存器 vAA
98 23x shl-int vAA, vBB, vCC 将寄存器 vBB 中的有符号数左移 vCC 位,结果存入寄存器 vAA
99 23x shr-int vAA, vBB, vCC 将寄存器 vBB 中的有符号数右移 vCC 位,结果存入寄存器 vAA
9a 23x ushr-int vAA, vBB, vCC 将寄存器 vBB 中的无符号数右移 vCC 位,结果存入寄存器 vAA
9b 23x add-long vAA, vBB, vCC 将寄存器对 vBB 中的长整型数加上寄存器对 vCC 中的长整型数,结果存入寄存器对 vAA
9c 23x sub-long vAA, vBB, vCC 将寄存器对 vBB 中的长整型数减去寄存器对 vCC 中的长整型数,结果存入寄存器对 vAA
9d 23x mul-long vAA, vBB, vCC 将寄存器对 vBB 中的长整型数乘以寄存器对 vCC 中的长整型数,结果存入寄存器对 vAA
9e 23x div-long vAA, vBB, vCC 将寄存器对 vBB 中的长整型数除以寄存器对 vCC 中的长整型数,结果存入寄存器对 vAA
9f 23x rem-long vAA, vBB, vCC 将寄存器对 vBB 中的长整型数和寄存器对 vCC 中的长整型数进行模运算,结果存入寄存器对 vAA
a0 23x and-long vAA, vBB, vCC 将寄存器对 vBB 中的长整型数和寄存器对 vCC 中的长整型数进行与运算,结果存入寄存器对 vAA
a1 23x or-long vAA, vBB, vCC 将寄存器对 vBB 中的长整型数和寄存器对 vCC 中的长整型数进行或运算,结果存入寄存器对 vAA
a2 23x xor-long vAA, vBB, vCC 将寄存器对 vBB 中的长整型数和寄存器对 vCC 中的长整型数进行异或运算,结果存入寄存器对 vAA
a3 23x shl-long vAA, vBB, vCC 将寄存器对 vBB 中的有符号长整型数左移 vCC 位,结果存入寄存器对 vAA
a4 23x shr-long vAA, vBB, vCC 将寄存器对 vBB 中的有符号长整型数右移 vCC 位,结果存入寄存器对 vAA
a5 23x ushr-long vAA, vBB, vCC 将寄存器对 vBB 中的无符号长整型数右移 vCC 位,结果存入寄存器对 vAA
a6 23x add-float vAA, vBB, vCC 将寄存器 vBB 中的单精度浮点数加上寄存器 vCC 中的单精度浮点数,结果存入寄存器 vAA
a7 23x sub-float vAA, vBB, vCC 将寄存器 vBB 中的单精度浮点数减去寄存器 vCC 中的单精度浮点数,结果存入寄存器 vAA
a8 23x mul-float vAA, vBB, vCC 将寄存器 vBB 中的单精度浮点数乘以寄存器 vCC 中的单精度浮点数,结果存入寄存器 vAA
a9 23x div-float vAA, vBB, vCC 将寄存器 vBB 中的单精度浮点数除以寄存器 vCC 中的单精度浮点数,结果存入寄存器 vAA
aa 23x rem-float vAA, vBB, vCC 将寄存器 vBB 中的单精度浮点数和寄存器 vCC 中的单精度浮点数进行模运算,结果存入寄存器 vAA
ab 23x add-double vAA, vBB, vCC 将寄存器对 vBB 中的双精度浮点数加上寄存器对 vCC 中的双精度浮点数,结果存入寄存器对 vAA
ac 23x sub-double vAA, vBB, vCC 将寄存器对 vBB 中的双精度浮点数减去寄存器对 vCC 中的双精度浮点数,结果存入寄存器对 vAA
ad 23x mul-double vAA, vBB, vCC 将寄存器对 vBB 中的双精度浮点数乘以寄存器对 vCC 中的双精度浮点数,结果存入寄存器对 vAA
ae 23x div-double vAA, vBB, vCC 将寄存器对 vBB 中的双精度浮点数除以寄存器对 vCC 中的双精度浮点数,结果存入寄存器对 vAA
af 23x rem-double vAA, vBB, vCC 将寄存器对 vBB 中的双精度浮点数和寄存器对 vCC 中的双精度浮点数进行模运算,结果存入寄存器对 vAA
b0 12x add-int/2addr vA, vB 将寄存器 vA 中的整型数加上寄存器 vB 中的整型数,结果存入寄存器 vA
b1 12x sub-int/2addr vA, vB 将寄存器 vA 中的整型数减去寄存器 vB 中的整型数,结果存入寄存器 vA
b2 12x mul-int/2addr vA, vB 将寄存器 vA 中的整型数乘以寄存器 vB 中的整型数,结果存入寄存器 vA
b3 12x div-int/2addr vA, vB 将寄存器 vA 中的整型数除以寄存器 vB 中的整型数,结果存入寄存器 vA
b4 12x rem-int/2addr vA, vB 将寄存器 vA 中的整型数和寄存器 vB 中的整型数进行模运算,结果存入寄存器 vA
b5 12x and-int/2addr vA, vB 将寄存器 vA 中的整型数和寄存器 vB 中的整型数进行与运算,结果存入寄存器 vA
b6 12x or-int/2addr vA, vB 将寄存器 vA 中的整型数和寄存器 vB 中的整型数进行或运算,结果存入寄存器 vA
b7 12x xor-int/2addr vA, vB 将寄存器 vA 中的整型数和寄存器 vB 中的整型数进行异或运算,结果存入寄存器 vA
b8 12x shl-int/2addr vA, vB 将寄存器 vA 中的有符号数左移 vB 位,结果存入寄存器 vA
b9 12x shr-int/2addr vA, vB 将寄存器 vA 中的有符号数右移 vB 位,结果存入寄存器 vA
ba 12x ushr-int/2addr vA, vB 将寄存器 vA 中的无符号数左移 vB 位,结果存入寄存器 vA
bb 12x add-long/2addr vA, vB 将寄存器对 vA 中的长整型数加上寄存器对 vB 中的长整型数,结果存入寄存器对 vA
bc 12x sub-long/2addr vA, vB 将寄存器对 vA 中的长整型数减去寄存器对 vB 中的长整型数,结果存入寄存器对 vA
bd 12x mul-long/2addr vA, vB 将寄存器对 vA 中的长整型数乘以寄存器对 vB 中的长整型数,结果存入寄存器对 vA
be 12x div-long/2addr vA, vB 将寄存器对 vA 中的长整型数除以寄存器对 vB 中的长整型数,结果存入寄存器对 vA
bf 12x rem-long/2addr vA, vB 将寄存器对 vA 中的长整型数和寄存器对 vB 中的长整型数进行模运算,结果存入寄存器对 vA
c0 12x and-long/2addr vA, vB 将寄存器对 vA 中的长整型数和寄存器对 vB 中的长整型数进行与运算,结果存入寄存器对 vA
c1 12x or-long/2addr vA, vB 将寄存器对 vA 中的长整型数和寄存器对 vB 中的长整型数进行或运算,结果存入寄存器对 vA
c2 12x xor-long/2addr vA, vB 将寄存器对 vA 中的长整型数和寄存器对 vB 中的长整型数进异或运算,结果存入寄存器对 vA
c3 12x shl-long/2addr vA, vB 将寄存器对 vA 中的有符号长整型数左移 vB 位,结果存入寄存器对 vA
c4 12x shr-long/2addr vA, vB 将寄存器对 vA 中的有符号长整型数右移 vB 位,结果存入寄存器对 vA
c5 12x ushr-long/2addr vA, vB 将寄存器对 vA 中的无符号长整型数左移 vB 位,结果存入寄存器对 vA
c6 12x add-float/2addr vA, vB 将寄存器 vA 中的单精度浮点数加上寄存器 vB 中的单精度浮点数,结果存入寄存器 vA
c7 12x sub-float/2addr vA, vB 将寄存器 vA 中的单精度浮点数减去寄存器 vB 中的单精度浮点数,结果存入寄存器 vA
c8 12x mul-float/2addr vA, vB 将寄存器 vA 中的单精度浮点数乘以寄存器 vB 中的单精度浮点数,结果存入寄存器 vA
c9 12x div-float/2addr vA, vB 将寄存器 vA 中的单精度浮点数除以寄存器 vB 中的单精度浮点数,结果存入寄存器 vA
ca 12x rem-float/2addr vA, vB 将寄存器 vA 中的单精度浮点数和寄存器 vB 中的单精度浮点数进行模运算,结果存入寄存器 vA
cb 12x add-double/2addr vA, vB 将寄存器对 vA 中的双精度浮点数加上寄存器对 vB 中的双精度浮点数,结果存入寄存器对 vA
cc 12x sub-double/2addr vA, vB 将寄存器对 vA 中的双精度浮点数减去寄存器对 vB 中的双精度浮点数,结果存入寄存器对 vA
cd 12x mul-double/2addr vA, vB 将寄存器对 vA 中的双精度浮点数乘以寄存器对 vB 中的双精度浮点数,结果存入寄存器对 vA
ce 12x div-double/2addr vA, vB 将寄存器对 vA 中的双精度浮点数除以寄存器对 vB 中的双精度浮点数,结果存入寄存器对 vA
cf 12x rem-double/2addr vA, vB 将寄存器对 vA 中的双精度浮点数和寄存器对 vB 中的双精度浮点数进行模运算,结果存入寄存器对 vA
d0 22s add-int/lit16 vA, vB, #+CCCC 将寄存器 vB 中的整型数和 16 位字面量 CCCC 相加,结果存入寄存器 vA
d1 22s rsub-int vA, vB, #+CCCC 将寄存器 vB 中的整型数和 16 位字面量 CCCC 相减,结果存入寄存器 vA
d2 22s mul-int/lit16 vA, vB, #+CCCC 将寄存器 vB 中的整型数和 16 位字面量 CCCC 相乘,结果存入寄存器 vA
d3 22s div-int/lit16 vA, vB, #+CCCC 将寄存器 vB 中的整型数和 16 位字面量 CCCC 相除,结果存入寄存器 vA
d4 22s rem-int/lit16 vA, vB, #+CCCC 将寄存器 vB 中的整型数和 16 位字面量 CCCC 进行模运算,结果存入寄存器 vA
d5 22s and-int/lit16 vA, vB, #+CCCC 将寄存器 vB 中的整型数和 16 位字面量 CCCC 进行与运算,结果存入寄存器 vA
d6 22s or-int/lit16 vA, vB, #+CCCC 将寄存器 vB 中的整型数和 16 位字面量 CCCC 进行或运算,结果存入寄存器 vA
d7 22s xor-int/lit16 vA, vB, #+CCCC 将寄存器 vB 中的整型数和 16 位字面量 CCCC 进行异或运算,结果存入寄存器 vA
d8 22b add-int/lit8 vAA, vBB, #+CC 将寄存器 vBB 中的整型数和 8 位字面量 CC 相加,结果存入寄存器 vAA
d9 22b rsub-int/lit8 vAA, vBB, #+CC 将寄存器 vBB 中的整型数和 8 位字面量 CC 相减,结果存入寄存器 vAA
da 22b mul-int/lit8 vAA, vBB, #+CC 将寄存器 vBB 中的整型数和 8 位字面量 CC 相乘,结果存入寄存器 vAA
db 22b div-int/lit8 vAA, vBB, #+CC 将寄存器 vBB 中的整型数和 8 位字面量 CC 相除,结果存入寄存器 vAA
dc 22b rem-int/lit8 vAA, vBB, #+CC 将寄存器 vBB 中的整型数和 8 位字面量 CC 进行模运算,结果存入寄存器 vAA
dd 22b and-int/lit8 vAA, vBB, #+CC 将寄存器 vBB 中的整型数和 8 位字面量 CC 进行与运算,结果存入寄存器 vAA
de 22b or-int/lit8 vAA, vBB, #+CC 将寄存器 vBB 中的整型数和 8 位字面量 CC 进行或运算,结果存入寄存器 vAA
df 22b xor-int/lit8 vAA, vBB, #+CC 将寄存器 vBB 中的整型数和 8 位字面量 CC 进行异或运算,结果存入寄存器 vAA
e0 22b shl-int/lit8 vAA, vBB, #+CC 将寄存器 vBB 中的有符号数左移 CC 位,将结果存入寄存器 vAA
e1 22b shr-int/lit8 vAA, vBB, #+CC 将寄存器 vBB 中的有符号数右移 CC 位,将结果存入寄存器 vAA
e2 22b ushr-int/lit8 vAA, vBB, #+CC 将寄存器 vBB 中的无符号数右移 CC 位,将结果存入寄存器 vAA
e3 10x unused
e4 10x unused
e5 10x unused
e6 10x unused
e7 10x unused
e8 10x unused
e9 10x unused
ea 10x unused
eb 10x unused
ec 10x unused
ed 10x unused
ee 10x unused
ef 10x unused
f0 10x unused
f1 10x unused
f2 10x unused
f3 10x unused
f4 10x unused
f5 10x unused
f6 10x unused
f7 10x unused
f8 10x unused
f9 10x unused
fa 45cc invoke-polymorphic {vC, vD, vE, vF, vG}, meth@BBBB, proto@HHHH 调用指定的签名多态方法,存在于 038 和更高版本的 Dex 文件中
fb 4rcc invoke-polymorphic/range {vCCCC .. vNNNN}, meth@BBBB, proto@HHHH 调用指定的方法句柄,存在于版本 038 及更高版本的 Dex 文件中
fc 35c invoke-custom {vC, vD, vE, vF, vG}, call_site@BBBB 解析并调用指定的调用点,存在于版本 038 及更高版本的 Dex 文件中
fd 3rc invoke-custom/range {vCCCC .. vNNNN}, call_site@BBBB 解析并调用一个调用点,存在于版本 038 及更高版本的 Dex 文件中
fe 21c const-method-handle vAA, method_handle@BBBB 将通过特定索引指定的方法句柄的引用移到指定的寄存器中,存在于版本 039 及更高版本的 Dex 文件中
ff 21c const-method-type vAA, proto@BBBB 将通过特定索引指定的方法原型的引用移到指定的寄存器中。存在于版本 039 及更高版本的 Dex 文件中

最后的 fa-ff 由于 DEX 版本问题,其实很少见。

其他相关内容 :

Class 文件格式详解

Smali 语法解析——Hello World

Smali —— 数学运算,条件判断,循环

Smali 语法解析 —— 类

Android逆向笔记 —— AndroidManifest.xml 文件格式解析

Android逆向笔记 —— DEX 文件格式解析

Android 逆向笔记 —— ARSC 文件格式解析

Android 逆向笔记 —— 一个简单 CrackMe 的逆向总结

Android 逆向笔记 —— 说说 Dalvik 及其指令集


文章首发微信公众号: 秉心说 , 专注 Java 、 Android 原创知识分享,LeetCode 题解。

扫码关注,回复 Dalvik 获取 Dalvik 指令集大全 pdf 版本 !

关注下面的标签,发现更多相似文章
评论