1. Computer Science 210 Computer Organization
Managing the Namespace
Parameters and Local Data

2. Example: Subtraction
;; Author: Ken Lambert
;; This program subtracts the number in the variable SECOND from FIRST and
;; and stores the result in DIFF
.ORIG x3000
;; Pseudocode design: diff = first - second
;; Main program register usage:
; R1 = first
; R2 = second
; R3 = diff
; Main program code
LD R1, FIRST ; Set the parameter for the minuend
LD R2, SECOND ; Set the parameter for the subtrahend
JSR SUB
ST R3, DIFF ; Store the returned difference
HALT
; Main program data variables
FIRST .BLKW 1
SECOND .BLKW 1
DIFF .BLKW 1
;; Subroutine SUB
; Subtracts R2 from R1 and stores result in R3
; Input parameters: R1 (minuend) and R2 (subtrahend)
; Output parameter: R3 (difference)
SUB NOT R3, R2
ADD R3, R3, #1
ADD R3, R1, R3
RET
.END
Note that the SUB routine does not modify its input parameters!

3. The Namespace
A subroutine should communicate with its caller only via registers
A subroutine may have its own data variables, but should not access anyone else’s data variables (those of other routines or the main program)
A subroutine should leave its input registers unchanged (may save and restore)

4. Saving and Restoring Registers
Called routine -- “callee-save”
At startup, save any registers that will be altered (unless altered value is desired by calling program!)
Before return, restore those same registers
Calling routine -- “caller-save”
Save registers destroyed by own instructions or by called routines (if known), if values needed later
save R7 before TRAP
save R0 before TRAP x23 (input character)
Or avoid using those registers altogether

5. Saving and Restoring Registers
Generally use “callee-save” strategy, except for return values.
Save anything that the subroutine will alter internally that shouldn’t be visible when the subroutine returns.
It’s good practice to restore incoming arguments to their original values (unless overwritten by return value).
Remember: You MUST save R7 if you call any other subroutine or TRAP.

6. Example: ORDER makes R1 <= R2 Is there a bug here?
;; Author: Ken Lambert
;; Calls the subroutine ORDER to guarantee that FIRST <= SECOND
.ORIG x3000
;; Main program register usage:
; R1 = initial value of FIRST
; R2 = initial value of SECOND
; Main program code
LD R1, FIRST
LD R2, SECOND
JSR ORDER
ST R1, FIRST
ST R2, SECOND
HALT
; Main program data
FIRST .BLKW 1
SECOND .BLKW 1
;; Subroutine ORDER
; Guarantees that R1 <= R2
; Input parameters: R1 and R2
; Output parameters: R1 and R2
; R3 = temporary working storage
ORDER ST R3, ORDERR3 ; Save R3
JSR SUB
BRnz ENDORD ; Exit if difference <= 0
ADD R3, R2, #0 ; Swap values in R1 and R2
ADD R2, R1, #0
ADD R1, R3, #0
ENDORD LD R3, ORDERR3 ; Restore R3
RET
; Data variable for subroutine ORDER
ORDERR3 .BLKW 1
;; Subroutine SUB . . .
Example: ORDER makes
R1 <= R2
Is there a bug here?

7. Example: ORDER makes R1 <= R2 Back up ret address
;; Author: Ken Lambert
;; Calls the subroutine ORDER to guarantee that FIRST <= SECOND
.ORIG x3000
;; Main program register usage:
; R1 = initial value of FIRST
; R2 = initial value of SECOND
; Main program code
LD R1, FIRST
LD R2, SECOND
JSR ORDER
ST R1, FIRST
ST R2, SECOND
HALT
; Main program data
FIRST .BLKW 1
SECOND .BLKW 1
;; Subroutine ORDER
; Guarantees that R1 <= R2
; Input parameters: R1 and R2
; Output parameters: R1 and R2
; R3 = temporary working storage
ORDER ST R3, ORDERR3 ; Save R3
ST R7, ORDERR7 ; Save R7
JSR SUB
BRnz ENDORD ; Exit if difference <= 0
ADD R3, R2, #0 ; Swap values in R1 and R2
ADD R2, R1, #0
ADD R1, R3, #0
ENDORD LD R3, ORDERR3 ; Restore R3
LD R7, ORDERR7 ; Restore R7
RET
; Data variables for subroutine ORDER
ORDERR3 .BLKW 1
ORDERR7 .BLKW 1
;; Subroutine SUB . . .
Example: ORDER makes
R1 <= R2
Back up ret address
before another call

8. Rules of Thumb for Namespace
Each program component owns its own labels (variables and instructions)
Each subroutine utilizes caller save for R7 and callee save for all other registers
Most parameters are input-only

9. Implementing a runtime stack
For Wednesday
Implementing a runtime stack