Question

所以我有一些插入了“伪方法调用”的类;即具有空体的专用类中的静态方法。

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

要了解本地人的处理方式，请运行

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（帖子底部的代码）。

正如您在输出中看到的那样（也在帖子的底部），局部变量

    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

在方法的最后访问。

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

所以我看到它的方式，添加更多局部变量的唯一安全方法是在每个方法中运行两次：

除了计算本地变量访问次数外，什么都不做。
一旦实际修改代码，跟踪本地“生成”，但延迟实际生成（即访问本地）直到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和LocalVariableTypeTable attribute中。如果不存在这些属性，则不会报告此类声明。

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

在字节码级别，通过实际将值存储到它们中来建立局部变量（仅指索引）。在源代码级别上具有析取范围的变量可以在堆栈帧中使用相同的索引。对于字节码，对同一索引的两次写入实际上是对同一变量的更改还是两个具有不同范围的变量无关紧要。但是visitMaxs报告的大小必须足够大，以保存操作数堆栈元素和方法堆栈帧中使用的所有变量索引。对于指定分支目标的预期类型的新类文件，也必须使用堆栈映射表框架。

由于ASM在访问结束时报告旧的最大本地，因此您不能使用它来预先使用大于此值的索引，但这不是必需的。如上所述，变量索引不需要是唯一的。您的用例就像引入一个新的变量作用域，因此您可以使用在该点之前尚未使用的索引，如果在注入的代码结束后后续代码再次使用这些索引，则没有问题。

获取在某一点之前使用的索引并不是那么难，如果你只能支持具有StackMapTable attributes的新类文件。对于这些课程，您只需要关注两个活动。在分支目标处，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处的变量也必须被视为正在使用中。相反，在堆栈映射表属性的框架中，这些long和double被报告为单个条目，因此我们必须查找它们并适当地增加已使用变量的数量。

通过跟踪used变量，我们可以简单地在visitMethodInsn内使用超过该数字的变量，只需将值存储到这些索引中，而无需通过visitLocalVariable报告它们。之后也没有动作需要声明它们超出范围，后续代码可能会也可能不会覆盖这些索引。

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

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

1 个答案: