I found some lecture notes and a chapter from a book and another. Still one more book has large sections available which, significantly, include a section specifically on subroutines (unfortunately, important parts of that aren't in the book preview). Lastly, there is also at least one message board specific to the 68HC12, where you may get more helpful answers - most of the people here don't really know the processor.
From what is shown in the available parts of that one book, the usual approach is one pretty typical for this sort of accumulator-based CPU: basically, you do it all through the stack. This is complicated by the lack of a frame pointer, but not all that much. The main thing is to use
leas
to offset the stack pointer by a fixed amount to set up local space. Along with the subroutine you would use a number of
equ
ates which act as offsets from where the top of the stack will be as the function runs. These will
all
be set up at the start of the function, forming what is known as an activation record for the subroutine. All of the arguments and local variables will be accessed using these offsets relative to SP. You will furthermore need offsets for the stack space for any registers you save at the start of the function.You will also - and this is very important - need an offset for the 16-bit value just before the first local variable. This value will hold the return address, and you will later reset the stack to it at the end of the function.
When one subroutine calls another, it starts by pushing the values for any function arguments it is passing, as well as a space for whatever return value it will get. Note that when I say 'pushing', it doesn't necessarily use psha, pshb, etc.; if it is expedient to do so, sure, but it can also use leas and memory-to-memory copies if it is easier. But I digress.
Anyway, only after the arguments are pushed, does it bsr or jsr to the function it is calling. This does two things: it pushes the return address (the address immediately following the subroutine call instruction) onto the stack, then jumps/branches to the start of the subroutine.
Now the subroutine itself has to set up it's activation record. It starts by pushing any registers other than IP and SP which it is going to use at any point in the function, so that they don't get trashed. Then it uses leas to subtract the total size of all of the local variables to the stack, moving the top of the stack down by that much and creating the activation record. The subroutine will not use the stack again, except for calling other subroutines, until finishes. When it is finished, it uses leas again to
add
the size of the activation record, then pops the registers in the reverse or from which it pushed them. At that point, if you've done things right, the return value is back at the top of the stack and you can safely rts back to where you were called. The caller then has to copy the return value somewhere safe, then clean up the arguments, before going on.
Here's a simple example of what I mean (not tested code, but it should get the idea across):
Code:- ; main program - note that it has to set up it's own local stack too
- main_locals equ 4 ; 2 bytes for the main() locals
- main_foo equ 2 ; offset for first local 16-bit variable
- main_bar equ 0 ; offset for second local 16-bit variable
- quux_ret_size equ 2 ; 16-bit return value size
- main psha
- pshb
- leas -main_locals, sp ; set up locals for main()
- ldaa 23
- staa main_foo, sp ; set the value of foo
- ; do something here...
- ldab main_foo, sp ; push foo as an argument
- leas -quux_ret_size, sp ; make space for return value
- bsr quux ; calling subroutine quux
- pula ; get return value off of stack
- leas quux_ret_size, sp ; clear off arguments
- staa bar ; save returned value in bar
- ; do something else
- end
- ;; offsets for quux, a function that adds 17 to it argument a
- ;; and returns the sum
- quux_locals equ 2
- quux_regs equ 2
- quux_baz equ 0
- quux_retval equ 6 ; offset for the return value - locals plus regs plus size of the return address
- quux_arg equ 8 ; offset for the argument
- quux psha ; save a
- leas -quux_locals, sp ; set aside space for baz
- ldaa 23
- staa quux_baz, sp ; initialize the value of quux_baz
- ldaa quux_arg, sp ; get the argument value
- adda quux_baz, sp ; add argument with baz
- staa quux_retval, sp ; ... and put it in th return value
- leas quux_locals, sp ; clean up locals
- pula ; restore registers
- rts ; return
|
