Bytecode Basics in Java

Bytecode is the instruction set of the Java Virtual Machine: the compact, platform-independent code that javac writes into .class files and the JVM executes. Each instruction is one byte (the opcode, which gives bytecode its name), sometimes followed by a few bytes of operands. The JVM is a stack machine: instead of working with CPU registers, instructions push values onto an operand stack and pop them off. In this lesson, you will learn how a method's frame is organized, the main families of instructions, how a loop looks in bytecode, and the five instructions that call methods: invokestatic, invokevirtual, invokeinterface, invokespecial and invokedynamic.

You don't write bytecode by hand, but reading it explains how Java features really work and what the JIT compiler starts from. "Javap Tool in Java" showed how to print it.

The Frame: Local Variables and the Operand Stack

Every method call gets a frame on the thread's stack (see "Stack vs Heap Memory in Java"). A frame has two working areas:

The compiler records the sizes both need (stack=2, locals=3 in javap -v), so the JVM can allocate the frame in one step.

Instruction Families

Most instruction names begin with a letter for the type they work on:

Short forms such as iload_1 and iconst_3 exist for the most common cases, so they take a single byte.

Example: A Loop in Bytecode

public class Sum {
    static int sumTo(int n) {
        int total = 0;
        for (int i = 1; i <= n; i++) {
            total += i;
        }
        return total;
    }
 
    public static void main(String[] args) {
        System.out.println(sumTo(4));
    }
}

10

  static int sumTo(int);
    Code:
         0: iconst_0
         1: istore_1
         2: iconst_1
         3: istore_2
         4: iload_2
         5: iload_0
         6: if_icmpgt     19
         9: iload_1
        10: iload_2
        11: iadd
        12: istore_1
        13: iinc          2, 1
        16: goto          4
        19: iload_1
        20: ireturn

Explanation: The method is static, so slot 0 is n, slot 1 is total and slot 2 is i.

There is no "for" instruction. Every loop and if becomes conditional jumps and goto. The compiler tests the opposite condition (if_icmpgt for <=) so that it jumps out of the loop when the condition fails.

The Five Invoke Instructions

Let's see an example that uses all five:

import java.util.ArrayList;
import java.util.List;
 
public class Calls {
    private int count;
 
    static int square(int n) {
        return n * n;
    }
 
    private void bump() {
        count++;
    }
 
    public static void main(String[] args) {
        int nine = square(3);
        Calls c = new Calls();
        c.bump();
        List<String> names = new ArrayList<>();
        names.add("Navika");
        String text = names.toString();
        Runnable r = () -> System.out.println(text + " " + nine);
        r.run();
    }
}

[Navika] 9

     0: iconst_3
     1: invokestatic  #13                 // Method square:(I)I
     4: istore_1
     5: new           #8                  // class Calls
     8: dup
     9: invokespecial #17                 // Method "<init>":()V
    12: astore_2
    13: aload_2
    14: invokevirtual #18                 // Method bump:()V
    17: new           #21                 // class java/util/ArrayList
    20: dup
    21: invokespecial #23                 // Method java/util/ArrayList."<init>":()V
    24: astore_3
    25: aload_3
    26: ldc           #24                 // String Navika
    28: invokeinterface #26,  2           // InterfaceMethod java/util/List.add:(Ljava/lang/Object;)Z
    33: pop
    34: aload_3
    35: invokeinterface #32,  1           // InterfaceMethod java/util/List.toString:()Ljava/lang/String;
    40: astore        4
    42: aload         4
    44: iload_1
    45: invokedynamic #36,  0             // InvokeDynamic #0:run:(Ljava/lang/String;I)Ljava/lang/Runnable;
    50: astore        5
    52: aload         5
    54: invokeinterface #40,  1           // InterfaceMethod java/lang/Runnable.run:()V
    59: return

Explanation:

• invokestatic (1): square(3). The argument 3 is pushed, the call pops it and pushes the result, which istore_1 saves in nine.
• new, dup, invokespecial (5 to 9): creating an object takes three steps. new allocates memory and pushes a reference, dup copies it, and invokespecial runs the constructor <init> on one copy, leaving the other to be stored.
• invokevirtual (14): c.bump(). The object reference is pushed first, like a hidden first argument. (Before Java 11, private methods were called with invokespecial.)
• invokeinterface (28, 35, 54): names has the type List, an interface, so calls through it use invokeinterface, even for toString(). The pop at 33 throws away add's unused boolean result.
• invokedynamic (45): the lambda. The two captured variables, text and nine, are pushed, and the call returns a Runnable. The first time it runs, the bootstrap method LambdaMetafactory.metafactory creates the object's class; later runs reuse that link.

Why Invokedynamic Matters

The first four instructions have their behavior fixed by the JVM. invokedynamic lets Java code decide how a call site is linked, through a bootstrap method that returns a method handle (see "Method Handles in Java"). That gives the language room to improve without new bytecode: string concatenation moved to invokedynamic in Java 9 and got faster, and records, pattern-matching switches and lambdas all rely on it.

Common Mistakes

Assuming bytecode is what the CPU runs. It is the input to the interpreter and the JIT, which then optimize it (see "JIT Optimizations in Java").

Judging performance by counting instructions. After inlining and escape analysis, the machine code can look very different.

Forgetting slot 0 is this. In instance methods, the first parameter is in slot 1.

Expecting boolean instructions. boolean, byte, char and short are handled as int on the stack.

Interview Corner

Practice

1. Easy: Compile a method static long twice(long x) { return x * 2; } and find the l-prefixed instructions with javap -c.
2. Harder: Write a method that calls Object.toString() on a variable declared as Object, one declared as List, and one via super.toString() inside a class. Predict the invoke instruction for each, then check.

Key Takeaways