Java反编译器剖析（上）

ImportNew  •  扫码分享
我是创始人李岩：很抱歉！给自己产品做个广告，点击进来看看。  
分享到：


本文由 ImportNew - 邬柏 翻译自 javacodegeeks。如需转载本文，请先参见文章末尾处的转载要求。

Importnew注：如果你也对Java技术翻译分享感兴趣，欢迎加入我们的Java开发小组。参与方式请查看小组简介。

反编译器（或者解码器），简而言之，就是将目标程序码反转成源代码。但是其中的过程却比较复杂，也很有意思——Java源码是结构化的，字节码却不是。而且，转换不是一一对应的：两段完全不同的Java程序也可能生成完全相同的字节码，有时需要一些试探才能更加接近源码。

（一段简短的）字节码教程

为了更好的理解反编译器如何工作，现在有必要理解一下字节码基础。如果你对此非常熟悉，可以略过此处直接跳到下一部分。

（不同于基于寄存器 register-based 的方式）JVM运行基于栈。这就意味着指令会在 evaluation stack（计算堆栈）上执行。操作对象可能先出栈，进行一些操作，然后再把结果入栈来进行接下来的操作。考虑如下场景：

public static int plus(int a, int b) {
    int c = a + b;
    return c;
}

注：本文所有的相关的字节码都是由 javap 产生，例如执行命令 javap -c -p MyClass。

public static int plus(int, int);
 Code:
  stack=2, locals=3, arguments=2
   0: iload_0    // load ‘x’ from slot 0, push onto stack
   1: iload_1    // load ‘y’ from slot 1, push onto stack
   2: iadd       // pop 2 integers, add them together, and push the result
   3: istore_2   // pop the result, store as ‘sum’ in slot 2
   4: iload_2    // load ‘sum’ from slot 2, push onto stack
   5: ireturn    // return the integer at the top of the stack

方法中的本地变量（包括方法声明）被寄存在所谓的JVM本地变量数组中。为了简单起见，在这里我们将一个存放在本地变量数组位置 #x 处的变量称为 slot#x （参见JVM规范3.6.1）。

对于示例方法，slot#0 的值一般是 this 指针。然后从左到右依次是方法中的各个变量，接下来是方法中声明的本地变量。在上面的示例中，由于方法是静态的，所以没有 this 指针。相应的 slot#0 存放的是参数 x，slot#y 存放的是参数 y，本地变量 sum 存放在 slot#2 中。

有意思的是，每个方法的栈大小和本地变量存储空间都有最大值的限制。二者都是在编译时决定。

目前为止，所有内容都是非常直白的，仅有一点没有达到你的预期：编译器一直没有尝试去优化这些代码。事实上，javac 几乎从未支持字节码优化。这样有很多好处，比如几乎可以在任何地方设置断点：一旦移除 load/store 操作，就会失去这种特性。所以，大部分压力都转移到了运行时JIT编译器（just-in-time compiler）。

反编译

那么，怎样才能将一个非结构化、基于栈的字节码转换为结构化的Java代码呢？通常，第一步要先摈弃操作对象栈。可以通过映射栈的值成变量，并插入合适的 load/store 操作来实现这个步骤。

如果一个“栈变量”仅仅分配并使用一次，你会发现这将产生非常多的重复变量——而且接下来会生成的重复变量会更多！反编译器会将这些字节码缩减成更简单的指令集。这里对此不作深究。

我们使用 s0 代表栈变量， v0 代表原始的字节码在本地的真实引用（存在 slot 上）。

字节码 栈变量 复制传播
0
1
2
3
4
5
 iload_0
iload_1
iadd
istore_2
iload_2
ireturn
 s0 = v0
s1 = v1
s2 = s0 + s1
v2 = s2
s3 = v2
return s3
 v2 = v0 + v1

return v2

通过为 push 或 pop 的每个值分配一个标识符，可以将字节码转换为本地变量。比如 iadd 是将两个操作数出栈并、相加，并将结果入栈。

然后，使用一种复制传播（copy propagation）的技术，可以消除一些重复变量。复制传播是内联的一种形式，可以将变量简单替换为指定值，前提是这种转换是有效的。

如何定义”有效性“？这里包含了一些重要准则。考虑下面这种情况：

0: s0 = v1
1: v1 = s4
2: v2 = s0 <-- s0 cannot be replaced with v1

在这里，如果将 s0 替换为 v1 结果将大不相同。因为 v1 的值在 s0 被指定之后改变了，虽然此时 v1 的值却还没有被使用（译注：原文这里是V0，根据注释可以确认为笔误）。为了避开这种复杂的情形，这里复制传播只考虑仅被赋值一次的内联变量（inline variable）。

