Tinker

@dodola
Android

前言

从微信公众号介绍 Tinker 开始就一直关注 Tinker，自己也一直在做热修复相关的开发，但一直都是在踩坑的状态，在 MDCC 的时候也和邵文同学聊了一下，从看到框架代码开始就觉得其稳定性相当的好，而整个框架里我在意的几部分是：
1. DexDiff
我觉得这是最体现微信做事风格的一个模块：要把一个技术做到极致，像之前开源的几种方案里 Andfix 的补丁粒度是方法，像 nuwa、rocoofix 类似的补丁粒度是类，其他有很多采用 bsdiff 的，其实上述的方法都会由于一些的情况造成补丁包变得很大（这个后面会讲原因），而 Tinker 是基于 Dex 的文件结构来下手，将产生变化的结构提取出来，产生的补丁非常小，而且在 diff 的过程中也处理了一些会造成补丁包很大的场景，这个后续再谈。之前有同学跟我说这个是反编译过程，其实并不是如此。
2. 资源 Diff
这块技术大家在做的时候大部分出现的问题都不在如何加载补丁资源包里，因为这块内容 InstantRun 里已经有很完整的解决方案，我们都在讨论同一个问题就是如何保证后续打包的资源 id 不变的问题，并且使用比较优雅的方式来集成进去，Tinker 里已经解决这个问题。
3. 分平台合成
DexDiff 生成了一个自定义格式的 dex，这个 dex 在不同的虚拟机环境下会区分 dalvik 和 art 平台合成不同的补丁包，而这种方式也是分别为了解决 dalvik 下和 art 下出现的问题产生的方案。这样就避免了 Dalvik 下需要宿主提前插桩才能解决验证问题等。
4. 补丁包的加载
这块遇到的问题其实有很多，比如如何判断 dex 、资源文件已经加载完成，如何判断这个机型不支持 ClassLoader 的 dex 插入机制，以及如何连续下发补丁，补丁的回退机制等等，Tinker 都已解决上述问题，并且提供了很完整的日志供开发同学分析。
5. MiniLoader
这个名词是从 Tinker 第一篇文章中看到的，像之前的框架基本上补丁的加载都是在 Application 的 onCreate里或者 attachBaseContext 里，这就会造成一个问题就是 Application 出现问题是无法被修复的， Tinker 为了解决这个问题采用了隔离 Application 的方式， Application 的初始化和声明周期由 MiniLoader 来进行代理这样我们就可以把很多操作放在代理类里完成， Application 和其提前加载的类都是可以进行修复的。

DexDiff

其实这个标题并不是很符合我下面要介绍的内容，我下面主要介绍一下在 Diff 过程中处理 Code Section 的内容，其他 Section 的 Diff 其实相对容易理解一些，大家看源码和这篇文章基本就明白了

从Dex说起

要了解整个 Diff 过程需要先熟悉一下Dex的文件结构，这里要老生常谈的描述一下 Dex 的 Section 结构和各个 Section 之间的关联性，我们以一段简单的代码为例。

% echo 'class Foo {'\
> 'public static void main(String[] args) {'\
> 'System.out.println("Hello, world"); }}' > Foo.java
% javac Foo.java
% dx --dex --output=foo.dex Foo.class

上述的命令将一段很简单的Hello World代码先经过 javac 编译成 .class文件，然后通过 dx命令 将 .class 文件转换成 Dex 也就是上面生成的一个foo.dex文件，这个文件就是我们下面要分析的文件.

我们先大体来看一下整个Dex的结构，从 AloneMonkey 的博客中找到一个描述DexFile整体结构的图

Tinker针对上面的Data Section部分每一项内容都做了相应的diff逻辑

本次要讲的是CodeSectionDiffAlgorithm算法过程，由于新旧源码的变更和编译过程中的优化会导致字节码的一些改变从而引发 Diff 和 Merge 的过程中出现一些问题，我们会逐步介绍这些问题，并说明 Tinker 中是如何处理的。

所以我们先来了解一下Code Section里包含什么内容。

Code Section

我们在上一节中生成了一个只有一个静态main方法的dex类，这个类足够简单很适合用来分析。
其实通过分析class_data结构中可以看到其中其direct_methods_size是2，说明里面有两个方法，一个是编译器生成的构造方法Foo.<init>一个是我们定义的静态方法 public static void Foo.main(java.lang.String[])

下面的图指出了在method结构里通过code_off字段引用到指定的code_item段，这个就是我们要分析的部分。

上面图中指出的code_item段的内容在Tinker里面通过com.tencent.tinker.android.dex.Code类对应

public final class Code extends Item<Code> {
    public int registersSize;//本段代码使用到的寄存器数目
    public int insSize;//method传入参数的数目 
    public int outsSize;//本段代码调用其它method 时需要的参数个数 
    public int debugInfoOffset;//指向调试信息的偏移
    public short[] instructions;//表示具体的字节码
    public Try[] tries;//try_item 数组
    public CatchHandler[] catchHandlers;
}

然后Tinker在做diff的时候通过compareTo方法来判断方法里的代码是否经过修改。

 @Override
    public int compareTo(Code other) {
        int res = CompareUtils.sCompare(registersSize, other.registersSize);
        if (res != 0) {
            return res;
        }
        res = CompareUtils.sCompare(insSize, other.insSize);
        if (res != 0) {
            return res;
        }
        res = CompareUtils.sCompare(outsSize, other.outsSize);
        if (res != 0) {
            return res;
        }
        res = CompareUtils.sCompare(debugInfoOffset, other.debugInfoOffset);
        if (res != 0) {
            return res;
        }
        res = CompareUtils.uArrCompare(instructions, other.instructions);
        if (res != 0) {
            return res;
        }
        res = CompareUtils.aArrCompare(tries, other.tries);
        if (res != 0) {
            return res;
        }
        return CompareUtils.aArrCompare(catchHandlers, other.catchHandlers);
    }

