A called function (child function) must perform the following tasks:
- If the called function modifies XAR1, XAR2, or XAR3, it must save them, since the calling function assumes that the values of these registers are preserved upon return. If the target is FPU, then in addition to the C28x registers, the called function must save registers R4H, R5H, R6H or R7H, if it modifies any of them. Any other registers may be modified without preserving them.
- The called function allocates enough space on the stack for any local variables, temporary storage area, and arguments to functions that this function might call. This allocation occurs once at the beginning of the function by adding a constant to the SP register.
- The stack is aligned at function boundary.
- If the called function expects a structure
argument, it receives a pointer to the structure. If writes are made to the
structure within the called function, space for a local copy of the structure
must be allocated on the stack and the local structure must be copied from the
passed pointer to the structure. If no writes are made to the structure, it can
be referenced in the called function indirectly through the pointer argument.
You must be careful to
properly declare functions that accept structure arguments, both at the
point where they are called (so that the structure argument is passed as an
address) and at the point where they are declared (so the function knows to
copy the structure to a local copy).
- The called function executes the code for the function.
- The called function returns a value. It is placed in a register using the
following convention:
- 16-bit integer value: AL
- 32-bit integer value: ACC
- 64-bit integer value: ACC/P
- 32-bit pointer: XAR4
- structure reference: XAR6
If the target is FPU and
a 32-bit float value is returned, the called function places this value in
R0H.
If the function
returns a structure, the caller allocates space for the structure and passes
the address of the return space to the called function in XAR6. To return a
structure, the called function copies the structure to the memory block
pointed by the extra argument.
In this way, the caller can
be smart about telling the called function where to return the structure.
For example, in the statement s= f(x), where S is a structure and F is a
function that returns a structure, the caller can actually make the call as
f(&s, x). The function f then copies the return structure directly into
s, performing the assignment automatically.
If the caller does not use
the return structure value, an address value of 0 can be passed as the first
argument. This directs the called function not to copy the return
structure.
You must be
careful to properly declare functions that return structures both at the
point where they are called (so that the extra argument is passed) and at
the point where they are declared (so the function knows to copy the
result). Returning 64-bit floating-point values (long double) are returned
similarly to structures.
- The called function deallocates the frame by subtracting the value that was added to the SP earlier.
- The called function restores the values of all registers saved in Step 1.
- The called function returns using the LRETR instruction. The PC is set to the value in the RPC register. The previous RPC value is popped from the stack and stored in the RPC register.