获取方法中局部变量的数量

Question

所以我有一些 classes 插入了 "dummy method calls"；即专用 class 中的静态方法具有空主体。

我们的想法是获取在方法调用之前被压入堆栈的参数，将它们存储在局部变量中，然后用实际实现替换方法调用。

要了解如何处理当地人，我运行

A.java

package asmvisit;

public class A {
    long y;

    public long doSomething(int x, A a){
        if(a == null){
            this.y = (long)x;
            return -1L;
        }
        else{
            long old = y;
            this.y += (long)x;
            return old;
        }
    }
}

通过 textifier（代码在 post 底部）。

正如您在输出中看到的（也在 post 的底部），局部变量

    LOCALVARIABLE old J L4 L6 3
    LOCALVARIABLE this Lasmvisit/A; L0 L6 0
    LOCALVARIABLE x I L0 L6 1
    LOCALVARIABLE a Lasmvisit/A; L0 L6 2

在方法的最后访问。

从技术上讲，我们可以更早地访问它们，但我明白为什么在任意位置插入本地人可能会搞砸编号 -- 以及程序。

所以在我看来，添加更多局部变量的唯一安全方法是通过每种方法运行两次：

曾经除了计算局部变量访问次数外什么也没做
一旦实际修改代码，跟踪本地 "generated"，但将实际生成（即访问本地）延迟到 visitMaxs 之前，使用计数器跟踪新当地人最终将拥有的指数。

是否有不需要两次通过的更简单的替代方案？

textifier

package asmvisit;

import org.objectweb.asm.ClassVisitor;
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.util.Printer;
import org.objectweb.asm.util.Textifier;
import org.objectweb.asm.util.TraceMethodVisitor;

import java.io.PrintWriter;
import java.util.Arrays;

public class MyClassVisitor extends ClassVisitor {
    public MyClassVisitor(ClassVisitor cv) {
        super(Opcodes.ASM5, cv);
    }

    @Override
    public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {
        System.out.println(String.format("\nvisitMethod: %d, %s, %s, %s, %s", access,name,desc,signature, Arrays.toString(exceptions)));

        Printer p = new Textifier(api) {
            @Override
            public void visitMethodEnd() {
                PrintWriter pw = new PrintWriter(System.out);
                print(pw); // print it after it has been visited
                pw.flush();
            }
        };

        MethodVisitor mv = cv.visitMethod(access, name, desc, signature, exceptions);
        if(mv != null){
            return new TraceMethodVisitor(mv,p);
        }

        return mv;
    }
}

输出

visitMethod: 1, <init>, ()V, null, null
L0
    LINENUMBER 3 L0
    ALOAD 0
    INVOKESPECIAL java/lang/Object.<init> ()V
    RETURN
L1
    LOCALVARIABLE this Lasmvisit/A; L0 L1 0
    MAXSTACK = 1
    MAXLOCALS = 1

visitMethod: 1, doSomething, (ILasmvisit/A;)J, null, null
L0
    LINENUMBER 7 L0
    ALOAD 2
    IFNONNULL L1
L2
    LINENUMBER 8 L2
    ALOAD 0
    ILOAD 1
    I2L
    PUTFIELD asmvisit/A.y : J
L3
    LINENUMBER 9 L3
    LDC -1
    LRETURN
L1
    LINENUMBER 12 L1
FRAME SAME
    ALOAD 0
    GETFIELD asmvisit/A.y : J
    LSTORE 3
L4
    LINENUMBER 13 L4
    ALOAD 0
    DUP
    GETFIELD asmvisit/A.y : J
    ILOAD 1
    I2L
    LADD
    PUTFIELD asmvisit/A.y : J
L5
    LINENUMBER 14 L5
    LLOAD 3
    LRETURN
L6
    LOCALVARIABLE old J L4 L6 3
    LOCALVARIABLE this Lasmvisit/A; L0 L6 0
    LOCALVARIABLE x I L0 L6 1
    LOCALVARIABLE a Lasmvisit/A; L0 L6 2
    MAXSTACK = 5
    MAXLOCALS = 5

Answer 1

visitLocalVariable 报告的局部变量只是调试信息，存储在LocalVariableTable attribute and LocalVariableTypeTable attribute 中。如果这些属性不存在，则不会报告此类声明。

