1. Chapters 9 & 10 Midterm next Wednesday (11/19) Trap Routines & RET Subroutines (or Functions) & JSR & JSRR & RET The Stack SSP & USP Interrupts RTI

2. Traps 1)Execute TRAP “vector” - Service Routine Addresses Trap Vectors are at memory locations [0000:00FF] Trap Vectors contain addresses of “Pre written (?)” Service Routines 2) [PC] is stored in R7 3) Address of Trap Service Routine loaded into PC 4) Service Routine Program executed 7)Trap service routine program ends with an RET ([R7] loaded into PC)

3. Subroutines 1) Execute JSR or JSRR - Call Subroutine or Method Location of Subroutine is specified in the Instruction 2) [PC] stored in R7 3) Address from JSR or JSRR is loaded into PC 4) Subroutine is executed R0 likely contains passed parameter (or address) R5 may be used to return error message R0 likely contains return parameter (or address) 5) Subroutine program ends with an RET ( [R7] loaded into PC) How does this mechanism support recursion?

4. The STACK The S tack is a dynamic “data structure” descending from high memory to lower memory (The stack grows down ) The Stack Pointer (R6) points to the top word on the stack. (The Stk Ptr is the “stack reference” that is available to the programmer) A new entry (word) is “ PUSHed ” onto the stack To take a word off of the Stack, the top word is “ POPed” off of the stack.

5. Stack R6 is the Stack Ptr Push: Push ADD R6, R6, #-1 ; Decrement Stack Ptr STR R0, R6, #0 ; “Push” Data onto Stack Pop: Pop LDR R0, R6, #0 ; “Pop” Data off of Stack ADD R6, R6, #1 ; Increment Stack Ptr Which way does the Stack grow? Where does Stack Ptr (R6) point?

6. Stack Underflow Check (Stack Empty) ; Stack POP subroutine. SP is R6. Returns “data” in R0. ; Fails if the stack is empty (SP=x4000) and reports error (1 --> R5) POP LDR1, STK_Empty; Compare Stk Ptr with “Empty” ADD R2, R6, R1 BRzfail_exit; EXIT IF STACK IS EMPTY ; if ok, Pop LDRR0, R6, #0; Pop top of Stack into R0 and ADDR6, R6, #1; Increment Stk Ptr ANDR5, R5, #0; R5 <-- 0 (POP successful) RET fail_exit AND R5, R5, #0; R5 <-- 1 (POP failed - underflow) ADDR5, R5, #1 RET STK_Empty.FILL xC000; STK_Empty  -x4000 (Stack begins at x3FFF)

7. Stack Overflow Check (Stack too Large) ; Stack PUSH subroutine. SP is R6. Value in R0 is pushed onto the stack. ; Fails if Stack is full (SP=x3F00) and reports error (1  R5) PUSH LD R1, STK_Full; Compare Stack Ptr with “Full” ADD R2, R6, R1 BRz fail_exit; EXIT IF STACK IS FULL ; if ok, PUSH ADD R6, R6, #-1; Decrement Stk Ptr and STR R0, R6, #0; “Push” R0 onto top of Stack AND R5, R5, #0; “Report” no Error 0  R5 RET fail_exit AND R5, R5, #0; “Report Error” 1  R5 ADD R5, R5, #1 RET STK_Full.FILL xC100 ; STK_Full <-- -x3F00 (Stack max is x3F00)

