
System programming
UM0404
DocID13284 Rev 2
a mechanism of accessing data referenced by data pointers, which are passed to the
subroutine. In addition, two instructions have been implemented to allow one parameter to
be passed on the system stack without additional software overhead.
The PCALL (push and call) instruction first pushes the 'reg' operand and the IP contents
onto the system stack and then passes control to the subroutine specified by the 'caddr'
operand.
When exiting from the subroutine, the RETP (return and pop) instruction first pops the IP
and then the 'reg' operand from the system stack and returns to the calling program.
Cross segment subroutine calls
Calls to subroutines in different segments require the use of the CALLS (call inter-segment
subroutine) instruction. This instruction preserves both the CSP (code segment pointer) and
IP on the system stack.
Upon return from the subroutine, a RETS (return from inter-segment subroutine) instruction
must be used to restore both the CSP and IP. This ensures that the next instruction after the
CALLS instruction is fetched from the correct segment.
Note:
It is possible to use CALLS within the same segment, but still two words of the stack are
used to store both the IP and CSP.
Providing local registers for subroutines
For subroutines which require local storage, the following methods are provided:
Alternate bank of registers:
Upon entry into a subroutine, it is possible to specify a new
set of local registers by executing the SCXT (switch context) instruction. This mechanism
does not provide a method to recursively call a subroutine.
Saving and restoring of registers:
To provide local registers, the contents of the registers
which are required for use by the subroutine can be pushed onto the stack and the previous
values be popped before returning to the calling routine. This is the most common technique
used today and it does provide a mechanism to support recursive procedures. This method,
however, requires two instruction cycles per register stored on the system stack (one cycle
to PUSH the register, and one to POP the register).
Use of the system stack for local
registers:
It is possible to use the SP and CP to set up
local subroutine register frames. This enables subroutines to dynamically allocate local
variables as needed within two instruction cycles.
A local frame is allocated by simply subtracting the number of required local registers from
the SP, and then moving the value of the new SP to the CP.
This operation is supported through the SCXT (switch context) instruction with the
addressing mode 'reg, mem'. Using this instruction saves the old contents of the CP on the
system stack and moves the value of the SP into CP (see example below). Each local
register is then accessed as if it was a normal register. Upon exit from the subroutine, first
the old CP must be restored by popping it from the stack and then the number of used local
registers must be added to the SP to restore the allocated local space back to the system
stack. The system stack is growing downwards, while the register bank is growing upwards.