CS251 - Computer Organization
Computer Science 251
Computer Organization
Dickinson College
Fall Semester 2000
Grant Braught
Class #4 - Procedure Calls and Local Variables
Consider the following Java Program:
<![CDATA[
public static void main(String[] args) {
int A = 7;
int B = 13;
int D;
...
D = min(A,B);
}
public int min(int x, int y) {
int m;
if (x < y) {
m = x;
}
else {
m = y;
}
return m;
}
]]>
Think about the following questions:
What assembly language might a compiler generate for this?
Do x, y and m hang around during the whole program execution?
Should x, y and m be declared as variables at the start of the program?
Do we want to repeat the assembly language for min every time it is called?
Main Memory Contents When a Program is Running:
The contents of main memory when a program is executing:
Program Instructions - the instructions of the program.
Global Data - Space for .word, .space, .half, .byte assembler directives.
Heap - Used to hold objects created with the new keyword in Java.
For Example: String k = new String("testing");
Stack - Used to hold method parameters, local variables, return values and return addresses.
The size of the stack and heap change dynamically as the program runs.
Each new operation increases the size of the heap.
Garbage collection of objects with no references to them decreases the size of the heap.
Each method call increases the size of the stack.
Each return from a method decreases the size of the stack.
A Stack:
LIFO - Last In First Out
Two Operations:
PUSH - Put an item onto the top of the stack.
POP - Remove an item from the top of the stack.
<![CDATA[
Empty
Stack
| | PUSH 5 => | | PUSH 1 => | | PUSH 3 => | |
| | | | | | | |
| | | | | | | |
| | | | | | | 3 |
| | | | | 1 | | 1 |
| | | 5 | | 5 | | 5 |
+---+ +---+ +---+ +---+
| | POP => | | POP => | | POP => | |
| | | | | | | |
| | | | | | | |
| 3 | | | | | | |
| 1 | | 1 | | | | |
| 5 | | 5 | | 5 | | |
+---+ +---+ +---+ +---+
]]>
High Level View of a Method Call
In general a method call consists of 10 steps:
- Push arguments of the call onto the stack.
- Call the method
- Method pushes locals onto the stack.
- Method pushes the return address onto the stack.
The return address is the address of the instruction that will be returned to when the method is finished executing.
- The method executes using the parameters and locals within the stack.
- The method pops the return address from the stack and saves it.
- The method pops all locals and parametrs off of the stack.
- The method pushes its return value (if any) onto the stack.
- Return to the return address
- Pop the result of the method from the stack.
Applying this to the program from the top of the page:
The stack for each step of the method call to the min method is shown below:
<![CDATA[
Empty
Stack
| | PUSH A => | | PUSH B => | | PUSH m => | |
| | | | | | | |
| | | | | | | |
| | | | | | | 0 |
| | | | |13 | |13 |
| | | 7 | | 7 | | 7 |
+---+ +---+ +---+ +---+
(1) (1) (3)
PUSH => | | | | POP => | |
return | | | | | |
address |RA | |RA | | |
| 0 | m | 7 | m | 0 | m
|13 | y |13 | y | 1 | x
| 7 | x | 7 | x | 5 | y
+---+ +---+ +---+
(4) (5) (6)
POP(s) => | | PUSH => | | POP => | |
| | | | | |
| | | | | |
| | | | | |
| | | | | |
| | | 7 | | |
+---+ +---+ +---+
(7) (8) (10)
]]>
- The value of the arguments A & B are PUSHed onto the stack.
- (min is called)
- The local variable m is PUSHed onto the stack. (m has no value so a 0 is pushed.)
- The return address is PUSHed onto the stack.
- m is set to x during the execution of min
- The return address is POPed off of the stack.
- The local variable (m) and parameters (x,y) are POPed off of the stack.
- The return value (m) is PUSHed back onto the stack.
- (Control returns from min)
- The return value is POPed off of the stack.
Related questions and issues:
Changing parameters does not change arguments because parameters are on the stack.
Consistent with what happens in Java.
What happens when a method calls another method?
What happens if that method calls yet another method?
What happens when these nested method calls start to return?
What would happen to the stack when a recursive method runs?
What about an argument that is a reference to an array or an object?
Recall, that in Java if the parameter is changed to refer to a new array there is no change to the argument.
However, if the array refered to by the parameter is changed then the array referred to by the argument is also changed.
You'll explore this some more through the homework!
Some New Assembly Language Instructions:
Stacks in Our Assembly Language:
PUSH and POP Assembly Language Instructions:
<![CDATA[
Format: Example: Meaning:
----------------------------------------------------------
PUSH R PUSH R1 MM[R13] = R1
R13 = R13 - 4
POP R POP R5 R13 = R13 + 4
R5 = MM[R13]
]]>
R13 is reserved by the assembler to point to the first empty space on the stack.
Do not use R13 for any of your own calculations.
PUSH puts the value of a register onto the stack and updates the stack pointer.
POP updates the stack pointer and copies the value from the top of the stack into a register.
NOTE: The stack in our machine will grow from the top down!
Calling and Returning from a Method in Assembly Language:
CALL and RET Assembly Langauge instructions.
<![CDATA[
Format: Example: Meaning:
----------------------------------------------------------
CALL L CALL PROC R12 = PC + 4 (next instruction)
PC = PROC
RET RET PC = R12
]]>
R12 is reserved by the assembler to hold return addresses.
Do not use R12 for any of your own calculations.
CALL places the address of the next instruction into R12.
This is used to return to the calling location at the end of the method.
RET uses the address in R12 to return from the method.
Making Space for the Stack:
In our machine we will explicitly allocate space to hold the stack.
We will also need to manually setup the stack pointer.
The following code snippet:
Reserves space for the stack
Sets up the stack pointer.
This is something that will happen at the start of every significant program you write.
<![CDATA[
STK: .space 128 * Reserve space to hold the stack.
LOAD R13 #STK * Point R13 to bottom of stack.
ADD R13 R13 #124 * Point R13 to top of stack.
]]>
The size of 128 will allow for 32 values to be on the stack at the same time.
This size must be customized to your application.
What are the issues involved in selecting a stack size?
Implementing the min example:
The following assembly langauge implements the program from the top of the page.
The Main program is as follows:
<![CDATA[
A: .word 7
B: .word 13
D: .word
STK: .space 128 * Reserve space for the stack
LOAD R13 #STK
ADD R13 R13 124 * Setup the stack pointer.
...
LOAD R0 A
PUSH R0 * 1) PUSH A onto stack
LOAD R0 B
PUSH R0 * 1) PUSH B onto stack
CALL MIN * 2) Transfer control to the MIN routine.
POP R0 * 10) POP result from stack
STORE R0 D * Store result in D
HALT
]]>
Now the minroutine:
<![CDATA[
MIN: LOAD R0 #0
PUSH R0 * 3) PUSH m onto stack
* Use 0 for m since it doesn't have
* a value.
* Could also just: SUB R13 R13 #4
PUSH R12 * 4) Push the return address onto the stack.
LOAD R0 R13 +16 * R0 = x
LOAD R1 R13 +12 * R1 = y
BGEQ R0 R1 IFPART * if x >= y skip to IFPART
STORE R1 R13 +8 * m = y
JUMP ENDIF
IFPART: STORE R0 R13 +8 * m = x
ENDIF: POP R12 * 6) Reset R12 to the return address.
POP R0 * 7) R0 = m - hold this for a moment.
POP R1 * 7) Throw local y away
POP R1 * 7) Throw local x away
PUSH R0 * 8) PUSH m onto stack as the return value.
RET * 9) Return to the calling location.
]]>
Summary of the new LOAD and STORE formats:
<![CDATA[
Format: Example: Meaning: Addressing Mode:
---------------------------------------------------------------------------
LOAD R R + LOAD R1 R13 +12 R1 = MM[R13 + 12] Stack
STORE R R + STORE R1 R13 +12 MM[R13 + 12] = R1 Stack
]]>
