1. Stacks and Subroutines May 23

2. Stacks and subroutine usage The stack is a special area of the random access memory in the overall memory system The stack is used for – General data storage (limited) – Temporary data storage (true) – Parameter and control information storage for subroutines (yes!)

3. Stacks Last-in, first-out (LIFO) structure All access is at the top of the stack Operations – Push » Places an item onto the stack – Pull » Removes an item from the stack » Some (most!) people use the term “pop” Bottom of the stack is at highest memory address, and top of the stack is at the lowest address – Stack grows from high to low address – For EVBU, stack is usually placed at $01FF Stack Pointer (SP) – Register that points to the memory location immediately preceding the top of the stack – In other words, the SP normally contains the address for a new data item to be pushed

4. Low Address High Address Bottom SP

5. Push instructions – PSHA, PSHB, PSHX, PSHY » Stores data in memory at address pointed to by SP » Decrements SP » For 16-bit values, low- order byte is pushed first, followed by high-order byte data1 data2 data3 dataA dataXL dataXH SP SP-1 SP-2 SP-3 (New top of stack) RAM dataXHdataXL IX ACCA dataXH LDAA #dataA PSHA LDX #dataX PSHX (a) Push data onto stack to store it

6. Pull instructions – PULA, PULB, PULX, PULY » Increments SP» Decrements SP » Loads data from memory address pointed to by SP data1 data2 data3 dataA dataXL dataXH SP+3 SP+2 SP+1 SP (New top of stack) RAM dataXHdataXL IX ACCA dataA PULX PULA (a) Pull data from stack to receive it Stack Pointer

7. Other stack operations – Can modify or read the SP LDSLoad the SP STSStore the SP INSIncrement SP DESDecrement SP TSXTransfer SP+1 to IX TSYTransfer SP+1 to IY TXSTransfer IX-1 to SP TYSTransfer IY-1 to SP

8. Stacks – Remember to initialize SP at beginning of program – Important to pull data in reverse order that you pushed it – Note that SP points to empty memory location (= location where next value will be stored)

9. Using the stack – Passing parameters to subroutines (more on this later) – Temporary storage » 68HC11 has limited number of registers » Use stack to preserve register values Example: Multiply ACCA and ACCB, round to 8 bits PSHB; save value in ACCB MUL; ACCD = ACCA*ACCB ADCA #$00; round to 8 bits PULB; restore ACCB

10. Using the stack – You can also use the stack to save intermediate values – Example: This calculates x squared plus y squared. x and y are 8-bit numbers stored in addresses $1031 and $1032. The 8-bit result is put in ACCA. ORG$E000 BEGIN:LDS#$FF ; initialize SP LDAA$1031; get x value TAB; square it MUL ADCA#$00; round to 8 bits PSHA; save it LDAA$1032; get y value TAB; square it MUL ADCA#$00; round to 8 bits PULB; retrieve first result ABA; add them

11. Dangers in using the stack – Overflow » Too many pushes » Stack grows so large that it overwrites portions of memory that are being used for other purposes » Example: ORG$E0 FOORMB2 ORG$E000 LDS#$FF; initialize SP LDAB#$FF; initialize loop count LOOP:PSHA; push value on stack DECB; decrement count BNELOOP; and repeat

12. Dangers in using the stack (continued) – Underflow » Too many pulls » SP points to address higher than the intended bottom of the stack – The HC11 does not protect you from overflow or underflow! » Only way to recover is to reset the system » Be aware of the stack size that your program needs. – Typical memory layout for EVBU: » 512 bytes of RAM ($00-$1FF) » $00 - $FF used by Buffalo monitor Don’t use these locations in your programs » User variables should start at $100 ($100-?) » Stack starts at $1FF (? - $1FF) » More variables = less stack space

13. Why use them? – Provides modularity to reduce program complexity – Creates many smaller, but more easily developed and tested program units – May save on memory space (to store program) – Can be reused in different parts of a program – Can be placed in a library for use by many programs and applications

14. Subroutines should... – Be small, to ease writing, testing, and modifying – Have a well defined purpose – Have a well defined interface – Be well documented (like the rest of the program!) » Describe input parameters Registers, memory locations, values on the stack, etc. » Describe output parameters Registers, memory locations, stack, condition codes » Describe any side effects Registers that are changed, condition codes, etc.

15. Example of proper documentation format: ;****************************** ; Function: ToUpper ; This function replaces all lower-case ; characters in a string with upper-case. ; The end of the string is marked with ; $00. ; Input: IX = starting address of string ; Output: none ; Registers affected: ACCA, CCR ;*******************************

16. Calling a subroutine JSRsbr BSRsbr – Address of next instruction (return address) is pushed onto the stack » This is the current value of PC – PC is loaded with the starting address of the subroutine » Next instruction fetched will be from the subroutine

17. Returning from a subroutine – RTS instruction – Must be the last instruction in subroutine – Pops return address off the stack, loads it into PC » Next instruction fetch will be the instruction following the JSR/BSR – If your subroutine manipulates the stack, be aware of where the return address is stored. » It must be at the top of the stack when you execute the RTS

