Compiling/disassembling Java without creating a constant pool?

Question

I'm having trouble understanding the usage of some Java Bytecode Instructions, partially due to lack of examples. Instead, I use javac or Jasmin to compile some regular Java code, and then I use javap -c to inspect the generated bytecode.

My project is built on a framework that optimizes my bytecode for me, so my own code generator doesn't have to manage the constant pool for me. Since the javap output contains a lot of reference to the constant pool, that doesn't really clear up the usage if I don't have to make use of those references myself.

Is there a way of getting disassembled bytecode without the symbol table (or any references to it)?

To elaborate, suppose we have the following code:

public class MyConcatCode {
    public static void main(String[] args){
        String a ="Hello ";
        String b ="World!";
        String c = new StringBuilder().append(a).append(b).toString();
    }
}

This resolves to:

...
       0: ldc           #7                  // String Hello
       2: astore_1
       3: ldc           #9                  // String World!
       5: astore_2
       6: new           #11                 // class java/lang/StringBuilder
       9: dup
      10: invokespecial #13                 // Method java/lang/StringBuilder."<init>":()V
      13: aload_1
      14: invokevirtual #14                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      17: aload_2
      18: invokevirtual #14                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      21: invokevirtual #18                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
      24: astore_3
      25: return
...

But I'd much rather have the following:

...
       0: ldc Hello
       2: astore_1
       3: ldc World!
       5: astore_2
       6: new java/lang/StringBuilder
       9: dup
      10: invokespecial java/lang/StringBuilder."<init>":()V
      13: aload_1
      14: invokevirtual java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      17: aload_2
      18: invokevirtual java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      21: invokevirtual java/lang/StringBuilder.toString:()Ljava/lang/String;
      24: astore_3
      25: return
...

If, like the framework supplied to me, the compiler creates the constant pool after producing bytecode described in my second example, then it should be possible to get bytecode that doesn't contain a symbol table at all, right?

I don't quite understand what your question is. Asking for Java code that doesn't use the constant pool (that won't exist in real life, as many of the Java bytecode instructions inherently reference the constant pool) or asking for a disassembler that leaves the constant pool references as the numeric constant pool index instead of giving the symbolic name? — Ralf Kleberhoff, Apr 10 '20 at 13:43
If I understand you correctly you are looking for a Java ByteCode viewer that automatically resolves constants form the constant pool. — Robert, Apr 10 '20 at 15:11
Run a regex filter over the output which removes occurrences of `#\d+\s*// \w+`? — Holger, Apr 14 '20 at 13:12

score 0 · Answer 1 · answered Apr 16 '20 at 17:04

As far as I understood your question, you're just looking for a bytecode viewer that does not print the constantpool. E.g. instead of printing a reference to a String in the constant pool, it will inlines the string.

Object web asm contains a utility class that disassambles the provided input class. Just download the asm jar (hotlink) and the asm-util jar containing the utility (hotlink). With both those jars on the classpath, run the org.objectweb.asm.util.Textifier class and provide the path to the classfile that you want to disassamble.
java -jar -cp asm-8.0.1.jar:asm-util-8.0.1.jar org.objectweb.asm.util.Textifier /path/to/your/file.class
Bytecode viewer is a powerful tool for working with bytecode in the view menu, you can select the option "Bytecode". Their representation resolves references for you.
I think Krakatau should work the same way, but since I didn't like their syntax and python, I've never had a deeper look into it.

Compiling/disassembling Java without creating a constant pool?

1 Answers1