CS251 - Computer Organization

Computer Science 251
Computer Organization

Dickinson College
Fall Semester 2001
Grant Braught

Class #4 - Procedure Calls and Local Variables

Our Assembler and Machine Emulator:

The Assembler program.

The Machine emulator.

Assembling a Program:

Enter the assembly language in a text editor.

java -jar Assembler.jar <assembly code file> <machine code file>

Running a Program:

java -jar Machine.jar <machine code file>

Input/Output in Our Assembly Language:

Our machine supports a simple form of input and output.

This input/output model is called memory mapped I/O.

Input is done by reading from a special memory address.

Output is done by writing to a special memory address.

LOAD

STORE

special memory addresses

Input:

Values entered in the Input: box can be read one-by-one.

Each LOAD from the memory address STDIN reads one value.

LOAD R0 STDIN reads one value from the Input: box into R0.

STDIN is short for Standard Input and is defined as a label by our Assembler.

All values must be entered into the Input: box before the program is run.

Output:

Values stored into the special memory address STDOUT appear in the Output: box.

STORE R0 STDOUT writes the value in R0 to the Output: box.

STDOUT is short for Standard Output and is defined by a label by our assembler.

Example:

This program reads 2 values from standard input...

The larger value is then stored in MAX & written to standard output.

MAX: .word LOAD R1 STDIN * Read the first value from STDIN. LOAD R2 STDIN * Read the second value from STDIN. BLT R1 R2 R2MAX * R1 < R2 so R2 is MAX STORE R1 STDOUT * R1 >= R2 so R1 is MAX STORE R1 MAX JUMP END R2MAX: STORE R2 STDOUT STORE R2 MAX END: HALT

Consider the following Java Program:

public static void main(String[] args) { int A = Console.in.readInt(); int B = Console.in.readInt(); int D; ... D = min(A,B); System.out.println(D); ... } public int min(int x, int y) { int m; if (x < y) { m = x; } else { m = y; } return m; }

Think about the following questions:

Calling and Returning from Methods

The CALL and RET instructions:

Format: Example: Meaning: ---------------------------------------------------------- CALL L CALL PROC R12 = PC + 4 (next instruction) PC = PROC RET RET PC = R12

R12 is reserved for the return address.

Do not use R12 for any other calculations.

Example:

A: .word B: .word D: .word ... CALL MIN * First Call ... CALL MIN * Second Call ... HALT MIN: LOAD R0 A LOAD R1 B BLT R0 R1 R0LTR1 * A < B STORE R1 D * B < A JUMP ENDMIN R0LTR1: STORE R0 D * A < B ENDMIN: RET

What are some of the problems with this approach?

Several of them are:

There are no arguments or parameters:

The method MIN always operates on A, B and D.

The state of the registers is not preserved:

The MIN method modifies R0 and R1

The program may have been using R0 and R1 and be counting on their values.

For example:

LOAD R0 #9 CALL MIN LOAD R1 D ADD R2 R1 R0

This does not produce the intended effect because MIN changed R0.

Passing Parameters:

To understand how this works we first need to look at a 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.

Empty Stack | | PUSH 5 => | | PUSH 1 => | | PUSH 3 => | | | | | | | | | | | | | | | | | | | | | | | | | 3 | | | | | | 1 | | 1 | | | | 5 | | 5 | | 5 | +---+ +---+ +---+ +---+ | | POP => | | POP => | | POP => | | | | | | | | | | | | | | | | | | | 3 | | | | | | | | 1 | | 1 | | | | | | 5 | | 5 | | 5 | | | +---+ +---+ +---+ +---+

Parameter Passing & Return Values

The calling code will PUSH parameters onto the stack.

The method uses the values on the stack to perform its function.

The method code will use a special register (R14) for the return value.

The calling code will retrieve the return value from R14.

PUSH and POP Assembly Language Instructions

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 for the Stack Pointer.

Do not use R13 for any other calculations.

NOTICE: PUSH decreases the SP. So the stack fills from the top down.

I.E. In memory, the stack is upside down from the pictures above.

Creating and Using a Stack:

Space must be allocated for the stack.

The Stack pointer (R13) must be initialized.

A: .word B: .word D: .word STK: .space 128 * Allocate 128 bytes for the stack. ... LOAD R0 #STK ADD R13 R0 #124 * Set Stack Pointer to top of the stack.

Passing the arguments:

Each argument is pushed onto the stack.

... LOAD R0 A PUSH R0 * Put A on the stack. LOAD R0 B PUSH R0 * Put B on the stack. CALL MIN * Transfer control to MIN. STORE R14 D * Save Result. HALT

Using the parameters:

We could POP the parameters but there is a better way.

Stack Addressing Mode:

The MIN routine with parameters:

MIN: LOAD R0 R13 +8 * x = R0 = A LOAD R14 R13 +4 * y = R14 = B BLT R14 R0 ENDMIN * B < A ADD R14 R0 #0 * A < B, Move A -> R0 ENDMIN: POP R15 * Discard y POP R15 * Discard x RET * Result is in R14.