18. Subroutine parameter passing -- how are the parameters / arguments for the subroutine passed to it? – Registers » Parameters are placed in predetermined register locations » Simple and fast » Number of parameters is limited by the number of "free" registers » Code is not reentrant – Dedicated memory » A series of (predetermined) memory locations are used to hold the parameters » Simple, but added overhead due to memory operations » Possible to pass many parameters » Code is not reentrant

19. Pointer to memory  Pass the subroutine a register value containing the address of the parameters in memory  More complex, extra overhead for use of the pointer  Code is reentrant Use the stack  Parameters, in addition to the return address, are pushed onto the stack -- the combination is called the stack frame You must push the parameters before the JSR/BSR  Requires care in manipulating the parameters Don’t forget about the return address!  Many parameters can be passed  Separate parameter stack can be created and used in addition to the system stack  Code is reentrant

20. Example Example: Timing delay  Write a subroutine that will delay for a specified number of milliseconds. The delay time is passed as a parameter in ACCB. The subroutine should also preserve the contents of all registers as well as the condition codes Main program: LDAB #$0A ; delay for 10 ms JSR DELAY

21. Example Example: Write a subroutine to find the maximum of two signed 8-bit numbers. The two numbers are passed to the subroutine on the stack, and the maximum is returned to the calling routine on the stack. Main program: LDAA #$73 ; load the 2 values LDAB #$A8 PSHA ; push them on the stack PSHB JSR MAX ; find the max PULA ; pull max off stack

22. Example Example: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; Subroutine - MAX ; This subroutine returns the maximum of 2 ; signed 8-bit numbers. ; Input - The 2 numbers are passed on the stack ; Output - The maximum is returned on the stack ; Registers used - ACCA, ACCB, IY, CCR ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; MAX: PULY ; save return address PULB ; get the 2 numbers PULA CBA ; compare them BGT A_IS_MAX ; branch if ACCA > ACCB B_IS_MAX: PSHB ; return the value in ACCB BRA MAX_EXIT A_IS_MAX: PSHA ; return the value in ACCA MAX_EXIT: PSHY ; put return address back on stack RTS ; and return Cont..

23. Example Example: Convert an 8-bit hex number into 2 ASCII characters  For example, convert $3F into ‘3’ and ‘F’ The hex number is passed to the subroutine on the stack, and the 2 ASCII characters are returned on the stack, with the high-order character on top. Main program: LDAA #$3F ; get hex number PSHA JSR HEX_TO_ASCII ; convert it PULB ; ACCB = ‘3’ = $33 PULA ; ACCA = ‘F’ = $46

24. Example Converting hex digit to 2 ASCII characters  Pseudo code: Get hex digit from stack Convert lower nibble to ASCII Push char on stack Convert upper nibble to ASCII Push char on stack Return We’ll use a second subroutine to convert a nibble to ASCII  Note that the ASCII codes for 0-9 are $30-$39, and the codes for A-F are $41-$46  Pseudo code: Add #$30 to nibble If (result > $39) Add #$07 Return Cont..

25. Example Example: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; Subroutine - CONVERT_NIBBLE ; This subroutine converts a nibble (4-bit value) ; to ASCII. ; Input: ACCB contains the nibble ; Output: ACCB contains the ASCII code ; Registers affected: None ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; CONVERT_NIBBLE: PSHA ; save ACCA TPA ; save CCR PSHA ADDB #$30 ; convert to ASCII CMPB #$39 ; is nibble > 9? BLS CN_EXIT ; branch if not ADDB #$07 ; for A-F CN_EXIT: PULA ; restore CCR TAP PULA ; restore ACCA RTS ; return Cont..

26. Example Example: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; Subroutine - HEX_TO_ASCII ; This subroutine converts an 8-bit hex number ; to two ASCII digits. ; Input: Hex number is passed on the stack ; Output: ASCII characters are returned on the ; stack, with the high-order nibble on top. ; Registers affected: ACCA, ACCB, IY, CCR ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; HEX_TO_ASCII: PULY ; save return address PULA ; get hex number TAB ; copy it to ACCB ANDB #$0F ; get lower nibble JSR CONVERT_NIBBLE PSHB ; save ASCII on stack TAB ; get hex number again LSRB ; get upper nibble LSRB JSR CONVERT_NIBBLE PSHB ; save ASCII on stack PSHY ; push return address RTS ; and return Cont..

27. Summary Stack  Be sure to initialize the stack pointer at the beginning of your program LDS #$1FF Don’t do this if you’re calling your program from Buffalo Buffalo initializes SP for you  Push and Pull operations  Remember SP points to next empty location

28. Summary Subroutines  Break your program into subroutines Don’t do this if you’re calling your program from Buffalo Well-defined (and documented!) function Well-defined (and documented!) interface  Passing parameters Use registers if possible Else, use stack if needed – Don’t forget about the return address