此外，对于字节码级变量，它们不需要是完整的，即它们不报告由 long 和 double 值占用的第二个变量。它们也可能不包括合成变量，例如 for-each 构造（包含隐藏的迭代器）、try-with-resource 构造（包含挂起的异常）或挂起的值，如 in
try { return expression; } finally { otherAction(); } 构造。

在字节码层面上，局部变量是通过实际向其中存储值来建立的（仅指索引）。在源代码级别具有分离范围的变量可以在堆栈帧中使用相同的索引。对于字节码，对同一索引的两次写入实际上是对同一变量的更改还是两个具有不同范围的变量并不重要。但是 visitMaxs 报告的大小必须足够大以容纳操作数堆栈元素和方法堆栈帧中使用的所有变量索引。此外，堆栈映射 table 帧对于指定分支目标的预期类型的新 class 文件是强制性的。

由于 ASM 在访问结束时报告旧的 max locals，因此您不能使用它来使用比事先更大的索引，但这不是必需的。如上所述，变量索引不需要是唯一的。你的用例就像引入一个新的变量范围，所以你可以使用之前没有使用过的索引，如果这些索引在你的注入代码结束后被后续代码再次使用也没有问题。

如果您可以只支持具有 StackMapTable attributes 的较新的 class 文件，那么获取在某个点之前使用过的索引并不难。对于这些 classes，您只需关心两个事件。在分支目标处，visitFrame 将报告此时正在使用哪些变量。将 EXPAND_FRAMES 指定为 ClassReader 时，使用此信息会更容易。另一个需要注意的事件是实际的变量使用指令（实际上，只有存储很重要），这些指令通过 visitVarInsn 报告。放在一起，草图看起来像

classReader.accept(new ClassVisitor(Opcodes.ASM5) {
    @Override
    public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {
        return new MyMethodVisitor(access, desc);
    }
}, ClassReader.EXPAND_FRAMES);

class MyMethodVisitor extends MethodVisitor {
    private int used, usedAfterInjection;

    public MyMethodVisitor(int acc, String signature) {
        super(Opcodes.ASM5);
        used = Type.getArgumentsAndReturnSizes(signature)>>2;
        if((acc&Opcodes.ACC_STATIC)!=0) used--; // no this
    }

    @Override
    public void visitFrame(
            int type, int nLocal, Object[] local, int nStack, Object[] stack) {
        if(type != Opcodes.F_NEW)
            throw new IllegalStateException("only expanded frames supported");
        int l = nLocal;
        for(int ix = 0; ix < nLocal; ix++)
            if(local[ix]==Opcodes.LONG || local[ix]==Opcodes.DOUBLE) l++;
        if(l > used) used = l;
        super.visitFrame(type, nLocal, local, nStack, stack);
    }

    @Override
    public void visitVarInsn(int opcode, int var) {
        int newMax = var+(opcode==Opcodes.LSTORE || opcode==Opcodes.DSTORE? 2: 1);
        if(newMax > used) used = newMax;
        super.visitVarInsn(opcode, var);
    }

    @Override
    public void visitMethodInsn(
            int opcode, String owner, String name, String desc, boolean itf) {
        if(!shouldReplace(owner, name, desc)) {
            super.visitMethodInsn(opcode, owner, name, desc, itf);
        }
        else {
            int numVars = (Type.getArgumentsAndReturnSizes(desc)>>2)-1;
            usedAfterInjection = used+numVars;
            /*
              use local vars between [used, usedAfterInjection]
            */
        }
    }
    @Override
    public void visitMaxs(int maxStack, int maxLocals) {
        super.visitMaxs(maxStack, Math.max(used, usedAfterInjection));
    }
}

需要注意的是，将long或double值存储到变量中时，index + 1处的变量也必须被视为正在使用。相反，在堆栈映射 table 属性的帧中，这些 long 和 double 被报告为单个条目，因此我们必须查找它们并适当增加使用的变量数.

通过跟踪 used 变量，我们可以简单地使用 visitMethodInsn 内超出该数字的变量，如前所述，只需将值存储到这些索引中，而无需通过 [=12] 报告它们=].之后也不需要声明它们超出范围，后续代码可能会也可能不会覆盖这些索引。

然后 visitMaxs 必须报告更改后的大小，如果大于旧大小（除非您使用 COMPUTE_MAXS 或 COMPUTE_FRAMES）。

获取方法中局部变量的数量

getting the number of local variables in a method

java

bytecode

instrumentation

java-bytecode-asm