SPRU514Y User guide

SPRU514Y August 2001 – June 2022

7.3.2 How a Called Function Responds

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 instead. If writes are made to the structure from 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 passes 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.

	16-bit integer value	AL
	32-bit integer value	ACC
	64-bit integer value	ACC/P
	32-bit pointer	XAR4
	structure reference	XAR6