Pushing variables to Stack and Variables living in the Stack difference?

Koray Tugay

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:

enter image description here

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?

M Anouti

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
  |__________|
  |          |
  |__________|
  |          |
  |__________|
  1. 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).

Collected from the Internet

Please contact [email protected] to delete if infringement.

edited at
0

Comments

0 comments
Login to comment

Related

From Dev

Declared variables stack

From Dev

Are variables contiguous on the stack?

From Dev

Local variables on stack

From Dev

how variables are stored on stack?

From Dev

The addressing of stack variables

From Dev

Local variables: are they always on the stack?

From Dev

Are variables on the stack "statically allocated"?

From Dev

Declared variables stack

From Dev

how variables are stored on stack?

From Dev

Call stack variables in javascript

From Dev

Examining local variables up the stack

From Dev

Determining variables stack or heap in C?

From Dev

Compiling local variables for a stack machine

From Dev

How is it known that variables are in registers, or on stack?

From Dev

Stack overflow from local variables?

From Dev

Are C stack variables stored in reverse?

From Dev

Determining variables stack or heap in C?

From Dev

Allocation of space for static variables on the stack

From Dev

Compiling local variables for a stack machine

From Dev

Examining local variables up the stack

From Dev

pthread memory leak with stack variables

From Dev

Example of Pointers dealing with Stack variables

From Dev

pushing object to stack

From Dev

Linux process stack overrun by local variables (stack guarding)

From Dev

What is the idea behind using a stack for local variables?

From Dev

Passing variables with include in salt-stack

From Dev

How do local variables get stored in stack?

From Dev

Preservation of out of scope stack variables with deferred execution

From Dev

Where variables of a function is store? on stack or heap?