全网最全 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 文件中