上面的代码属性里的任何一项出现不同那么就认为用户修改过这个方法体。

不过，这一切并没有这么顺利。。。

我们需要考虑一下这种情况，有如下两段代码

Foo.java 下面的代码相当于我们上一个版本的代码

public class Foo { 
    public void foo(){
        System.out.println("hello dodola5");
    }
}

这段代码相当于我们修改过后的代码，下面这段代码并没有修改任何方法，只是增加了4个字符串属性。

public class Foo { 
    public String foo1 = "hello dodola";
    public String foo5 = "hello dodola1";
    public String foo2 = "hello dodola2";
    public String foo3 = "hello dodola3";
    public String foo4 = "hello dodola4";
    public void foo(){
        System.out.println("hello dodola5");
    }
}

那么直观上我们认为其中定义的方法从生成的code段的内容应该是没有任何变化的，但事实并不如此，我们以foo方法为例，两段代码中各自对应的foo方法的字节码如下：

从上面的图上，我们可以看到，在这种情况下新旧版本里一个并没有修改过的方法生成的字节码并不一样。

让我们看看图中出现不一致的地方是什么内容，祭出dexdump来查看一下这部分生成的smali代码

旧版本

6200 0000        |0000: sget-object v0, Ljava/lang/System;.out:Ljava/io/PrintStream; // field@0000
1a01 0a00        |0002: const-string v1, "hello dodola5" // string@000a 
6e20 0200 1000   |0004: invoke-virtual {v0, v1}, Ljava/io/PrintStream;.println:(Ljava/lang/String;)V // method@0002
0e00             |0007: return-void

新版本

6200 0500        |0000: sget-object v0, Ljava/lang/System;.out:Ljava/io/PrintStream; // field@0005
1a01 1400        |0002: const-string v1, "hello dodola5" // string@0014
6e20 0200 1000   |0004: invoke-virtual {v0, v1}, Ljava/io/PrintStream;.println:(Ljava/lang/String;)V // method@0002
0e00             |0007: return-void

从上面两段代码的对比中我们可以看到虽然我们没有改变 hello dodola5 这个字符串的内容，但是这个字符串由于我们新增的字符串导致其string_id产生变化，也就是上述代码中出现的string@000a和string@0014的不同,并且由于字段的增加导致读取的field位置也是不同 sget-object指的是根据 字段ID 读取静态对象引用字段到 vx，这说明java.io.PrintStream java.lang.System.out 所在的fieldid变了。

所以，按照直接取出两个Code做对比的方法，在类似这种情况下虽然没有对其方法做修改，也是会被判定为different的，所以我们需要一个过程，将这样内容没有变化，id出现变化的情况，将新dex里的ID映射回旧dex的ID上面。这是一方面的考虑。

下面我们来具体讨论一下 Tinker 是如何做新旧 ID的映射的，这里使用 String ID 来做演示

public class Foo { 
    public String foo1="hello dodola";
    public String foo5="hello dodola1";
    public String foo2="hello dodola2";
    public void foo(){
        System.out.println("hello dodola5");
    }
}

增加foo3,删除foo2,修改foo1,修改方法里字符串为hello dodola1，代码变成如下内容

public class Foo { 
    public String foo1="hello dodola_modify";
    public String foo5="hello dodola1";
    public String foo3="hello dodola3";
    public void foo(){
        System.out.println("hello dodola1");
    }
}

好了，我们用上面修改的内容看一下 Tinker 里所用的diff算法的逻辑，下面以字符串的修改为例，先看一下两个dex里Strings部分的内容是什么样子的。

diff 算法

算法的过程比较简单，描述一下就是：
首先我们需要将新旧内容排序，这需要针对排序的数组进行操作
新旧两个指针，在内容一样的时候 old、new 指针同时加1，在 old 内容小于 new 内容(注：这里所说的内容比较是单纯的内容比较比如'A'<'a')的时候 old 指针加1 标记当前 old 项为删除
在 old 内容大于 new 内容 new 指针加1， 标记当前 new 项为新增
下面我列出了算法执行的简单过程
------old-----
11 foo2 
12 foo5 
13 hello dodola
14 hello dodola1
15 hello dodola2
16 hello dodola5
17 out
18 println
------new-----
11 foo3 
12 foo5 
13 hello dodola1 
14 hello dodola3
15 hello dodola_modify
16 out
17 println
对比的old cursor 和 new cursor 指针的改变以及操作判定，判定过程如下
old_11 new_11 cmp <0  del
old_12 new_11 cmp >0  add
old_12 new_12 cmp =0  no
old_13 new_13 cmp <0  del
old_14 new_13 cmp =0  no
old_15 new_14 cmp <0  del
old_16 new_14 cmp >0  add
old_16 new_15 cmp <0  del
old_17 new_15 cmp >0  add
old_17 new_16 cmp =0  no
old_18 new_17 cmp =0  no
break;
进入下一步过程
可以确定的是删除的内容肯定是从 old 中的 index 进行删除的 添加的内容肯定是从 new 中的 index 中来的，按照这个逻辑我们可以整理如下内容。
old_11 del
new_11 add
old_13 del
new_14 add
old_15 del
new_15 add
old_16 del
到这一步我们需要找出替换的内容，很明显替换的内容就是从 old 中 del 的并且在 new 中 add 的并且 index 相同的i tem，所以这就简单了
old_11 replace
old_13 del
new_14 add
old_15 replace
old_16 del
ok，到这一步我们就能判定出两个dex的变化了。很机智的算法

总觉得这算法略熟悉，但是叫不上名字，问过小唐同学后才知道这是二路归并算法，算法这部分还需要学习，惭愧。

上面的内容过于混杂，下面拆分出各个知识点进行介绍。

首先我们需要考虑的内容是如何找出像上面出现的那种方法没有修改但是其字节码产生变化的情况，所以我们需要彻底了解一遍Dalvik bytecode，这也有助于我们对后面的分析。

so next