8. ; PUSH and POP Subroutines. STK Ptr is R6. Data in R0. Success: R0 = 0. ; Stack: x3FFF to x3F00 (256 words max). POP and PUSH are Entry Points. POP ST R2,Save2 ; R1 & R2 are used by “POP”. Save them. ST R1,Save1 LD R1,STK_Empty ; Compare Stk Ptr with “Empty” ADD R2,R6,R1 BRz fail_exit ; EXIT IF STACK IS EMPTY LDR R0,R6,#0 ; “POP” top of Stack into R0 and ADD R6,R6,#1 ; Increment stack pointer BRnzp success_exit PUSH ST R2,Save2 ; R1 & R2 are used by “PUSH”. Save them. ST R1,Save1 LD R1,STK_Full ; Compare Stk Ptr with “Full” ADD R2,R6,R1 BRz fail_exit ; EXIT IF STACK IS FULL ADD R6,R6,#-1 ; Decrement Stk Ptr and STR R0,R6,#0 ; “PUSH” R0 onto top of Stack success_exit AND R5,R5,#0 ; R5 <-- 0 (success) LD R1,Save1 ; Restore registers and Return LD R2,Save2 RET fail_exit AND R5,R5,#0 ; R5 <-- 1 (failure) ADD R5,R5,#1 LD R1,Save1 ; Restore registers and Return LD R2,Save2 RET STK_Empty.FILL xC000 ; BASE = –x4000. STK_Full.FILL xC100 ; Stack 256 words Save1.FILL x0000 Save2.FILL x0000.END Subroutine for Push & Pop What is a reasonable length for the Stack ? Two Entry Points: JSR POP & JSR PUSH Both [PC]  R7 Two exit Points: RET Both [R7]  PC Has an Initial Stk Ptr Address Here it is x4000 Has a Stack Limit (Often not spec) Here it is 256 words (x100)

9. Subroutine Using Stack ; Using Stack to store Registers and to pass arguments to Subroutine.ORIG x3000 MAIN ST R6,SaveR6 ; Initialize Stk Ptr (After saving old Stk Ptr) LD R6,STK_Init ADD R6,R6,#-1 ; Push R7 & R0 STR R7,R6,#0 ADD R6,R6,#-1 STR R0,R6,#0 AND R0,R0,#0 ; Push #5 (argument) onto Stack and call Double ADD R0,R0,#5 ADD R6,R6,#-1 ; (Push R0) STR R0,R6,#0 JSR Double LDR R0,R6,#0 ; Pop R0 ** Returned Value from Double ** ADD R6,R6,#1 LDR R0,R6,#0 ; Pop R0 & R7 ADD R6,R6,#1 LDR R7,R6,#0 ADD R6,R6,#1 LD R6,SaveR6 ; Restore old Stk Ptr Loop BRnzp Loop ; Loop when DONE SaveR6.BLKW 1 STK_Init.FILL x4000 ; Subroutine ; Double value passed and returned on Stack Double LDR R0,R6,#0 ; Pop argument from Stack ADD R6,R6,#1 ADD R0,R0,R0 ; Multiply R0 by 2 ADD R6,R6,#-1 ; Push return argument on Stack STR R0,R6,#0 RET.END Has an Initial Stk Ptr x4000 Registers Stored on Stack Pushed in beginning Poped at end Arguments Passed on Stack Pushed by MAIN Poped by Double Pushed by Double Poped by MAIN What are challenges using the stack this way ? What are the benefits ?

10. Recursive Subroutine ; Using the Stack for Recursive Subroutine Calls MAINSTR0, SaveR0 ; Save Registers Used STR1, SaveR1 STR6, SaveR6 STR7, SaveR7 LDR6, STK_Init ; Initialize STK_Ptr (R6) ANDR1, R1, #0 ; R1 <-- 10 (Depth of Recursion) ADDR1, R1, #10 JSRSUBR ; Call SUBR LDR0, SaveR0 ; Restore Registers LDR1, SaveR1 LDR6, SaveR6 LDR7, SaveR7 LoopBRnzpLoop ; Loop when done SaveR0.BLKW1 SaveR1.BLKW1 SaveR6.BLKW 1 SaveR7.BLKW1 STK_Init.FILL x4000 ; Recursive Subroutine (Stores R7 on the Stack) ; R1 is "shared" by all instances of SUBR SUBRADDR0, R7, #0 ; Push R7 onto Stack JSRPUSH ADDR1, R1, #-1 ; Decrement R1 BRzdone JSRSUBR ; Call SUBR again doneJSRPOP ; Pop R7 from Stack ADDR7, R0, #0 RET Are the PC and R7 the same ? Are the STK Ptr and R6 the Same ? Could we have stored R0 – R7 on Stack ? Why didn’t we store R0 & R1 in SUBR ? Could we have used SaveR0 & Save R1 in SUBR to save R0 & R1 ? How can we change this for SUBR to call itself until the Stack is full, and then terminate (unwind) properly ?