Skip to main content
Back to path

Welcome to a Grasp lesson

Create a free account to keep studying and create your own study path.

Lesson 12

Anatomy of a Stack Frame

Recommended resources

Welcome back! In our last lesson, we surveyed the five major runtime data areas that form the JVM's memory landscape. We established that for each thread, a private JVM Stack is created to track method calls. You learned that every time a method is invoked, a new "frame" is pushed onto this stack.

Today, we will zoom in from the stack itself to the structure of a single stack frame. Our goal is to explain its three internal components: the local variable array, the operand stack, and the frame data. Understanding the stack frame is crucial because it is the fundamental workspace where the JVM executes bytecode. By dissecting it, you'll see precisely how Java code translates into low-level operations, connecting high-level programming constructs to the machine's execution model.

Let's begin by formally defining the stack frame and its constituent parts.

The Anatomy of a Stack Frame

As we discussed, when a thread invokes a method, the JVM pushes a new stack frame onto that thread's JVM Stack. This frame contains all the state necessary for the execution of that specific method call. When the method completes, either by returning a value or throwing an exception, its frame is popped from the stack, and control returns to the calling method (whose frame is now at the top of the stack).

A stack frame is composed of three main parts.

The Java Virtual Machine - The Java Stack - Artima

This article by Bill Venners, from his book Inside the Java Virtual Machine, provides a canonical description of the JVM stack and the structure of a frame. It's a foundational text for understanding JVM internals.

Please read the introduction, "The Java Stack", to reinforce the concept of the call stack. Then, read the section "The Stack Frame", which explicitly introduces its three components. Note the important detail that the sizes of the local variables and operand stack are determined at compile time.

As the reading highlights, every stack frame contains:

  1. A Local Variable Array
  2. An Operand Stack
  3. Frame Data

Let's examine each of these in detail.

1. The Local Variable Array (LVA)

The Local Variable Array, as its name suggests, is an array that stores all local variables for a method, including the parameters passed to it. It is zero-indexed, and individual entries can be accessed directly using an index.

The JVM specification dictates how different data types are stored:

  • int, float, reference (for objects), and returnAddress each occupy a single slot.
  • long and double, being 64-bit values, occupy two consecutive slots. The instruction will refer to the first of the two slots.
  • Smaller integral types like byte, short, char, and boolean are converted to int before being stored in the LVA.

A crucial distinction exists between class (static) methods and instance methods. For an instance method, the LVA's first slot (at index 0) is always reserved for the this reference, which points to the object on which the method was invoked. This is how instance methods access the object's fields. Class methods don't have a this reference, so their parameters start at index 0.

The Java Virtual Machine - The Java Stack - Artima

This section of the Artima article provides a detailed breakdown of the Local Variable Array.

Read the entire section on Local Variables. Pay close attention to: The ordering of parameters in the array. The explanation of the hidden this reference for instance methods. The type conversion rules for byte, short, char, and boolean.

The following image, taken from the article, provides a perfect illustration of how the LVA is structured for both a class method and an instance method.

This diagram contrasts the Local Variable Array for a static method (`runClassMethod`) and an instance method (`runInstanceMethod`). Note how the instance method's LVA begins at index 0 with the implicit `this` reference, while the static method's LVA begins immediately with its declared parameters.

2. The Operand Stack

While the LVA is for storage, the Operand Stack is the primary workspace for computation. It is a Last-In-First-Out (LIFO) stack where the JVM pushes and pops values to execute bytecode instructions. The JVM is a stack-based machine, meaning that instructions take their operands from the operand stack rather than from a set of general-purpose CPU registers.

The process is straightforward:

  1. Instructions load values from the Local Variable Array (or constants) and push them onto the Operand Stack.
  2. An operation instruction (e.g., for addition or subtraction) pops the required number of operands from the stack.
  3. The instruction performs the computation.
  4. The result is pushed back onto the Operand Stack.
  5. Finally, a store instruction can pop the result from the Operand Stack and save it back into the Local Variable Array.

The following video provides a concise and clear animation of this process.

JVM Anatomy 101

This segment from a talk at a Java conference, presented by JetBrains, gives a dynamic visual of how bytecode instructions move data between the Local Variable Array and the Operand Stack.

Watch the short segment from bytecode interpretation. The speaker walks through four simple bytecode instructions (iload, bipush, iadd, istore) and shows the state of the LVA and Operand Stack at each step.

To reinforce this, the image below shows a static, step-by-step breakdown of a subtraction operation. Imagine iload_0 pushes the value 50, iload_1 pushes 20, isub pops both and pushes the result 30, and finally istore_2 moves that result from the operand stack into the LVA at index 2.

This diagram visualizes the states of the Local Variable Array and Operand Stack during the execution of a sequence of bytecode instructions (`iload_0`, `iload_1`, `isub`, `istore_2`). It clearly shows values moving from the LVA to the Operand Stack for computation, and the result moving back.

3. Frame Data

The final component, Frame Data, holds all other information the JVM needs to execute the method. It's a bit of a catch-all but serves three critical functions.

The Java Virtual Machine - The Java Stack - Artima

Now, let's read the formal definitions of the Operand Stack and Frame Data from the Artima article.

First, read the section on the Operand Stack to solidify your understanding of its role as a workspace. Then, read the section on Frame Data to learn about its three main responsibilities.

As detailed in the reading, the Frame Data contains:

  1. A Reference to the Runtime Constant Pool: Many bytecode instructions, like invokevirtual (for calling a method) or new (for creating an object), refer to entries in the class's constant pool. The Frame Data holds a pointer to the constant pool of the current method's class, allowing the JVM to resolve these symbolic references into actual memory addresses for methods and fields.

  2. Information for Method Return: When a method finishes, the JVM must restore the stack frame of the method that called it. The Frame Data contains the necessary information to do this, including setting the program counter (PC) of the calling thread to the correct instruction so it can resume execution. If the completed method returns a value, this data also helps the JVM push that value onto the operand stack of the restored frame.

  3. A Reference to the Method's Exception Table: If an exception is thrown, the JVM consults the method's exception table to see if there is a matching catch block that can handle it. The Frame Data contains a reference to this table. If a handler is found, control is transferred to it. If not, the method completes abruptly, its frame is popped, and the same exception is re-thrown in the context of the calling method.

Conclusion

In this lesson, we have dissected the anatomy of a JVM stack frame. You can now see that this structure is far more than just a simple entry on the call stack; it's a sophisticated and self-contained environment for method execution.

Key Takeaways:

  • A stack frame is created for each method call and consists of three parts: the Local Variable Array, the Operand Stack, and Frame Data.
  • The Local Variable Array (LVA) stores parameters and local variables, accessed by index. Instance methods have an implicit this reference at index 0.
  • The Operand Stack is a LIFO structure that serves as the computational workspace for bytecode instructions.
  • Frame Data provides crucial metadata, including a link to the runtime constant pool, information for handling method returns, and a reference to the exception table for error handling.

We have now explored how the JVM manages the flow of execution on the stack. In our next lesson, we will shift our focus back to the Heap, the shared memory area where all objects live. We'll explore its internal organization, including the Young and Old Generations, to understand how the JVM manages object lifecycles.