CDA-4101 Lecture 18 Notes

• Before discussing the specifics of the IJVM ISA, we need to first cover a few concepts.

• Most languages have the concept of functions/procedures/methods that have local variables
• the scope of these local variables is only within the function/procedure/method: not on any inner or outer calls.
• You probably know that these variables live in memory, but exactly where in memory or who decides where in memory they go is something you probably haven't had to worry about.
• When coding in high-level language, the compiler decides where to put things in memory.
• At the ISA level, we no longer have the compiler to do our work for us.

• So where is a good place to put local variables in memory?
• Question: Why not just pick some memory location for each local variable?
  Answer: Because it doesn't work.
• Consider this function, where the function parameters are the same as local variables:

  void recurseCountdown( int count, int limit ) { if ( count > limit ) return; recurseCountdown( count+1, limit ); printf( "Count: %d\n", count ); } int main() { recurseCountdown( 0, 3 ); }

  int count; int limit; void recurseCountdown( ) { if ( count > limit ) return; count += 1; recurseCountdown( ); printf( "Count: %d\n", count ); } int main() { count = 0; limit = 3; recurseCountdown(); }

  Count: 3 Count: 2 Count: 1 Count: 0

  Count: 4 Count: 4 Count: 4 Count: 4

• Just disallowing recursion is not an acceptable solution:
  • You would need to disallow object oriented programming, since each object's method will have their own local variables.
  • You would have to disallow multi-threaded programming, since two threads could potentially access the same function.
  • and many other subtleties that would severely restrict programmers.

A stack turns out to be a useful data structure for storing local variables. When a procedure is called, you push its local variables onto the stack; when it finishes you pop them off the stack. Recursive calls to the same routine just keep popping new sets of local variables on top of the stack. each procedure call creates its own local variable stack frame However, the stack itself is really just some area of memory, so each local variable on the stack will still have a memory address. A much simpler way to reference the local variables is relative to the stack frame. This greatly simplifies figuring out where the variables for a function are, since they will always be in the same relative location, where this is relative to the stack frame.

Important Note

When we are showing a bunch of memory locations as a vertical array of cells, higher address memory locations are on the bottom. However, when showing stacks as an array of cells, the higher memory addresses are toward the top.

We'll reserve some section of main memory to hold the stack We will use a register (SP), will keep track of the top of the stack We will use another register (LV) to hold the address of the current local stack frame (where the local variables begin in memory). Our data is always 4 bytes (remember we have 32 bit registers)

1. method 'a' called, 3 local variables
2. 'a' calls 'b' which has 4 local variables
3. 'b' call 'c' which has 2 local variables
4. 'c' returns
5. 'b' returns
6. 'a' calls 'd' which has 5 local variables

This is the general idea. In the next lecture we will look at the details of how this is really done in IJVM and the Mic-1 architecture

• Stacks are also useful for computing arithmetic expressions
• Using a stack to compute an expression:

      a1 = a2 + a3
    

  1. push a2 onto stack
  2. push a3 onto stack
  3. remove and add top two words on the stack, putting result onto stack
  4. pop stack and store into a1
• we can intermix the local variable stack frames and operand stacks
  

• All machines use a stack for storing local variable frames
• Most machines do not use a stack for computing arithmetic expressions
• But the JVM and IJVM do use them, which is why we need to understand them

• Can view IJVM memory as either an array of 4,294,967,296 bytes or an array of 1,073,741,824 words.
• No memory addresses are used directly at the ISA level
• All variable references are relative to some base address:
  • The Constant Pool
    • An area for constants, strings and pointers to other areas of memory.
    • This area is loaded when program is first brought into memory and cannot be changed afterwards.
    • The CPP register contains the address of the first word of this area.
  • Local Variable Frame:
    • This is the area on the stack we have been referring to and uses the LV register..
    • The beginning of the frame will have the parameters (a.k.a. arguments) of the method/procedure, with the local variables following.
    • The operand stack is not part of this frame, but will be immediately above it on the stack as we have shown.
  • Operand Stack:
    • Stack area is a fixed size determined at startup.
    • Will be right above the local variable stack frame.
  • Method Area (the code):
    • Non-writable area where ISA program stored
    • Treated as a byte array.
    • The PC points into this area

• The LV, SP and CPP registers have word addresses (like the MAR register).
• Adding one to these registers is like adding 4 to the actual memory address.
• Adding one to the PC register is just like adding one.

• Note the difference between the IJVM instructions and the single cycle microinstruction: i.e., it will take a few microinstructions to implement each IJVM instruction
• The offset for the four branch instructions (GOTO, IFEQ, IFLT and IF_ICMPEQ) is a signed 16 bit number.
• The WIDE instruction is used to allow other instructions to have multiple forms: a 1 byte vs. 2 byte index

• Local Variable indices:
  • i = 1
  • j = 2
  • k = 3
• Notice the ways in which the assembly language makes it easier for you.

  i = j + k ;
  if ( i == 3 )
  {
    k = 0 ;
  }
  else
  {
    j = j - 1 ;
  }