Pushing variables to Stack and Variables living in

Question

So I know that there exists 2 memory areas: Stack and Heap.

I also know that if you create a local variable it will live in the Stack, not in the heap. Stack will grow as we push data into it as in:

Now I will try to pass the confusion I am having to you:

For example this simple Java Code:

public class TestClass {
    public static void main(String[] args)  {
        Object foo = null;
        Object bar = null;
    }
}

is translated into this byte code:

public static void main(java.lang.String[]);
  Code:
   Stack=1, Locals=3, Args_size=1
   0:   aconst_null
   1:   astore_1
   2:   aconst_null
   3:   astore_2
   4:   return

LineNumberTable: 
line 5: 0
line 6: 2
line 7: 4

LocalVariableTable: 
Start  Length  Slot  Name   Signature
0      5      0    args       [Ljava/lang/String;
2      3      1    foo       Ljava/lang/Object;
4      1      2    bar       Ljava/lang/Object;

where by definition acons_null is:

push a null reference onto the stack

and astore_1 is:

store a reference into local variable 1

The confusion I am having is, we pushed the foo into stack, then we stored it in the stack again? What is meant by storing a reference in a local variable? Where does that local variable live? The same stack we pushed the foo into or are these seperate Stacks?

Now at that point, if I call a method on the first object I pushed into the stack, since the stack pointer is pointing to the last element I pushed, how will it be processed?

Answer 1

You should look at structure of Java stack frame.

A java stack frame contains 3 things :

1. A local variable table
2. An operand stack
3. A reference to class's constant pool AKA Frame Data

So, push a null reference onto the stack --> pushes the reference onto the operand stack.

store a reference into local variable 1 --> stores the reference into slot 1 of local variable table

Answer 2

There exists one stack per thread in the JVM. Each stack is composed of several frames: each method invocation creates a new frame, and when the method invocation is done, the frame is destroyed.

Within a stack frame there are two areas :

1. The operand stack (don't confuse the word "stack" here with the JVM stack itself -- stack here denotes the area as a last-in-first-out structure).
2. An array of local variables where each variable has an index (starting at zero).

Depending on the JVM implementation, they may or may not be contiguous in memory. Logically they are two separate sections of the stack frame.

As explained in the description of aconst_null, the aconst_null instruction pushes the null object reference onto the operand stack.

And as explained in the description of astore_<n> (where n could be 0, 1, 2 or 3):

The <n> must be an index into the local variable array of the current frame (§2.6). The objectref on the top of the operand stack must be of type returnAddress or of type reference. It is popped from the operand stack, and the value of the local variable at <n> is set to objectref.

So in your example, the statement Object foo = null translates to the following:

1. Push the null (a special reference that points to "nothing") onto the top of the operand stack.

  operand stack
   __________
  |   null   | <-- null is pushed on the operand stack
  |__________|
  |          |
  |__________|
  |          |
  |__________|

2. Pop the reference from the operand stack and store it in the local variable at index 1. This local variable corresponds to foo.

  operand stack                           local variables
   __________      _______________ _______________ _______________ _______________
  |          |    |      args     |   foo (null)  |               |               |
  |__________|    |_______0_______|_______1_______|_______2_______|_______3_______|
  |          |                    store null in LV#1 
  |__________|
  |          |
  |__________|

Same steps are done for Object bar = null except that null is stored in the local variable at index 2.

Source: Java Virtual Machine Specification (See this section).

Answer 3

You can think of the operand stack as temporary variables. It's local to each method call, and its size can be determined at compile time.

If you want to do anything with any kind of variables (local variables, static variables, or non-static variables), you do it via the operand stack. Java Bytecode instructions work mainly only with the operand stack.

For example,

• foo = bar would correspond to aload_2 and astore_1, which simply mean push the value of local variable 2 onto the operand stack and pop whatever on top of the operand stack to local variable 1
• if (foo == null) ... would correspond to aload_1 and ifnonnull 5, where the latter tells the JVM: if whatever on top of the operand stack is not null, jump to the next 5 instruction offsets; otherwise, continue to the next instruction.
• int x = args.length would correspond to aload_0, arraylength, istore_3, which mean push local variable 0, pop the array on top the operand stack and push its length back, pop the integer and store it in local variable 3
• Numerical operations such as iadd, isub, imul, idiv pop two integer values from the operand stack and push the result back
• When calling a method, the operand stack is popped and passed as arguments to the local variables of the new method.
• putstatic/getstatic pops/pushes to/from static variables
• putfield/getfield pops/pushes to/from non-static variables

Answer 4

It's the same stack.

Or at least you can think of it as the being the same stack, it actually depends on the jvm implementation.

In a simple jvm

When a method is called it reserves space for the local variables on the stack. It basically increments the stack pointer to open space for it's local variables. The method's parent object (if instance method) and the method's arguments are the first locals.

To assign something from the stack to a local var is to copy from the top of the stack to some a nearby address, a few positions before, in the same memory region.

During astore 1 in your example:

locals/stack
[local 0] // args
[local 1] // foo   <--+
[local 2] // bar      |
..return address..    |
[stack 0] // null  ---+