bytecode 简要说明

指令说明

在阅读官网文档之前我们需要先了解一些东西，由于能力有限下面的内容大部分来自网上的文档。

Dalvik虚拟机是基于寄存器的，在java字节转换为dalvik字节码的过程中，方法调用栈的尺寸就已经确定，其中明确指出了方法使用寄存器的个数

这里先引用非虫《Android软件安全与逆向分析》书中对字节码的讲解。

一段Dalvik字节码由一系列Dalvik指令组成，指令语法由指令的位描述与指令格式标识来决定。位描述约定如下：

• 每16位的字采用空格分隔开来。
• 每个字母表示4位，每个字母按顺序从高字节开始，排列到低字节。每4位之间可能使有竖线“|”来表示不同的内容。
• 顺序采用A~Z的单个大写字母作为一个4位的操作码，op表示一个8位的操作码。
• “Ø”来表示这字段所有位为０值。

以指令格式A|G|op BBBB F|E|D|C为例：

指令中间有两个空格，每个分开的部分大小为16位，所以这条指令由三个16位的字组成。第一个16位是A|G|op，高8位由A与G组成，低字节由操作码op组成。第二个16位由BBBB组成，它表示一个16位的偏移值。第三个16位分别由F，E，D，C共四个4位组成，在这里它们表示寄存器参数。
在实际存储时，是以小端方式，而在描述时，则以大端方式。
单独使用位标识还无法确定一条指令，必须通过指令格式标识来指定指令的格式编码。它的约定如下：

• 指令格式标识大多由三个字符组成，前两个是数字，最后一个是字母。
• 第一个数字是表示指令有多少个16位的字组成。
• 第二个数字是表示指令最多使用寄存器的个数。特殊标记“r”标识使用一定范围内的寄存器。
• 第三个字母为类型码，表示指令用到的额外数据的类型。取值见下表。
• 还有一种特殊的情况是末尾可能会多出另一个字母，如果是字母 s 表示指令采用静态链接，如果是字母 i 表示指令应该被内联处理
  
  以指令格式标识 22x 为例：

第一个数字2表示指令有两个16位字组成，第二个数字2表示指令使用到2个寄存器，第三个字母x表示没有使用到额外的数据。

另外，Dalvik指令对语法做了一些说明，它约定如下：

• 格式表的第三列指出了指令中所使用的人类可识别的语法。每个指令以命名的操作码开始，后面可选择使用一个或多个参数，并且参数之间用逗号分隔。

• 当参数指第一列中的某个字段时，该字段的字母将在语法中出现，并在字段中每四位重复一次。例如，第一列中标记为“BB”的八位字段在语法列中也将标记为“BB”。

• 命名寄存器的参数形式为“vX”。选择“v”而不是更常用的“r”作为前缀，这样可避免与实现 Dalvik 可执行格式的（非虚拟）架构（其寄存器使用“r”作为前缀）出现冲突。（也就是说，我们可以直截了当地同时讨论虚拟和实际寄存器。）

• 表示字面值的参数的形式为“#+X”。有些格式在表示字面量时，仅具有字面量的高位（无 0 位）；对于这种类型的量，仅在语法表示时会明确写出后面的 0，但是在按位描述中这些 0 会被省略。

• 表明相对指令地址偏移量的参数形式为“+X”。

• 表示字面量常量池索引的参数形式为“kind@X”，其中“kind”表示正在引用的常量池。每个使用此类格式的操作码明确地表示只允许使用一种常量；请查看操作码参考，找出对应关系。常量池的种类包括“string”（字符串池索引）、“type”（类型池索引）、“field”（字段池索引）、“meth”（方法池索引）和“site”（调用点索引）。

• 此外还可使用一些建议的可选形式，它们与常量池索引的表示类似，表示预链接的偏移量或索引。可以使用两种类型的建议的预链接值：vtable 偏移（表示为“vtaboff”）和字段偏移（表示为“fieldoff”）。

• 如果格式值并非明确地包含在语法中，而是选择使用某种变体，则每个变体都以“[X=N]”（例如，“[A=2]”）为前缀来表示对应关系。

以指令 op vAA, string@BBBB 为例：指令用到了1个寄存器参数 vAA，并且还附加了一个字符串常量池索引 string@BBBB，其实这条指令格式代表着 const-string 指令。

在 Dalvik 虚拟机字节码中寄存器的命名法中主要有 2 种：

1. v 命名法
2. p 命名法。

假设一 个函数使用到 M 个寄存器，并且该函数有 N 个入参，根据 Dalvik 虚拟机参数传递方式中的规定：入参使用最后的 N 个寄存器中，局部变量使用从 v0 开始的前 M-N 个寄存器。比如， 某函数 A 使用了 5 个寄存器，2 个显式的整形参数，如果函数 A 是非静态方法，函数被调用 时会传入一个隐式的对象引用(也就是this)，因此实际传入的参数个数是 3 个。根据传参规则，局部变量将使用前 2 个寄存器，参数会使用后 3 个寄存器。

v 命名法采用小写字母v开头的方式表示函数中用到的局部变量与参数，所有的寄存器命名从 v0 开始，依次递增。对于上文的函数 A，v 命名法会用到 v0、v1、v2、v3、v4 等 5 个寄存器，v0 与 v1 表示函数 A 的局部变量，v2 表示传入的隐式对象引用，v3 与 v4 表示实际传入的 2 个整形参数。

p 命名法对函数的局部变量寄存器命名没有影响，它的命名规则是：函数的入参从 p0 开始命名，依次递增。对于上文的函数 A，p 命名法会用到 v0、v1、p0、p1、p2 等 5 个寄 存器，v0 与 v1 表示函数 A 的局部变量，p0 表示传入的隐式对象引用，p1 与 p2 表示实际传 入的 2 个整形参数。此时，p0、p1、p2 实际上分别表示 v2、v3、v4，只是命名不一样而已。p命名法的好处是能够通过寄存器的名字前缀就能判断寄存器是局部变量还是函数入参。

