L9: Subroutines

1
L9 Subroutines
ECE 2560

• Department of Electrical and
• Computer Engineering
• The Ohio State University

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

3
Stacks

• The stack an area of memory for storage of data
  accessed through the PUSH and POP instructions

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-gt SP src-gt_at_SP
• Removing data from the stack
• Done using a POP(.B) instruction
• POP(.B) dst Pop item from stack to
  destination
• Action is _at_SP-gt dst SP2 -gt SP

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

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.

7
Binary Multiplication

• Need to perform integer multiplication of AB.
• Will do this by simply adding up the value B, A
  times in a loop.
• mult mov 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 AA-1
• jne mlp repeat
• end R7BA
• As register is 16 bits and treated as 2s
  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

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

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.

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
• mult clr R7 R7 to accumulate sum
• mlp add R6,R7 add R6 to R7
• dec R5 AA-1
• jne mlp repeat
• ret end R7BA
• .data
• A .word 3
• B .word 5

11
Subroutine call/return

• At end of subroutine code need a ret instruction.
  (see manual) RET
• Note action of instruction
• _at_SP ? PC
• SP 2 ? SP
• The CALL instruction action again see manual.
• dst ? tmp
• SP-2 ? SP
• PC ? _at_SP
• tmp ? PC (tmp is not a register you can see)

12
Demo of routine use memory

• 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 3,A
• mov 4,B
• call mult
• end jmp end
• the subroutine
• mult clr RES RES to accumulate sum
• mlp add B,RES add B to RES
• dec A AA-1
• jne mlp repeat
• ret end RESBA
• .data
• A .word 3
• B .word 5

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.

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

15
Subroutine

• Now in subroutine
• srmult mov 2(SP),R6 B to R6
• mov 4(SP),R5 A to R5
• clr R7
• mlp add R6,R7
• dec R5
• jne mlp at end R7 is AB
• mov R7,4(SP) R7 for rtn
• ret return from sr

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 smult mov 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

17
Get code working

• When having problems get some code working and
  then build on it
• In this case will build the subroutine
• Demo

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

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.

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 _at_SP-gt dst SP2 -gt SP

21
Cleanup on Return

• Same code note the pop instructions that remove
  data and result from the stack
• in main subroutine
• mov A,R5 smult mov 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

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

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.

24
Saving of the SR (R(2))

• Save the register you will use and SR.
• Becomes ------- -gt
• State of SR upon
• return is same as it
• was before the call.

25
Save other registers

• Subroutine used R5,R6,R7 push on Stack

26
What is the code?

• Note the change to the offsets of the passed
  arguments.
• Now subroutine has no effect on
• calling program.

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