如何将无法独立运行的Java类文件静态转换为汇编代码？

Awesome question—this is a common pain point when trying to analyze specific classes without sifting through tons of unrelated assembly output. Let’s break down your options, including ways to get clean, isolated assembly even if your target class can’t run standalone:

1. Write a Minimal Wrapper Class #

Create a tiny, purpose-built class that only instantiates your target class and calls the methods you want to analyze. This keeps the runtime context minimal, so the PrintAssembly output will focus almost entirely on your target code.

Add a loop to trigger JIT compilation (since PrintAssembly shows JIT-generated assembly, not interpreted code):

public class TargetClassWrapper {
    public static void main(String[] args) {
        // Replace with your target class and method calls
        TargetClass targetInstance = new TargetClass();
        // Warm up the JIT compiler with repeated calls
        for (int i = 0; i < 10000; i++) {
            targetInstance.methodToAnalyze();
        }
    }
}

Run it with the PrintAssembly flags, plus syntax options for readability:

java -XX:+UnlockDiagnosticVMOptions -XX:+PrintAssembly -XX:PrintAssemblyOptions=intel -XX:+PrintCompilation TargetClassWrapper

• -XX:PrintAssemblyOptions=intel (use att for AT&T syntax) makes the assembly easier to parse.
• -XX:+PrintCompilation lets you confirm exactly when your target method gets JITted.

2. Use CompileCommand to Filter Exact Methods #

The JVM’s -XX:CompileCommand flag lets you specify only the methods you want to compile and print assembly for. This is perfect for cutting out all noise from standard library code or other parts of an application.

For example, to print assembly exclusively for TargetClass.methodToAnalyze:

java -XX:+UnlockDiagnosticVMOptions -XX:+PrintAssembly -XX:CompileCommand=print,com/yourpackage/TargetClass.methodToAnalyze TargetClassWrapper

Add multiple -XX:CompileCommand flags if you need to analyze several methods from the target class.

3. GraalVM AOT Compilation (Fully Static Approach) #

If you want a truly static method (no runtime JIT), use GraalVM’s Ahead-of-Time (AOT) compilation to turn your target class into a native binary, then disassemble that binary. This generates assembly ahead of time, with no runtime execution required beyond the disassembly step.

Steps:

1. Compile your wrapper + target class into a native executable:

   native-image -cp . TargetClassWrapper
   

2. Disassemble the binary using tools like objdump (Linux/macOS) or dumpbin (Windows):

   objdump -d targetclasswrapper > target_assembly.txt
   

Note: GraalVM’s AOT assembly may differ slightly from HotSpot’s JIT output, but it’s a valid static view of your class’s compiled machine code.

Key Note #

There’s no fully static way to get HotSpot’s JIT assembly without running the code (since JIT assembly is generated at runtime based on execution context), but the methods above let you isolate your target class’s assembly effectively with minimal noise.

内容的提问来源于stack exchange，提问作者xiao su