PUSH R0 to save its value when MIN begins.

POP R0 to restore its value when MIN ends.

The MIN routine with parameters & register preservation:

MIN: PUSH R0 * Save R0 LOAD R0 R13 +12 * x = R0 = A LOAD R14 R13 +8 * y = R14 = B BLT R14 R0 ENDMIN * B < A ADD R14 R0 #0 * A < B, Move R0 -> R14 ENDMIN: POP R0 * Restore R0 POP R15 * Discard y POP R15 * Discard x RET * Result in R14.

Special Purpose Registers:

R12: Return Address - PC value for RET

R13: Stack Pointer - Address of top of stack.

R14: Scratch Register - value is not preserved across CALL

R15: Reserved - value is not preserved between instructions.

Related questions and issues:

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 happens to an argument if the corresponding parameter on the stack is changed?

Changing parameters does not change arguments because parameters are copies of the argument.

Consistent with what happens in Java.

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 referred 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!

Procedure Call Protocol:

The following is a general protocol for implementing procedure calls:

Calling code pushes all arguments onto the stack.
Calling code executes the CALL instruction.
Procedure pushes all registers that it uses onto the stack.
Procedure pushes local variables (if any) onto the stack.
Procedure pushes the Return Address (R12) onto the stack.
Procedure carries out its operation using the parameters stored in the stack.
Procedure places return value into R14.
Procedure pops saved return address from the stack.
Procedure pops and discards all local variables.
Procedure pops saved register values from the stack.
Procedure pops and discards all parameters.
Procedure executes the RET instruction.
Calling code retrieves the return value from R14.

Calling Code Perspective:

From the perspective of the calling code, the procedure has simply computed the result and placed it in R14. The values in the general purpose registers (R0-R11) appear not to have changed and the stack has been returned to its original condition. The calling code may pick up right were it left off.

Procedure Perspective:

It is the responsibility of the procedure code to ensure that it leaves everything just as it found it. It saves the values of the general purpose registers so that they can be restored. It does not manipulate any of the globally allocated memory. It cleans up the stack when it is complete. It returns the result in register R14. The procedure must ensure that the calling code can pick up right where it left off.

The int min(int x, int y) Example:

The following code completely implements the min example from above.

A: .word B: .word D: .word STK: .space 40 * Allocate 40 bytes (10 words) for * the stack. This example only pushes * 6 words to the stack so 10 is safe. LOAD R13 #STK * Setup the Stack Pointer. ADD R13 R13 #36 LOAD R0 STDIN * Read A from Standard Input STORE R0 A * Store value of A in RAM LOAD R0 STDIN * Read B from Standard Input STORE R0 B * Store value of B in RAM * ASSUMING SOME ADDITIONAL CODE HERE THAT * MAY CHANGE THE VALUE STORE IN R0. *** * Step #1: Calling code pushes all arguments onto the stack. *** LOAD R0 A PUSH R0 * Push argument A onto the Stack. LOAD R0 B PUSH R0 * Push argument B onto the Stack. *** * Step #2: Calling code executes the CALL instruction. *** CALL MIN * Call the MIN routine. *** * Step #13 Calling code retrieves the return value from R14. *** STORE R14 D * Store returned value of D in RAM STORE R14 STDOUT * Display the result on Standard output. HALT *-------------------------------------------------------------------- *** * Step #3: Push all registers that will be used onto the stack. *** MIN: PUSH R0 * Save the value of R0. (+16) PUSH R1 * Save the value of R1. (+12) *** * Step #4: Push local variables (if any) onto the stack. *** LOAD R0 #0 PUSH R0 * Push m onto the stack (+8). *** * Step #5: Push the Return Address (R12) onto the stack. *** PUSH R12 * Push return address onto the stack. (+4) *** * Step #6: Carry out operation using parameters stored in the stack. *** LOAD R0 R13 +24 * R0 = x = A (+24) LOAD R1 R13 +20 * R1 = y = B (+20) BLT R0 R1 XLTY * Is x < y? STORE R1 R13 +8 * y <= x, so set m = y JUMP ENDMIN XLTY: STORE R0 R13 +8 * x < y, so set m = x *** * Step #7: Place return value into R14. *** ENDMIN: LOAD R14 R13 +8 * return m; *** * Step #8: Pop saved return address from the stack. *** POP R12 * restore the return address. *** * Step #9: Pop and discard all local variables. *** POP R15 * Remove m from the stack. *** * Step #10: Pop saved register values from the stack. *** POP R1 * Restore the value of R1 POP R0 * Restore the value of R0 *** * Step #11: Pop and and discard all parameters. *** POP R15 * Remove y from the stack. POP R15 * Remove x from the stack. *** * Step #12: Return from the CALL. *** RET

Summary of new Assembly Language Instructions:

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 CALL L CALL PROC R12 = PC + 4 PC = PROC RET RET PC = R12 PUSH R PUSH R1 MM[R13] = R1 R13 = R13 - 4 POP R POP R5 R13 = R13 + 4 R5 = MM[R13]