This content originally appeared on Level Up Coding - Medium and was authored by Wassim Dhokar
Calling Convention Definition and Overview, RISCV low level implementation of calling convention for function call.
What is Calling Convention?
Calling convention refers to the schemes for how the function calls, subroutines gets their input parameters from the caller routine and how the caller it get the result from the called subroutines/functions.
This is generic computer science concept and not RISCV specific one, however the the implementation of this concept will differ from one Processor architecture to another , therefore RISCV has its own low level implementation of the Calling convention scheme.
Fundamentally Calling Convention consists of :
- Providing input parameters to called function/subroutine from the routine/function calling it.
- Providing a mechanism to return to the address in the caller function right after calling the subroutine.
- Preserving and getting out the result of the called function/subroutines
The calling function/routine is referred in this convention by callee and the called function/subroutine is referred by caller.
Low Level Scheme Implementation
Calling a function/subroutine can be seen something quiet easy to do from High level implementation perspective like C level Coding. Nevertheless in background and to be more precise at Assembly and instruction level implementation this is all about how to use Processors resources as well as hardware resources to manage saving current function state before jumping to subroutine, then how to restore somehow this state with preserving the results coming out from the previously called subroutines.
By going back to previously presented Calling convention fundamentals, we will do the mapping between those fundamentals and low level scheme implementation.
Passing input parameters to called function/subroutine from the top level calling routine, there are two schemes are used at low level :
- Use the Processor general purposes registers as containers of those input parameters which allow fast access to those parameters due to the low latency to access CPU internal registers , but in the other hands we don’t have unlimited Processors registers, means if the function calls requires multiple inputs parameters then better to have another way to pass the additional parameters to preserve some of the Processors registers for other use. The other method is to use the stack area, which is by the end of the day just a normal data area (SRAM ,DRAM …) where we have a dedicated processor register called ‘Stack Pointer’ to point to the stack section then get updated whenever the processors push some parameters to it or pop out of it those parameters.
- Returning back to the calling function: A dedicated Processor internal register called ‘Link Register’ is used here to save the address part of the calling function right after the line that calls the subroutine function, upon return from the called function then the processor the Program Counter will be updated with that value to return to the proper address.
- Getting the called function result: this is done by using one of the Processor general purpose registers to hold the result before jumping out of the called subroutine, then the calling function can get out the result of that register and saved for instance into stack or other area to reuse later this general purpose register that was holding the result for other purposes.
If you may think about those Calling Conventions fundamentals, you can see that this is more about how to use the Internal Processors/Hardware resources (general purpose registers, memory area for the stack …) to preserve the calling function state so that upon a return from the called subroutine we restore back the calling function state without messing up the execution flow of our program.
RISCV Approach
RISCV as Processor architecture is not an exception , and it will try to follow those calling convention fundamentals.
RISCV has 32 general purpose registers, some of those has double functionalities means the Link Register , Frame Pointer , Thread pointer can be used as general purpose ones as well.
In term of naming convention, the RISCV registers has standard names like : x0, x1, x2, x3, x4 ,…. x31 (in total 32 registers) , however in the other side for the calling convention we are having more meaningful names like : ra (link register or return address), sp (stack pointer), fp (frame pointer) tp (thread pointer) …
therefore we will need to have one-to-one mapping between RISCV registers standard names and calling convention naming , below is the RISCV mapping between those types of naming:
- Function Calls input Parameters: calling convention registers names a0,a1,a2,a3,a4,a5,a6,a7 which corresponds to RISCV internal registers x10,x11,x12,x13,x14,x15,x16,x17 are used to save the input parameters of function call, the called function subroutine will extract the input parameters from those registers for further instructions/operations execution and to free as well those registers to be re-used as part for the execution routine of different instructions.
- Link Register: calling convention name is ra (return address) and RISCV standard naming is x1, used as stated to hold the return address after the called subroutine get back to to the main function calling routing
- Stack Pointer: calling convention name sp and RISCV standard naming is x2, it point to the stack area and get updated upon PUSH/POP of data to/out of the stack area by the Processors, the saving and restore of data to/from stack is done by Processor when execution instructions like PUSH (to save)/ POP (to read) to/from Stack section.
There are some other registers used for different purposes like the ones used for PLT/GOT procedure call specific to dynamic linking and shared binary execution flow but this is beyond the scope of this calling convention blog, I wanted maybe to give some light into this topic due to the fact we have multiple registers in above RISCV calling convention naming beside the standard ones used for function calling convention that has double functionalities and you may get confused by them.
Caller vs Callee Registers
As stated before, the caller refers to calling function and the callee refers to called function/subroutine. This classification is propagated as well to the registers itself, means the registers can be classified into two major categories: caller and callee registers.
- Callee saved registers: whose values the called method must save and restore (if it uses them).
- Caller saved registers: whose value the calling method must save and restore (if it depends on them after the call).
Based on above definition, the calling function will save into stack the caller registers to prevent the called subroutine from modifying those registers contents and upon return from called function subroutine and if needed those registers saved contents will be popped-up back from the stack, in the other hand the called function/subroutine will preserve and backup/restore them if needed by the subroutine and will be modified within this called subroutine.
All RISCV input parameters registers a0,a1 … a7 are considered a caller registers and must be saved into stack by the calling function then restored back again from the stack upon return from called subroutine, beside those we have another set of RISCV registers that can be used by different instructions set in the function body like S0, S1, S2, S3, S4, … S11, those ones are callee registers and will be preserved and saved/restored by the called function/subroutine in case they have been used.
Prologue and Epilogue
Prologue refer to the callee function entry routine to save into stack different Processor registers to be used within the callee function body.
Epilogue in the other hand refers to the function end routine used to restore back the prologue saved registers routine before jumping back to the calling function return address.
RISCV Function Calling Convention was originally published in Level Up Coding on Medium, where people are continuing the conversation by highlighting and responding to this story.
This content originally appeared on Level Up Coding - Medium and was authored by Wassim Dhokar
Wassim Dhokar | Sciencx (2024-07-26T16:01:16+00:00) RISCV Function Calling Convention. Retrieved from https://www.scien.cx/2024/07/26/riscv-function-calling-convention/
Please log in to upload a file.
There are no updates yet.
Click the Upload button above to add an update.