这是2013年写的一篇旧文，放在gegahost.net上面 http://raison.gegahost.net/?p=31
February 19, 2013
function calling convention
(original works by Peixu Zhu)
Function calling conventions are important for inter-operations between different languages, and debug inside. Since the birth of C language, the language has evolved for many years (it is older than me !!), with richer function calling conventions appeared. Some ideas validated before may be demanded to refresh.
Let us review current available conventions:
1. cdecl
- on the i386/x86_64 architecture, the cdecl attributes causes the compiler to assume that the calling function will pop off the stack space used to pass arguments, in another word, the caller is responsible to pop off the calling stack.
- arguments are all pushed into stack, with right to left.
- ’cause the stack is recovered by the caller function, thus, it is possible to implement functions with variable number of arguments, like fprintf series functions, since the compiler knows how many arguments are pushed in the stack.
- returned values normally in register RAX/EAX, or ST0.
2. stdcall
- on the i386/x86_64 architecture, the stdcall attribute cause the compiler to assume that the called function will pop off the stack space used to pass arguments, unless it take a variable number of arguments, i.e., the callee function is responsible to pop off the stack space before the function is returned to caller.
- arguments are all pushed into stack from right to left.
- it is possible to make functions with variable number of arguments, with supporting of compilers.
- returned values normally in register RAX/EAX.
3. fastcall
- on the i386 architecture, the fastcall atributes causes the compiler to pass the first argument(if of integral type) in the register ECX and the second argument(if of integral type) in the register EDX. subsequent and other typed arguments are passed on the stack from left to right.
- The callee function will pop the arguments off the stack, just like stdcall does.
- this is compiler dependent, some compilers may utilize other registers to pass argument.
- it makes less access of memory, and improve efficiency.
4. numbered register parameters
- on the i386 architectures, the attributes causes the compiler to pass arguments number one to number if they are of integral type in registers EAX, EDX, and ECX instead of on the stack.
- Functions that take a variable number of arguments will continue to be passed all of their arugments on the stack.
- return value in EAX.
- This is compiler dependent.
5. SSE register parameters
- on the i386 with SSE support, the attribute causes the compiler to pass up to 3 floating point arguments in SSE registers instead of on the stack.
- Functions that take a variable number of arguments will continue to pass all of their floating point arguments on the stack.
- Return value in EAX.
- This is a compiler dependent and CPU dependent feature.
- Greatly improve efficiency.
6. x86_64
- In 64-bit Intel programs the first six parameters are passed in registers: %rdi, %rsi, %rdx, %rcx, %r8, %r9.
- The return address is on the stack.
7. Power PC
- In Power PC programs, 32- or 64-bit, the first eight parameters are passed in registers: %r3, %r4, %r5, %r6, %r7, %r8, %r9, %r10.
- The return address is in register %lr.
Conclusion
Matching calling conventions is basically required. In practice, compiler optimization may cause the convention be changed potentially. Thus, be careful to specify call conventions of libraries, multi-threaded programs, and make sure mutex object has been specified volatile, otherwise, the potential register passing may cause nightmare.