这里需要注意个情况，在调用非静态方法的时候，需要传入该方法所在对象的引用也就是this,此时 p0 表示隐式对象引用，p1后面是实际传入的参数，在调用静态方法时，由于不需要对当前对象进行引用，所以从 p0 开始就是实际传入的参数，这点需要注意。

指令中使用v加数字的方法来索引寄存器，每条指令使用的寄存器索引范围都有限制，这里使用一个大写字母来表示4位数据宽度的取值范围，比如：指令 move vA, vB，目的寄存器 vA 可使用 v0 ~ v15 的寄存器，源寄存器 vB 可以使用 v0 ~ v15 寄存器。指令 move/from16 vAA, vBBBBB，目的寄存器 vAA 可使用 v0 ~ v255 的寄存器，源寄存器 vB 可以使用 v0 ~ v65535 寄 存器。当目的寄存器和源寄存器中有一个寄存器的编号大于 15 时，即需要加上 /from16 指令才能得到正确运行。

上面描述了一下dalvik bytecode中所使用的指令格式，所有格式的说明在https://source.android.com/devices/tech/dalvik/instruction-formats.html 这个官方文档中有说明，这里就不贴出了，在下面的内容中会涉及到。

Bytecode 指令

数据操作指令

12x: 指令长度16，两个寄存器
例子：01 10 : move v0, v1

22x:指令长度32，两个寄存器
例子：02 01 1400 ：move/from16 v1, v20
说明：出现from16的情况一般是一个方法里使用的寄存器超过15个

32x:指令长度48，两个寄存器
例子：

0300 0201 0000 : move/16 v258, v0

12x:指令长度16，两个寄存器
例子：

public static long test3(long a,long b){
        return a+b;
}

注意：可以从 vN 移到 vN-1 或 vN+1，因此必须在执行写入运算之前，为要读取的寄存器对的两部分均安排实现。
入参使用最后的几个寄存器，局部变量使用v0开始的前N个寄存器， 在此例中，registersize是12

 0480 |0000: move-wide v0, v8 #
 04a2 |0001: move-wide v2, v10 #
 0404 |0002: move-wide v4, v0 #
 0426 |0003: move-wide v6, v2 #
 bb64 |0004: add-long/2addr v4, v6 #
 0440 |0005: move-wide v0, v4 #
 1000 |0006: return-wide v0 #

22x:指令长度32，两个寄存器

例子：02 02 1600 :move/from16 v2, v22
该字节码会出现在寄存器使用超过15个的情况，并且操作数为long或者double

32x:指令长度48，两个寄存器

还未发现该字节码

12x:指令长度16，两个寄存器
例子：07 30: move-object v0, v3 将v3寄存器中的对象引用到v0

22x:指令长度32，两个寄存器
例子：0801 1200: move-object/from16 v1, v18 将v18寄存器中的对象引用到v1

32x：指令长度48，两个寄存器

11x:指令长度16，一个寄存器
例子：0a01: move-result v1
此处需要注意的项是，这个结果是非对象型结果的，比如方法返回一个对象，那么紧接着的操作应该不会出现move-result,而应该是object系的操作。

11x：指令长度16，一个寄存器
例子：

  0013: invoke-interface {v5}, Zorch.zorch4:()J #此方法返回long
  0016: move-result-wide v5

11x:指令长度16，一个寄存器
例子：