译注：一个简单的（C语言）内联变量手动解析示例，来自Wikipedia:inline expansion

int pred(int x) {
    if (x == 0)
       return 0;
    else
       return x - 1;
}

进行 inline 操作前：

int f(int y) {
     return pred(y) + pred(0) + pred(y+1);
 }

进行 inline 操作以后：

int f(int y) {
    int temp;
    if (y   == 0) temp  = 0; else temp  = y       - 1; /* (1) */
    if (0   == 0) temp += 0; else temp += 0       - 1; /* (2) */
    if (y+1 == 0) temp += 0; else temp += (y + 1) - 1; /* (3) */
    return temp;
}

一种改进的方案——跟踪所有非栈变量的存储空间。比如，我们知道 v1 在 #0 赋值给 v10，同时在 #2 被赋值给 v11。当对 v1 赋值超过一次，则不能进行复制传播。

不过我们最初的那个例子没有这么复杂，因而我们得到如下的优美精确的结果：

v2 = v0 + v1
return v2

画外音：存储变量名

如果变量在字节码中被简化为 slot 的引用，那么接下来怎样才能知道原来对象的名称呢？很有可能无法知道。为了改变这情况，改进调试的用户体验，每个方法的字节码都包含有一个特殊的部分——本地变量表。这个表中记录了原代码中每个变量的名称、slot 编号和变量名对应的字节码。通过 javap 的 -v 选项可以把本地变量表（以及其他有用的元数据）包含到反汇编代码。对于上面示例中的 plus() 方法，它的本地变量表看起来像下面这样：

Start  Length  Slot  Name   Signature
0      6       0     a      I
0      6       1     b      I
4      2       2     c      I

可以看到 v2 是 int 类型的变量，原来变量名为 c，偏移位于字节码 #4-5。

如果编译的类没有包含本地变量表（也可能被混淆器删掉），必须自己生成变量名。处理这种情况有很多办法：聪明的方法会根据变量的使用情况定义合适的名字。

栈分析

前面的示例中，在任何时刻都可以确保栈顶的变量，因此可以依次命名为 s0、s1等。

目前为止，在处理变量的时候都是比较直接的，因为我们仅仅采用一种代码路径来探索方法。在真实的应用环境里，多数的方法都不是那么”善解人意“。每当为方法增加一个循环或者判断，就会增加了很多可能的调用情况。让我们来看一下改进版的示例：

public static int plus(boolean t, int a, int b) {
    int c = t ? a : b;
    return c;
}

现在情况更加复杂，如果按照之前的分配方式操作，将会遇到很大的问题。

字节码 栈变量
0
1
4
5
8
9
10
11
 iload_0
ifeq 8
iload_1
goto 9
iload_2
istore_3
iload_3
ireturn
 s0 = v0
if (s0 == 0) goto #8
s1 = v1
goto #9
s2 = v2
v3 = {s1,s2}
s4 = v3
return s4

我们需要对如何用栈标识符赋值更加谨慎。由于可能有多个路径能够到达，因此仅考虑每个指令自身是不够的，需要对给定的位置查看整个栈的情况。

在我们检查 #9 的时候，看到 istore_3 出栈了一个值。但是这个值可能有两个来源，可能来自于 #5 或者 #8。栈顶 #9 的值可能是 s1 也可能是 s2，这取决于它是来自于 #5 还是 #8。因此，我们认为这可能是同一个变量——因此我们将其合并，所有引用 s1 或者 s2 的地方都指向这个无歧义的变量 s{1,2}。”重新标记“（relabeling）后，可以安全地进行复制传播。

重新标记后 复制传播后
0
1
4
5
8
9
10
11
 s0 = v0
if (s0 == 0) goto #8
s{1,2} = v1
goto #9
s{1,2} = :v2
v3 = s{1,2}
s4 = v3
return s4
if (v0 == 0) goto #8
s{1,2} = v1
goto #9
s{1,2} = v2
v3 = s{1,2}return v3

值得注意的是：在 #1 处的条件分支：如果 s0 的值是0，就跳到 else 块；否则，继续当前的路径。有趣的是，与原始代码相比，这里测试条件是取反的。

接下来将我们进行更深入的研究……


原文链接： javacodegeeks 翻译： ImportNew.com - 邬柏
译文链接： http://www.importnew.com/9155.html
[ 转载请保留原文出处、译者和译文链接。]



可能感兴趣的文章

随意打赏

提交建议
微信扫一扫，分享给好友吧。
关闭