Best choice? Edit bytecode (asm) or edit java file before compiling

Question

Goal

• Detecting where comparisons between and copies of variables are made
• Inject code near the line where the operation has happened
• The purpose of the code: everytime the class is ran make a counter increase

General purpose: count the amount of comparisons and copies made after execution with certain parameters

2 options

Note: I always have a .java file to begin with

1) Edit java file

---

Find comparisons with regex and inject pieces of code near the line And then compile the class (My application uses JavaCompiler)

2)Use ASM Bytecode engineering

---

Also detecting where the events i want to track and inject pieces into the bytecode And then use the (already compiled but modified) class

My Question

What is the best/cleanest way? Is there a better way to do this?

Answer 1

If you go for the Java route, you don't want to use regexes -- you want a real java parser. So that may influence your decision. Mind, the Oracle JVM includes one, as part of their internal private classes that implement the java compiler, so you don't actually have to write one yourself if you don't want to. But decoding the Oracle AST is not a 5 minute task either. And, of course, using that is not portable if that's important.

If you go the ASM route, the bytecode will initially be easier to analyze, since the semantics are a lot simpler. Whether the simplicity of analyses outweighs the unfamiliarity is unknown in terms of net time to your solution. In the end, in terms of generated code, neither is "better".

There is an apparent simplicity of just looking at generated java source code and "knowing" that What You See Is What You Get vs doing primitive dumps of class files for debugging and etc., but all that apparently simplicity is there because of your already existing comfortability with the Java lanaguage. Once you spend some time dredging through byte code that, too, will become comfortable. Just a question whether it's worth the time to you to get there in the first place.

Answer 2

Generally it all depends how comfortable you are with either option and how critical is performance aspect. The bytecode manipulation will be much faster and somewhat simpler, but you'll have to understand how bytecode works and how to use ASM framework.

Intercepting variable access is probably one of the simplest use cases for ASM. You could find a few more complex scenarios in this AOSD'07 paper.

Here is simplified code for intercepting variable access:

ClassReader cr = ...;
ClassWriter cw = ...;
cr.accept(new MethodVisitor(cw) {
  public void visitVarInsn(int opcode, int var) {
    if(opcode == ALOAD) {  // loading Object var
      ... insert method call
    } 
  }
});

Answer 3

If it was me i'd probably use the ASM option.

If you need a tutorial on ASM I stumbled upon this user-written tutorial click here