2420 0f00 2100 :filled-new-array {v1, v2}, [I // type@000f
0c02           : move-result-object v2

11x:指令长度16，一个寄存器
例子：

 public static int tryCatch(String num){
        try{
            return Integer.parseInt(num);
        }catch(Exception ex){
            return 0;
        }
    }

 0730            : move-object v0, v3
 0702            : move-object v2, v0
 7110 0500 0200  : invoke-static {v2}, Ljava/lang/Integer;.parseInt:(Ljava/lang/String;)I // method@00
05
 0a02            : move-result v2
 0120            : move v0, v2
 0f00            : return v0
 0d02            : move-exception v2
 0721            : move-object v1, v2
 1202            : const/4 v2, #int 0 // #0
 0120            : move v0, v2
 28fb            : goto 0007 // -0005

返回指令

10x:指令长度16，没有使用寄存器

例子：

0E00 : return-void #返回值为 void，即无返回值，并非返回 null。

11x:指令长度16，一个寄存器
例子：0F00 : return v0

11x:指令长度16，一个寄存器
例子：
1000 : return-wide v0 #返回 v0,v1 寄存器中的 double/long 值。

11x:指令长度16，一个寄存器
例子：1100 : return-object v0 #返回v0寄存器中的对象引用

数据定义指令

11n:指令长度16，一个寄存器，4位立即数
例子：

int b = 1;

1212 : const/4 v2, #int 1 // #1

21s:指令长度32，一个寄存器，16bit立即数
例子：

int a = 10;

1301 0a00 : const/16 v1, #int 10 // #a

31i:指令长度48，一个寄存器，signed int，或者32位float

例子：

int c = 12345678;

1403 4e61 bc00 : const v3, #float 0.000000 // #00bc614e

21h:指令长度32，一个寄存器，有符号的立即数(见上表说明)
例子：

int a = 0x40000000;

1501 0040 : const/high16 v1, #int 1073741824 // #4000

21s:指令长度32，一个寄存器，一个常量池索引

例子：

long a = 1;

1602 0100 : const-wide/16 v2, #int 1 // #1

31i:指令长度48，一个寄存器，有符号整数或float浮点数

例子：

long a = 12345678;

1702 4e61 bc00 : const-wide/32 v2, #float 0.000000 // #00bc614e

51l:指令长度80，一个寄存器，一个有符号整数或者64位双精度浮点数

例子：

long a = 12345678901234567L;

0001d4: 1802 874b 6b5d 54dc 2b00 : const-wide v2, #double 0.000000 // #002bdc545d6b4b87

21h:指令长度32，一个寄存器，一个有符号立即数，低位为0
例子：

long a = 0x1000000000000000L;

1902 0010 : const-wide/high16 v2, #long 1152921504606846976 // #1000

21c:指令长度32，一个寄存器，一个常量池索引
例子：

        String name="dodo";

1a01 0d00 : const-string v1, "dodo" // string@000d 字符串表d项

31c:指令长度48，一个寄存器，一个常量池索引

例子：
这个指令出现的情况比较特殊一些,我总结了两种情况会出现这个指令

1. 强制在dx编译的时候传入--force-jumbo选项
   dx --dex --output=d.dex --no-optimize --force-jumbo *.class

       String name="dodo";

   1b01 0d00 0000 : const-string/jumbo v1, "dodo" // string@0000000d

2. 当dex里的字符串数量很多的时候

   static public final String s0 = "0";
   static public final String s1 = "1";
   ......
   static public final String s32767 = "32767";

   1b01 0d00 0100  : const-string/jumbo v1, "zorch" // string@0001000d

21c:指令长度32，一个寄存器，一个常量池索引
例子：

 Class intClass=Integer.class;

1c04 0300 : const-class v4, Ljava/lang/Integer; // type@0003

锁指令

11x:指令长度16，一个寄存器

注意：如果该指令需要抛出异常，则必须以 pc 已提前超出该指令的方式抛出。不妨将其想象成，该指令（在一定意义上）已成功执行，并且在该指令之后但又在下一条指令找到机会执行之前抛出异常。这种定义使得某个方法有可能将监视锁清理 catch-all（例如 finally）分块用作分块自身的监视锁清理，以便处理可能由于 Thread.stop() 的既往实现而抛出的任意异常，同时仍尽力维持适当程度的监视锁安全机制。

例子：

  public static synchronized void test1(){
        test2();
    }
    public static synchronized void test2(){
    }

1c01 0200       : const-class v1, LBlort; // type@0002
1d01            : monitor-enter v1
7100 0200 0000  : invoke-static {}, LBlort;.test2:()V // method@0002
1e01            : monitor-exit v1
0e00            : return-void
0d00            : move-exception v0
1e01            : monitor-exit v1
2700            : throw v0

实例操作指令

21c：指令长度32，一个寄存器，一个常量池索引

注意：由于 A 必须始终是引用（而非原始值），因此如果 B 引用原始类型，则必然会在运行时失败（即抛出异常）。

例子：

    public static Blort test(Object x) {
        return (Blort) x;
    }

1f01 0000 : check-cast v1, LBlort; // type@0000

22c:指令长度32，两个寄存器，一个常量池索引

注意：由于 B 必须始终是引用（而非原始值），因此如果 C 引用原始类型，则始终赋值 0

例子：

x instanceof Blort

 2011 0000 : instance-of v1, v1, LBlort; // type@0000

12x：指令长度16，两个寄存器
例子：

 public static void testlength(Object[] objs){
        int a=objs.length;
    }

 2122 : array-length v2, v2

21c:指令长度32，一个寄存器，一个常量池索引
例子：

new Object();

2201 0100 : new-instance v1, Ljava/lang/Object; // type@0001

数组操作指令

22c：指令长度32，两个寄存器，一个常量池索引

例子：

      int[] a=  new int[4];
      Object[] b=new Object[0];

2322 0300 : new-array v2, v2, [I // type@0003
2322 0400 : new-array v2, v2, [Ljava/lang/Object; // type@0004

35c:指令长度48，5个寄存器，一个常量池索引

例子：

Object[][] a = new Object[1][13];
Object[][][] b = new Object[1][14][3];
Object[][][][] c = new Object[1][15][3][16];
Object[][][][][] d = new Object[1][17][3][18][5];

1214             :const/4 v4, #int 1 // #1
1225             :const/4 v5, #int 2 // #2
2420 0f00 5400   :filled-new-array {v4, v5}, [I // type@000f
0c05             :move-result-object v5
6204 0500        :sget-object v4, Ljava/lang/Integer;.TYPE:Ljava/lang/Class; // field@0005
7120 1500 5400   :invoke-static {v4, v5}, Ljava/lang/reflect/Array;.newInstance:(Ljava/lang/Class;[I)Ljava/lang/Object; // method@0015
0c04             :move-result-object v4
1f04 1500        :check-cast v4, [[I // type@0015
0740             :move-object v0, v4
1214             :const/4 v4, #int 1 // #1
1225             :const/4 v5, #int 2 // #2
1236             :const/4 v6, #int 3 // #3
2430 0f00 5406   :filled-new-array {v4, v5, v6}, [I // type@000f
0c05             :move-result-object v5
6204 0500        :sget-object v4, Ljava/lang/Integer;.TYPE:Ljava/lang/Class; // field@0005
7120 1500 5400   :invoke-static {v4, v5}, Ljava/lang/reflect/Array;.newInstance:(Ljava/lang/Class;[I)Ljava/lang/Object; // method@0015
0c04             :move-result-object v4
1f04 1800        :check-cast v4, [[[I // type@0018
0741             :move-object v1, v4
1214             :const/4 v4, #int 1 // #1
1225             :const/4 v5, #int 2 // #2
1236             :const/4 v6, #int 3 // #3
1247             :const/4 v7, #int 4 // #4
2440 0f00 5476   :filled-new-array {v4, v5, v6, v7}, [I // type@000f
0c05             :move-result-object v5
6204 0500        :sget-object v4, Ljava/lang/Integer;.TYPE:Ljava/lang/Class; // field@0005
7120 1500 5400   :invoke-static {v4, v5}, Ljava/lang/reflect/Array;.newInstance:(Ljava/lang/Class;[I)Ljava/lang/Object; // method@0015
0c04             :move-result-object v4
1f04 1b00        :check-cast v4, [[[[I // type@001b
0742             :move-object v2, v4
1214             :const/4 v4, #int 1 // #1
1225             :const/4 v5, #int 2 // #2
1236             :const/4 v6, #int 3 // #3
1247             :const/4 v7, #int 4 // #4
1258             :const/4 v8, #int 5 // #5
2458 0f00 5476   :filled-new-array {v4, v5, v6, v7, v8}, [I // type@000f
0c05             :move-result-object v5
6204 0500        :sget-object v4, Ljava/lang/Integer;.TYPE:Ljava/lang/Class; // field@0005
7120 1500 5400   :invoke-static {v4, v5}, Ljava/lang/reflect/Array;.newInstance:(Ljava/lang/Class;[I)Ljava/lang/Object; // method@0015
0c04             :move-result-object v4
1f04 1e00        :check-cast v4, [[[[[I // type@001e
0743             :move-object v3, v4
0e00             :return-void

3rc:指令长度48，A+C-1个寄存器，一个常量池引用
N=A寄存器数量+使用的第一个寄存器-1
如下面的例子： 数组维度是6 ， 第一个使用的寄存器是v4 ， 那么N的值是6+4-1==9

例子：

    public static void arrayTest(int a,int b,int c){
        Object[][][][][][] d = new Object[1][19][3][20][5][21];
    }

01a0           : move v0, v10
01b1           : move v1, v11
01c2           : move v2, v12
1214           : const/4 v4, #int 1 // #1
1225           : const/4 v5, #int 2 // #2
1236           : const/4 v6, #int 3 // #3
1247           : const/4 v7, #int 4 // #4
1258           : const/4 v8, #int 5 // #5
1269           : const/4 v9, #int 6 // #6
2506 0600 0400 : filled-new-array/range {v4, v5, v6, v7, v8, v9}, [I // type@0006
0c05           : move-result-object v5
1c04 0300      : const-class v4, Ljava/lang/Object; // type@0003
7120 0300 5400 : invoke-static {v4, v5}, Ljava/lang/reflect/Array;.newInstance:(Ljava/lang/Class;[I)Ljava/lang/Object; // method@0003
0c04           : move-result-object v4
1f04 0700      : check-cast v4, [[[[[[Ljava/lang/Object; // type@0007
0743           : move-object v3, v4
0e00           : return-void

31t:指令长度48，一个寄存器，跳转分支offset

例子：

public static int[] x={1,2,3,4,5,6,7,8,9};
public static void arrayTest(){
    int[] a=x;
}

1300 0900                              |0000: const/16 v0, #int 9 // #9
2300 0300                              |0002: new-array v0, v0, [I // type@0003
2600 0600 0000                         |0004: fill-array-data v0, 0000000a // +00000006
6900 0000                              |0007: sput-object v0, LBlort;.x:[I // field@0000
0e00                                   |0009: return-void
0003 0400 0900 0000 0100 0000 0200 ... |000a: array-data (22 units)

解释一下，填充v0中的数组，在000a的位置+当前指令位置0004

异常指令

11x:指令长度16，一个寄存器

例子：

2700 :throw v0 抛出异常对象，异常对象的引用在v0寄存器

跳转指令

10t:指令长度16，0个寄存器，跳转、分支

注意：分支偏移量不得为 0。（自旋循环可以用 goto/32 或通过在分支之前添加 nop 作为目标来正常构造）。

例子：

28F0 : goto 0005 // -0010 跳转到当前位置-16（hex 10）的位置， 0005 是目标指令标签。

20t:指令长度32，0个寄存器，跳转

例子：

2900 0FFE : goto/16 002f // -0 无条件 1f1 跳转到当前位置-1F1H 的位置，002f 是目标指令标签。

30t:指令长度48，0个寄存器，跳转

还没有复现这个指令。。。

31t:指令长度48，1个寄存器，跳转

例子：

    public void switchTest3(int x) {
        int b = 0;
        switch (x) {
            case 1:
                break;
            case 2:
                break;
            case 5:
                break;
            case 4:
                b = 4;
                break;
            default:
                b = 0;
        }
    }

0000: Op 0740            move-object v0, v4; */
0001: Op 0151            move v1, v5; */
0002: Op 1203            const/4 v3, 0; */
0003: Op 0132            move v2, v3; */
0004: Op 0113            move v3, v1; */
0005: Op 2b03 0d00 0000  packed-switch v3, +0xd (=0x12) */
0008: Op 1203            const/4 v3, 0; */
0009: Op 0132            move v2, v3; */
000a: Op 0e00            return-void  */
000b: Op 28ff            goto =0xa (0xffffffff) */
000c: Op 28fe            goto =0xa (0xfffffffe) */
000d: Op 28fd            goto =0xa (0xfffffffd) */
000e: Op 1243            const/4 v3, 4; */
000f: Op 0132            move v2, v3; */
0010: Op 28fa            goto =0xa (0xfffffffa) */
0x11 nop */
0012: packed-switch-payload (5 units, from 1)
     1: 0x6
     2: 0x7
     3: 0x3
     4: 0x9
     5: 0x8

31t:指令长度48，1个寄存器，跳转

例子：

    public int switchTest2(int x) {
        switch (x) {
            case 1: {
                return 2;
            }
            case 10: {
                return 3;
            }
            case 100: {
                return 4;
            }
            case 1000: {
                return 50;
            }
        }
        return 6;
    }

 0000: Op 0730            move-object v0, v3; */
 0001: Op 0141            move v1, v4; */
 0002: Op 0112            move v2, v1; */
 0003: Op 2c02 1300 0000  sparse-switch v2, +0x13 (=0x16) */
 0006: Op 1262            const/4 v2, 6; */
 0007: Op 0120            move v0, v2; */
 0008: Op 0f00            return v0; */
 0009: Op 1222            const/4 v2, 2; */
 000a: Op 0120            move v0, v2; */
 000b: Op 28fd            goto =0x8 (0xfffffffd) */
 000c: Op 1232            const/4 v2, 3; */
 000d: Op 0120            move v0, v2; */
 000e: Op 28fa            goto =0x8 (0xfffffffa) */
 000f: Op 1242            const/4 v2, 4; */
 0010: Op 0120            move v0, v2; */
 0011: Op 28f7            goto =0x8 (0xfffffff7) */
 0012: Op 1302 3200       const/16 v2, 0x32 */
 0014: Op 0120            move v0, v2; */
 0015: Op 28f3            goto =0x8 (0xfffffff3) */
 0027: sparse-switch-payload (4 units)
        /* 0: Key: 1 - 0x64 */
        /* 1: Key: 10 - 0x3e8 */
        /* 2: Key: 100 - 0x6 */
        /* 3: Key: 1000 - 0x9 */

偏移量为+0x13,说明索引表为0x03+0x13=0x16开始
这个例子和上面指令的例子不同的地方是case值是不连续的

比较指令

23x:指令长度32，3个寄存器

2d: cmpl-float (lt bias) 比较vBB和vCC中的 float 值并在vAA中存入int型的返回值
2e: cmpg-float (gt bias) 比较vBB和vCC中的 float 值并在vAA中存入int型的返回值
2f: cmpl-double (lt bias) 比较vBB和vCC中的 double 值并在vAA中存入int型的返回值
30: cmpg-double (gt bias) 比较vBB和vCC中的 double 值并在vAA中存入int型的返回值
31: cmp-long 比较vBB和vCC中的 long 值并在vAA中存入int型的返回值
NOTE:
setting a to 0 if b == c, 1 if b > c, or -1 if b < c
针对浮点数比较列出的`bias`(偏差)说明NaN比较的时候是如何处理的：`gt bias`指令说明和NaN比较返回1，`lt bias`则返回-1
虚拟机规定浮点数比较只有有 NaN进行参与就返回false，为了维持这两种等价的源码表现一致，而且字节码尽量短：
if(a < b){        if(b > a){         
    // dosth1         //dosth1       
} else {          } else {
    // dosth2         //dosth2
}                 }
具体见下面的例子
举例说明：如果要进行浮点数`x < y`比较，则建议使用`cmpg-float`

public void foo(float a,float b){
    float c;
    if( a < b){
        c = a;
    } else {
        c = b;
    }
    if(b > a){
        c = a;
    } else {
        c = b;
    }
}

0760         |0000: move-object v0, v6
0171         |0001: move v1, v7
0182         |0002: move v2, v8
0114         |0003: move v4, v1
0125         |0004: move v5, v2
2e04 0405    |0005: cmpg-float v4, v4, v5
3b04 0d00    |0007: if-gez v4, 0014 // +000d
0114         |0009: move v4, v1
0143         |000a: move v3, v4
0124         |000b: move v4, v2
0115         |000c: move v5, v1
2d04 0405    |000d: cmpl-float v4, v4, v5
3d04 0800    |000f: if-lez v4, 0017 // +0008
0114         |0011: move v4, v1
0143         |0012: move v3, v4
0e00         |0013: return-void
0124         |0014: move v4, v2
0143         |0015: move v3, v4
28f5         |0016: goto 000b // -000b
0124         |0017: move v4, v2
0143         |0018: move v3, v4
28fa         |0019: goto 0013 // -0006

22t:指令长度32，2个寄存器,跳转

注意：分支偏移量不得为 0。（自旋循环可以通过围绕后向 goto 进行分支或通过在分支之前添加 nop 作为目标来正常构造。）

指令说明：

A: first register to test (4 bits)
B: second register to test (4 bits)
C: signed branch offset (16 bits)
32: if-eq 如果vA==vB 跳转到目标 vA和vB是int型
33: if-ne 如果vA!=vB 跳转到目标 vA和vB是int型
34: if-lt 如果vA<vB  跳转到目标 vA和vB是int型
35: if-ge 如果vA>=vB 跳转到目标 vA和vB是int型
36: if-gt 如果vA>vB  跳转到目标 vA和vB是int型
37: if-le 如果vA<=vB 跳转到目标 vA和vB是int型
NOTE:
目标地址的偏移量不能是0 否则会发生死循环

例子：

boolean c = false;
c = a == b;
c = a != b;
c = a < b;
c = a >= b;
c = a > b;
c = a <= b;

3310 0200  : if-ne v0, v1, 0002 // +0002
3210 0200  : if-eq v0, v1, 0004 // +0002
3510 0200  : if-ge v0, v1, 0006 // +0002
3410 0200  : if-lt v0, v1, 0008 // +0002
3710 0200  : if-le v0, v1, 000a // +0002
3610 0200  : if-gt v0, v1, 000c // +0002

21t:指令长度32，一个寄存器

指令说明：

38: if-eqz 如果 vAA==0，跳转到目标 vAA是int值
39: if-nez 如果 vAA!=0，跳转到目标 vAA是int值
3a: if-ltz 如果 vAA<0，跳转到目标 vAA是int值
3b: if-gez 如果 vAA>=0，跳转到目标 vAA是int值
3c: if-gtz 如果 vAA>0，跳转到目标 vAA是int值
3d: if-lez 如果 vAA<=0，跳转到目标 vAA是int值

字段操作指令

23x:指令长度32，3个寄存器

指令说明：

A: value register or pair; may be source or dest (8 bits)
B: array register (8 bits)
C: index register (8 bits)
44: aget          从int数组中获取一个int值到vAA中，目的数组的引用位于vBB，需要获取元素的索引位于vCC中
45: aget-wide     从long/double数组中获取一个long/double值到vAA,vAA+1中，数组的引用位于vBB，需要获取元素的索引位于vCC中
46: aget-object   从对象数组中获取一个对象引用值到vAA中，目的数组的引用位于vBB，需要获取元素的索引位于vCC中
47: aget-boolean 从boolean数组中获取一个boolean值到vAA中，目的数组的引用位于vBB，需要获取元素的索引位于vCC中
48: aget-byte 从byte数组中获取一个byte值到vAA中，目的数组的引用位于vBB，需要获取元素的索引位于vCC中
49: aget-char 从char数组中获取一个char值到vAA中，目的数组的引用位于vBB，需要获取元素的索引位于vCC中
4a: aget-short 从short数组中获取一个short值到vAA中，目的数组的引用位于vBB，需要获取元素的索引位于vCC中 
4b: aput         将vAA的int值存入int数组，数组引用位于vBB，元素的索引位于vCC
4c: aput-wide  将vAA,vAA+1的long/double值存入long/double数组，数组引用位于vBB，元素的索引位于vCC
4d: aput-object 将vAA的对象引用存入对象引用数组，数组引用位于vBB，元素的索引位于vCC
4e: aput-boolean 将vAA的boolean值存入boolean数组，数组引用位于vBB，元素的索引位于vCC
4f: aput-byte 将vAA的byte值存入byte数组，数组引用位于vBB，元素的索引位于vCC
50: aput-char 将vAA的char值存入char数组，数组引用位于vBB，元素的索引位于vCC
51: aput-short 将vAA的short值存入short数组，数组引用位于vBB，元素的索引位于vCC

public static void testx2(){
      int[] a = new int[2];
      double[] b = new double[2];
      Object[] c = new Object[2];
      boolean[] d = new boolean[2];
      byte[] e = new byte[2];
      char[] f = new char[2];
      short[] g = new short[2];
      a[0] = 1;
      b[0] = 1;
      c[0] = new Object();
      d[0] = true;
      e[0] = 1;
      f[0] = 'a';
      g[0] = 1;
}

 121a           : const/4 v10, #int 1 // #1
 1226           : const/4 v6, #int 2 // #2
 1207           : const/4 v7, #int 0 // #0
 2360 0700      : new-array v0, v6, [I // type@0007
 2361 0600      : new-array v1, v6, [D // type@0006
 2362 0800      : new-array v2, v6, [Ljava/lang/Object; // type@0008
 2363 0a00      : new-array v3, v6, [Z // type@000a
 2364 0400      : new-array v4, v6, [B // type@0004
 2365 0500      : new-array v5, v6, [C // type@0005
 2366 0900      : new-array v6, v6, [S // type@0009
 4b0a 0007      : aput v10, v0, v7
 1908 f03f      : const-wide/high16 v8, #long 4607182418800017408 // #3ff0
 4c08 0107      : aput-wide v8, v1, v7
 2200 0200      : new-instance v0, Ljava/lang/Object; // type@0002
 7010 0300 0000 : invoke-direct {v0}, Ljava/lang/Object;.<init>:()V //method@0003
 4d00 0207      : aput-object v0, v2, v7
 4e0a 0307      : aput-boolean v10, v3, v7
 4f0a 0407      : aput-byte v10, v4, v7
 1300 6100      : const/16 v0, #int 97 // #61
 5000 0507      : aput-char v0, v5, v7
 510a 0607      : aput-short v10, v6, v7
 0e00           : return-void

22c:指令长度32，两个寄存器，常量池索引

注意：这些运算码是静态链接的合理候选项，将字段参数更改为更直接的偏移量

指令说明：

A: value register or pair; may be source or dest (4 bits)
B: object register (4 bits)
C: instance field reference index (16 bits)
52: iget          根据 字段 id 读取实例的int类型字段到 vA 中， vB 寄存器中是该实例的引用
53: iget-wide    根据 字段 id 读取实例的long/double类型字段到 vA 中， vB 寄存器中是该实例的引用
54: iget-object  根据 字段 id 读取实例的对象引用字段到 vA 中， vB 寄存器中是该实例的引用
55: iget-boolean 根据 字段 id 读取实例的boolean类型字段到 vA 中， vB 寄存器中是该实例的引用
56: iget-byte    根据 字段 id 读取实例的byte类型字段到 vA 中， vB 寄存器中是该实例的引用
57: iget-char    根据 字段 id 读取实例的char类型字段到 vA 中， vB 寄存器中是该实例的引用
58: iget-short   根据 字段 id 读取实例的short类型字段到 vA 中， vB 寄存器中是该实例的引用
59: iput         根据 字段 id 将vA寄存器中的值存入实例的 int 型字段,vB 寄存器中是该实例的引用
5a: iput-wide    根据 字段 id 将vA寄存器中的值存入实例的 long/double 型字段,vB 寄存器中是该实例的引用
5b: iput-object  根据 字段 id 将vA寄存器中的值存入实例的对象引用字段,vB 寄存器中是该实例的引用
5c: iput-boolean 根据 字段 id 将vA寄存器中的值存入实例的 boolean 型字段,vB 寄存器中是该实例的引用
5d: iput-byte    根据 字段 id 将vA寄存器中的值存入实例的 byte 型字段,vB 寄存器中是该实例的引用
5e: iput-char    根据 字段 id 将vA寄存器中的值存入实例的 char 型字段,vB 寄存器中是该实例的引用
5f: iput-short   根据 字段 id 将vA寄存器中的值存入实例的 short 型字段,vB 寄存器中是该实例的引用

例子：

public class Blort
{
    public boolean insBoolean;
    public byte insByte;
    public char insChar;
    public short insShort;
    public int insInt;
    public long insLong;
    public float insFloat;
    public double insDouble;
    public Object insObject;
    public void test2(boolean a,byte b,char c,short d,int e,long f,float g,double h,Object i) {
        insBoolean   = a;
        insByte      = b;
        insChar      = c;
        insShort     = d;
        insInt       = e;
        insLong      = f;
        insFloat     = g;
        insDouble    = h;
        insObject    = i;
        a  = insBoolean;
        b  = insByte   ;
        c  = insChar   ;
        d  = insShort  ;
        e  = insInt    ;
        f  = insLong   ;
        g  = insFloat  ;
        h  = insDouble ;
        i  = insObject ;
    }
}