L9: Subroutines

1. ECE 2560 L9: Subroutines Department of Electrical and Computer Engineering The Ohio State University ECE 3561 - Lecture 1

2. Subroutines • Subroutines • What are they • How they can simplify a program • An example • Stacks • Passing data on the stack • How subroutine calls use the stack ECE 3561 - Lecture 1

3. Stacks • The stack – an area of memory for storage of data accessed through the PUSH and POP instructions ECE 3561 - Lecture 1

4. The 430 stack • After initialization – where is the stack? • After initialization the value in the SP register (R2) is 0x0300 (can see this in Code Composer) • Placing data on the stack • Done using a PUSH(.B) instruction • PUSH(.B) src Push the source onto stack • Action is SP-2-> SP src->@SP • Removing data from the stack • Done using a POP(.B) instruction • POP(.B) dst Pop item from stack to destination • Action is @SP-> dst SP+2 -> SP ECE 3561 - Lecture 1

5. Also in code composer • If you view memory it will show you data variables names at their location • To see action of stack will do some push and pop actions while watching memory • Will push values of 10 copies of $FFFF on the stack • Then 10 pops to get the SP back to no data – pop into R4 • Then push $0000,$0110,$0220,etc up to $0990 on the stack • Again 10 pops back into R4 • Also show what occurs when one is .B ECE 3561 - Lecture 1

6. In Demo • After initialization, the SP is set to value 0x0300. • Remember that the stack grows down in memory and the SP register points to where the last value pushed on the stack is. So when a value is pushed on the stack it, the SP register is decremented by 2 and then the data is stored in memory. ECE 3561 - Lecture 1

7. Binary Multiplication • Need to perform integer multiplication of A*B. • Will do this by simply adding up the value B, A times in a loop. • multmov A,R5 ;A is in R5 • mov B,R6 ;B is in R6 • clr R7 ;R7 to accumulate sum • mlp add R6,R7 ;add R6 to R7 • dec R5 ;A=A-1 • jnemlp ;repeat • ;end R7=B*A • As register is 16 bits and treated as 2’s complement, can do up to a 7-bit x 7-bit multiply for a 14 bit result. • Number of times through the loop? 128 times max ECE 3561 - Lecture 1

8. Now turn this into a subroutine • Could code up the previous instructions each time you need to do a multiply OR create a routine to do it. The routine needs the data to multiply passed to it. • Where to pass the data? • Could do it in registers • Could do it in memory • Could do it on the stack • Set up before call • move A and B to stack • use push instruction ECE 3561 - Lecture 1

9. Why one an not the other? • Why pass the data on the stack? • Pass it in registers • Works fine but program may be using registers for other tasks. • Pass in variables in memory • Works fine • Pass on the stack • Also works fine • For a simple routine like this no real advantage of any method. Just shows how to do pass variables on the stack. • Will look at subroutine for all three. ECE 3561 - Lecture 1

10. Demo of routine – use registers • Pick two register to pass data • Pick R5, and R6 for numbers to be multiplied • Pick R7 for the result • Code it up – calling routine • mov A,R5 ;A is in R5 • mov B,R6 ;B is in R6 • call #mult • end jmp end • ;the subroutine • multclr R7 ;R7 to accumulate sum • mlp add R6,R7 ;add R6 to R7 • dec R5 ;A=A-1 • jnemlp ;repeat • ret ;end R7=B*A • .data • A .word 3 • B .word 5 • RES .word 0 ECE 3561 - Lecture 1

11. Subroutine call/return • At end of subroutine code need a ret instruction. (see manual) RET • Note action of instruction • @SP  PC • SP + 2  SP • The CALL instruction action – again see manual. • dst tmp • SP-2  SP • PC  @SP • tmp  PC (tmp is not a register you can see) ECE 3561 - Lecture 1

12. Demo of routine – use memory • Pick memory locations to pass data • A and B are the data to be multiplied • RES is the result • Code it up – calling routine • mov#3,&A • mov#4,&B • call #mult • end jmp end • ;the subroutine • multclr &RES ;RES to accumulate sum • mlp add &B,RES ;add B to RES • dec&A ;A=A-1 • jnemlp ;repeat • ret ;end RES=B*A • .data • A .word 3 • B .word 5 • RES .word 0 ECE 3561 - Lecture 1

