内容简介:首先说明 Dalvik 虚拟机的基本约定 。下面解释一下表格中的每项内容。操作码 :十六进制,范围 00 - ff
为什么是全网最全,因为根本没人整理 Dalvik 指令集。。
本文档纯粹作为一个 Dalvik 指令集速查表,相信一定有需要的同学。
文末扫码关注公众号,回复 Dalvik
获取本文档 pdf 版本 !
首先说明 Dalvik 虚拟机的基本约定 。
-wide 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 版本问题,其实很少见。
其他相关内容 :
Android逆向笔记 —— AndroidManifest.xml 文件格式解析
Android 逆向笔记 —— 一个简单 CrackMe 的逆向总结
Android 逆向笔记 —— 说说 Dalvik 及其指令集
文章首发微信公众号: 秉心说
, 专注 Java 、 Android 原创知识分享,LeetCode 题解。
扫码关注,回复 Dalvik
获取 Dalvik 指令集大全 pdf 版本 !
以上所述就是小编给大家介绍的《全网最全 Dalvik 指令集解析 !》,希望对大家有所帮助,如果大家有任何疑问请给我留言,小编会及时回复大家的。在此也非常感谢大家对 码农网 的支持!
猜你喜欢:- 全网最全 | MySQL EXPLAIN 完全解读
- 全网最全Flutter常用工具类
- 全网最通透的 Java 8 版本特性讲解
- 全网首发!Laravel 远程代码执行漏洞 POC
- IPv6全网大改造真的来了
- 全网IPv6部署带来的现实问题
本站部分资源来源于网络,本站转载出于传递更多信息之目的,版权归原作者或者来源机构所有,如转载稿涉及版权问题,请联系我们。
Mastering Flask
Jack Stouffer / Packt Publishing / 2015-9-30 / USD 49.99
Work with scalable Flask application structures to create complex web apps Discover the most powerful Flask extensions and learn how to create one Deploy your application to real-world platforms......一起来看看 《Mastering Flask》 这本书的介绍吧!