如何判断变量是否冗余
如果在IntelliJ IDEA当中编写如下的代码，它会提示str2和str3局部变量是多余的：
public class HelloWorld {
public void test() {
String str1 = "Hello ASM";
Object obj1 = new Object();
// Local variable 'str2' is redundant
String str2 = str1;
Object obj2 = new Object();
// Local variable 'str3' is redundant
String str3 = str2;
Object obj3 = new Object();
int length = str3.length();
System.out.println(length);
}
}
整体思路
结合Analyzer和SimpleVerifier类，我们可以查看Frame的变化情况：
test:()V
000: ldc "Hello ASM" {HelloWorld, ., ., ., ., ., ., .} | {}
001: astore_1 {HelloWorld, ., ., ., ., ., ., .} | {String}
002: new Object {HelloWorld, String, ., ., ., ., ., .} | {}
003: dup {HelloWorld, String, ., ., ., ., ., .} | {Object}
004: invokespecial Object.<init> {HelloWorld, String, ., ., ., ., ., .} | {Object, Object}
005: astore_2 {HelloWorld, String, ., ., ., ., ., .} | {Object}
006: aload_1 {HelloWorld, String, Object, ., ., ., ., .} | {}
007: astore_3 {HelloWorld, String, Object, ., ., ., ., .} | {String}
008: new Object {HelloWorld, String, Object, String, ., ., ., .} | {}
009: dup {HelloWorld, String, Object, String, ., ., ., .} | {Object}
010: invokespecial Object.<init> {HelloWorld, String, Object, String, ., ., ., .} | {Object, Object}
011: astore 4 {HelloWorld, String, Object, String, ., ., ., .} | {Object}
012: aload_3 {HelloWorld, String, Object, String, Object, ., ., .} | {}
013: astore 5 {HelloWorld, String, Object, String, Object, ., ., .} | {String}
014: new Object {HelloWorld, String, Object, String, Object, String, ., .} | {}
015: dup {HelloWorld, String, Object, String, Object, String, ., .} | {Object}
016: invokespecial Object.<init> {HelloWorld, String, Object, String, Object, String, ., .} | {Object, Object}
017: astore 6 {HelloWorld, String, Object, String, Object, String, ., .} | {Object}
018: aload 5 {HelloWorld, String, Object, String, Object, String, Object, .} | {}
019: invokevirtual String.length {HelloWorld, String, Object, String, Object, String, Object, .} | {String}
020: istore 7 {HelloWorld, String, Object, String, Object, String, Object, .} | {I}
021: getstatic System.out {HelloWorld, String, Object, String, Object, String, Object, I} | {}
022: iload 7 {HelloWorld, String, Object, String, Object, String, Object, I} | {PrintStream}
023: invokevirtual PrintStream.println {HelloWorld, String, Object, String, Object, String, Object, I} | {PrintStream, I}
024: return {HelloWorld, String, Object, String, Object, String, Object, I} | {}
================================================================
我们的整体思路是这样的：
- 在每一个Frame当中，它有local variable和operand stack两部分组成。
- 程序中定义的“变量”是存储在local variable当中。
- 在理想的情况下，一个“变量”对应于local variable当中的一个位置；如果一个“变量”对应于local variable当中的两个或多个位置，那么我们就认为“变量”出现了冗余。
那么，针对某一个具体的frame，相应的实现思路上是这样的：
- 判断
local[0]和local[1]是否相同，如果相同，那么表示local[1]是冗余的变量。 - 判断
local[0]和local[2]是否相同，如果相同，那么表示local[2]是冗余的变量。 - …
- 判断
local[0]和local[n]是否相同，如果相同，那么表示local[n]是冗余的变量。 - 判断
local[1]和local[2]是否相同，如果相同，那么表示local[2]是冗余的变量。 - 判断
local[1]和local[3]是否相同，如果相同，那么表示local[3]是冗余的变量。 - …
需要注意的一点就是，如果local variable当中存储“未初始化的值”（BasicValue.UNINITIALIZED_VALUE），那么我们就不进行处理了。
具体来说，“未初始化的值”（BasicValue.UNINITIALIZED_VALUE）有两种情况：
- 第一种情况，在方法刚进入的时候，local variable有些位置存储的就是“未初始化的值”（
BasicValue.UNINITIALIZED_VALUE）。 - 第二种情况，在存储
long和double类型的数据时，它占用两个位置，其中第二个位置就是“未初始化的值”（BasicValue.UNINITIALIZED_VALUE）。
为什么选择SimpleVerifier
在ASM当中，Interpreter类是一个抽象类，其中提供的子类有BasicInterpreter、BasicVerifier、SimpleVerifier和SourceInterpreter类。那么，我们到底应该选择哪一个呢？
┌───┬───────────────────┬─────────────┬───────┐
│ 0 │ Interpreter │ Value │ Range │
├───┼───────────────────┼─────────────┼───────┤
│ 1 │ BasicInterpreter │ BasicValue │ 7 │
├───┼───────────────────┼─────────────┼───────┤
│ 2 │ BasicVerifier │ BasicValue │ 7 │
├───┼───────────────────┼─────────────┼───────┤
│ 3 │ SimpleVerifier │ BasicValue │ N │
├───┼───────────────────┼─────────────┼───────┤
│ 4 │ SourceInterpreter │ SourceValue │ N │
└───┴───────────────────┴─────────────┴───────┘
首先，不能选择BasicInterpreter和BasicVerifier类。因为它们使用7个值（BasicValue类定义的7个静态字段）来模拟Frame的变化，这7个值的“表达能力”很弱。如果一个对象是String类型，另一个对象是Object类型，这两个对象都会被表示成BasicValue.REFERENCE_VALUE，没有办法进行区分。
其次，不能选择SourceInterpreter类。因为它定义的copyOperation方法中会创建一个新的对象（new SourceValue(value.getSize(), insn)），不能识别为同一个对象。
public class SourceInterpreter extends Interpreter<SourceValue> implements Opcodes {
@Override
public SourceValue copyOperation(final AbstractInsnNode insn, final SourceValue value) {
return new SourceValue(value.getSize(), insn);
}
}
为什么要关注这个copyOperation方法呢？因为copyOperation方法负责处理load和store相关的指令。
public abstract class Interpreter<V extends Value> {
/**
* Interprets a bytecode instruction that moves a value on the stack or to or from local variables.
* This method is called for the following opcodes:
*
* ILOAD, LLOAD, FLOAD, DLOAD, ALOAD,
* ISTORE, LSTORE, FSTORE, DSTORE, ASTORE,
* DUP, DUP_X1, DUP_X2, DUP2, DUP2_X1, DUP2_X2, SWAP
*
*/
public abstract V copyOperation(AbstractInsnNode insn, V value) throws AnalyzerException;
}
最后，选择SimpleVerifier是合适的。一方面，它能区分不同的类型（class）、区分不同的对象实例（object instance）；另一方面，在copyOperation方法中保证了对象的一致性，传入的是value，返回的仍然是value。更准确的来说，SimpleVerifier是继承了父类BasicVerifier类的copyOperation方法。
public class BasicVerifier extends BasicInterpreter {
@Override
public BasicValue copyOperation(final AbstractInsnNode insn, final BasicValue value)
throws AnalyzerException {
//...
return value;
}
}
示例：冗余变量分析
预期目标
在下面的代码中，会提示str2和str3局部变量是多余的：
public class HelloWorld {
public void test() {
String str1 = "Hello ASM";
Object obj1 = new Object();
// Local variable 'str2' is redundant
String str2 = str1;
Object obj2 = new Object();
// Local variable 'str3' is redundant
String str3 = str2;
Object obj3 = new Object();
int length = str3.length();
System.out.println(length);
}
}
我们的预期目标：识别出str2和str3是冗余变量。
编码实现
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.tree.AbstractInsnNode;
import org.objectweb.asm.tree.InsnList;
import org.objectweb.asm.tree.MethodNode;
import org.objectweb.asm.tree.VarInsnNode;
import org.objectweb.asm.tree.analysis.*;
import java.util.Arrays;
public class RedundantVariableDiagnosis {
public static int[] diagnose(String className, MethodNode mn) throws AnalyzerException {
// 第一步，准备工作。使用SimpleVerifier进行分析，得到frames信息
Analyzer<BasicValue> analyzer = new Analyzer<>(new SimpleVerifier());
Frame<BasicValue>[] frames = analyzer.analyze(className, mn);
// 第二步，利用frames信息，查看local variable当中哪些slot数据出现了冗余
TIntArrayList localIndexList = new TIntArrayList();
for (Frame<BasicValue> f : frames) {
int locals = f.getLocals();
for (int i = 0; i < locals; i++) {
BasicValue val1 = f.getLocal(i);
if (val1 == BasicValue.UNINITIALIZED_VALUE) {
continue;
}
for (int j = i + 1; j < locals; j++) {
BasicValue val2 = f.getLocal(j);
if (val2 == BasicValue.UNINITIALIZED_VALUE) {
continue;
}
if (val1 == val2) {
if (!localIndexList.contains(j)) {
localIndexList.add(j);
}
}
}
}
}
// 第三步，将slot的索引值（local index）转换成instruction的索引值（insn index）
TIntArrayList insnIndexList = new TIntArrayList();
InsnList instructions = mn.instructions;
int size = instructions.size();
for (int i = 0; i < size; i++) {
AbstractInsnNode node = instructions.get(i);
int opcode = node.getOpcode();
if (opcode >= Opcodes.ISTORE && opcode <= Opcodes.ASTORE) {
VarInsnNode varInsnNode = (VarInsnNode) node;
if (localIndexList.contains(varInsnNode.var)) {
if (!insnIndexList.contains(i)) {
insnIndexList.add(i);
}
}
}
}
// 第四步，将insnIndexList转换成int[]形式
int[] array = insnIndexList.toNativeArray();
Arrays.sort(array);
return array;
}
}
进行分析
public class HelloWorldAnalysisTree {
public static void main(String[] args) throws Exception {
String relative_path = "sample/HelloWorld.class";
String filepath = FileUtils.getFilePath(relative_path);
byte[] bytes = FileUtils.readBytes(filepath);
//（1）构建ClassReader
ClassReader cr = new ClassReader(bytes);
//（2）生成ClassNode
int api = Opcodes.ASM9;
ClassNode cn = new ClassNode(api);
int parsingOptions = ClassReader.SKIP_DEBUG | ClassReader.SKIP_FRAMES;
cr.accept(cn, parsingOptions);
//（3）进行分析
List<MethodNode> methods = cn.methods;
MethodNode mn = methods.get(1);
int[] array = RedundantVariableDiagnosis.diagnose(cn.name, mn);
System.out.println(Arrays.toString(array));
BoxDrawingUtils.printInstructionLinks(mn.instructions, array);
}
}
输出结果：
[7, 13]
000: ldc "Hello ASM"
001: astore_1
002: new Object
003: dup
004: invokespecial Object.<init>
005: astore_2
006: aload_1
┌──── 007: astore_3
│ 008: new Object
│ 009: dup
│ 010: invokespecial Object.<init>
│ 011: astore 4
│ 012: aload_3
└──── 013: astore 5
014: new Object
015: dup
016: invokespecial Object.<init>
017: astore 6
018: aload 5
019: invokevirtual String.length
020: istore 7
021: getstatic System.out
022: iload 7
023: invokevirtual PrintStream.println
024: return
测试用例
primitive type - no
本文介绍的方法不适合对primitive type进行分析：
- 所有
int类型的值都用BasicValue.INT_VALUE表示，不能对两个不同的值进行区分 - 所有
float类型的值都用BasicValue.FLOAT_VALUE表示，不能对两个不同的值进行区分 - 所有
long类型的值都用BasicValue.LONG_VALUE表示，不能对两个不同的值进行区分 - 所有
double类型的值都用BasicValue.DOUBLE_VALUE表示，不能对两个不同的值进行区分
public class HelloWorld {
public void test() {
int a = 1;
int b = 2;
int c = a + b;
int d = a - b;
int e = c * d;
System.out.println(e);
}
}
输出结果（错误）：
[3, 7, 11, 15]
000: iconst_1
001: istore_1
002: iconst_2
┌──── 003: istore_2
│ 004: iload_1
│ 005: iload_2
│ 006: iadd
├──── 007: istore_3
│ 008: iload_1
│ 009: iload_2
│ 010: isub
├──── 011: istore 4
│ 012: iload_3
│ 013: iload 4
│ 014: imul
└──── 015: istore 5
016: getstatic System.out
017: iload 5
018: invokevirtual PrintStream.println
019: return
return-no
本文介绍的方法也不适用于return语句的判断。在下面的代码中，会提示result局部变量是多余的：
public class HelloWorld {
public Object test() {
// Local variable 'result' is redundant
Object result = new Object();
return result;
}
}
我觉得，可以使用astore aload areturn的指令组合来识别这种情况，不一定要使用Frame的分析做到。
总结
本文内容总结如下：
- 第一点，如何判断一个变量是否冗余呢？看看local variable当中是否有两个或多个相同的值。
- 第二点，代码示例，编码实现冗余变量分析。