13. A third way – the stack • First two methods work, BUT • Limitations • REGISTER USE is fixed • Subroutine restricted to specific registers • For subroutine to have no side effects, must protect any register it uses. ECE 3561 - Lecture 1

14. The main and subroutine • In Main program • ;Setup for call • mov A,R5 • mov B,R6 • push R5 • push R6 • call #srmult • ;after return have to cleanup • SP will be pointing to B – result is A • pop stack twice – 2nd time is result position ECE 3561 - Lecture 1

15. Subroutine • Now in subroutine • srmultmov 2(SP),R6 ;B to R6 • mov 4(SP),R5 ;A to R5 • clr R7 • mlp add R6,R7 • dec R5 • jnemlp ;at end R7 is A*B • mov R7,4(SP) ;R7 for rtn • ret ;return from sr ECE 3561 - Lecture 1

16. But the call can be a problem • Have to make sure that call works correctly • The first time this was done, call was transferring control all over the place or so it seemed. • ;in main ;subroutine • mov A,R5 smultmov 2(SP),R6 • mov B,R6 mov 4(SP),R5 • push R5 ret • push R6 • mov #smult,R4 • call R4 • pop R7 • pop R7 • push R5 • push R6 • call #smult ;this code worked • pop R7 • pop R7 • mov R7,res ECE 3561 - Lecture 1

17. Get code working • When having problems get some code working and then build on it • In this case will build the subroutine • Demo ECE 3561 - Lecture 1

18. Multiply routine • The multiply routine is important as there is no multiply instruction • Note that the routine is for positive integer multiplication only. • With the algorithm implemented cannot multiply a negative number • Both A and B and the result have to be between 0 and 215-1, positive integers ECE 3561 - Lecture 1

19. Clean up the stack • After returning from subroutine • A ret simply pops the return address from the stack into the PC register • So execution continues after the subroutine call • If data was passed on the stack it needs to be cleaned up to retrieve the result and set the SP to before the call. ECE 3561 - Lecture 1

20. The pop instruction • The pop instruction removes the top item of the stack (the item currently pointed to by the SP register) and moves it to dst. • POP(.B) dst Pop item from stack to destination • Action is @SP-> dst SP+2 -> SP ECE 3561 - Lecture 1

21. Cleanup on Return • Same code – note the pop instructions that remove data and result from the stack • ;in main ;subroutine • mov A,R5 smultmov 2(SP),R6 • mov B,R6 mov 4(SP),R5 • push R5 ret • push R6 • mov #smult,R4 • call R4 • call #smult ;this code worked • pop R7 • pop R7 • mov R7,res ECE 3561 - Lecture 1

22. Subroutine side effects • Subroutine should have no side effects!,i.e., change the values of registers or data the main program is using • If subroutine should have no side effects then the state of machine (registers, memory, etc.) should be the same after the RTS as before the call. What does that mean? • That means that subroutine needs to preserve any register that it will affect during execution of the subroutine. • What are they? (refer to slide 11) • CALL and RET do not affect SR • Action in subroutine will alter sr bits, and here contents of R5, R6, and R7 ECE 3561 - Lecture 1

23. Items to preserve • The first item to preserve is the SR • How to do it? Push it onto the stack. • What else to save? Any register used. ECE 3561 - Lecture 1

24. Saving of the SR (R(2)) • Save the register you will use and SR. • Becomes ------- -> • State of SR upon • return is same as it • was before the call. ECE 3561 - Lecture 1

25. Save other registers • Subroutine used R5,R6,R7 – push on Stack ECE 3561 - Lecture 1

26. What is the code? • Note the change to the offsets of the passed arguments. • Now subroutine has no effect on • calling program. ECE 3561 - Lecture 1

27. Assignment • Code up a positive integer multiply subroutine as shown in this lecture • Description of this is on the webpage and is assignment HW6 ECE 3561 - Lecture 1