Why does getLineNumber return -1 when using StackTraceElement

The line numbers are given by the LineNumberTable Attribute which maps bytecode locations to source code lines. When you transform code with the ASM library, it will take care to adapt code locations to reflect changes.

This implies that when you inject code before any original code, the location of the first code associated with a line number gets adapted too, so your new code is not covered by the line numbers.

Instead of injecting the code on visitCode, you may inject it after the first line number has been reported through visitLineNumber. In the best case, this still is before any executable code (it may not, if synthetic code has been injected by other means already).

This way, the new code gets associated with the first recorded line number. However, you don’t need to deal with stack traces to reconstitute this information, as it is already known at this point of code injection. Since class and method name are known too, there is not even a need to generate string concatenation code. You can assemble the string beforehand.

package com.example;

import java.lang.invoke.MethodHandles;

import org.objectweb.asm.*;

public class AsmExample {
    static class Test {
        public static int add(int a, int b){
            int sum = a + b;
            return sum;
        }
    }

    public static void main(String[] args) throws Exception {
        ClassReader cr = new ClassReader(AsmExample.class.getName()+"$Test");
        ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS);
        cr.accept(new ClassVisitor(Opcodes.ASM9, cw) {
            String className;
            @Override
            public void visit(int ver,
                int acc, String name, String sig, String superName, String[] ifs) {

                super.visit(ver, acc, name, sig, superName, ifs);
                className = name.replace('/', '.');
            }
            @Override
            public MethodVisitor visitMethod(
                int acc, String name, String desc, String sig, String[] ex) {

                MethodVisitor mv = super.visitMethod(acc, name, desc, sig, ex);
                if(name.equals("add")) mv = new Injector(mv, className + '_' + name);
                return mv;
            }
        }, 0);

        MethodHandles.lookup().defineClass(cw.toByteArray());

        System.out.println("return value: " + Test.add(30, 12));
    }

    static class Injector extends MethodVisitor {
        private final String classAndMethodName;
        private boolean logStatementAdded;

        public Injector(MethodVisitor methodVisitor, String classAndMethod) {
            super(Opcodes.ASM9, methodVisitor);
            classAndMethodName = classAndMethod;
        }

        @Override
        public void visitLineNumber(int line, Label start) {
            super.visitLineNumber(line, start);
            if(!logStatementAdded) {
                logStatementAdded = true;
                visitFieldInsn(Opcodes.GETSTATIC,
                    "java/lang/System", "out", "Ljava/io/PrintStream;");
                visitLdcInsn(classAndMethodName + "_" + line);
                visitMethodInsn(Opcodes.INVOKEVIRTUAL,
                    "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);
            }
        }
    }
}

com.example.AsmExample$Test_add_10
return value: 42

I used a simple print statement instead of your logger, but the example should be easy to adapt.

As an alternative, if you want to stay with your original logic as much as possible, you may just alter the bytecode location of the first reported line number association, to cover your injected code:

static class Injector extends MethodVisitor {
    private final String classAndMethodName;
    Label newStart = new Label();

    public Injector(MethodVisitor methodVisitor, String classAndMethod) {
        super(Opcodes.ASM9, methodVisitor);
        classAndMethodName = classAndMethod;
    }

    @Override
    public void visitCode() {
        super.visitCode();
        visitLabel(newStart);
        instrument();
    }

    @Override
    public void visitLineNumber(int line, Label start) {
        if(newStart != null) {
            start = newStart;
            newStart = null;
        }
        super.visitLineNumber(line, start);
    }

    …

Keep in mind that a line number reported for a code location is associated with all following instructions, until the next line number is reported. While ASM will invoke the visitor methods in the order of the code locations, we don’t need to be as strict when calling into the class writer.

So we can associate a Label with the beginning of the method by calling visitLabel(newStart); before instrument();, without knowing the line number. By the time, visitLineNumber is called for the first time, we replace the label start, which represents the original start of the method, with our new label, representing the new start. ASM doesn’t mind that we didn’t call visitLineNumber before instrument();, as only the code location associated with the Label matters.