Calling convention-调用约定

In computer science, a calling convention is an implementation-level (low-level) scheme for how subroutines receive parameters from their caller and how they return a result. Differences in various implementations include where parameters, return values, return addresses and scope links are placed, and how the tasks of preparing for a function call and restoring the environment afterward are divided between the caller and the callee.

Calling conventions may be related to a particular programming language's evaluation strategy but most often are not considered part of it (or vice versa), as the evaluation strategy is usually defined on a higher abstraction level and seen as a part of the language rather than as a low-level implementation detail of a particular language's compiler.

 

Variations[edit]

Calling conventions may differ in:

• Where parameters, return values and return addresses are placed (in registers, on the call stack, a mix of both, or in other memory structures)
• The order in which actual arguments for formal parameters are passed (or the parts of a large or complex argument)
• How a (possibly long or complex) return value is delivered from the callee back to the caller (on the stack, in a register, or within the heap)
• How the task of setting up for and cleaning up after a function call is divided between the caller and the callee
• Whether and how metadata describing the arguments is passed
• Where the previous value of the frame pointer is stored, which is used to restore the frame pointer when the routine ends (in the stack frame, or in some register)
• Where any static scope links for the routine's non-local data access are placed (typically at one or more positions in the stack frame, but sometimes in a general register, or, for some architectures, in special-purpose registers)
• How local variables are allocated can sometimes also be part of the calling convention (when the caller allocates for the callee)

In some cases, differences also include the following:

• Conventions on which registers may be directly used by the callee, without being preserved (otherwise regarded as an ABI detail)
• Which registers are considered to be volatile and, if volatile, need not be restored by the callee (often regarded as an ABI detail)

Language variation[edit]

Threaded code[edit]

Main article:  Threaded code

Threaded code places all the responsibility for setting up for and cleaning up after a function call on the called code. The calling code does nothing but list the subroutines to be called. This puts all the function setup and cleanup code in one place—the prolog and epilog of the function—rather than in the many places that function is called. This makes threaded code the most compact calling convention.

Threaded code passes all arguments on the stack. All return values are returned on the stack. This makes naive implementations slower than calling conventions that keep more values in registers. However, threaded code implementations that cache several of the top stack values in registers—in particular, the return address—are usually faster than subroutine calling conventions that always push and pop the return address to the stack.^[1][2][3]

 

https://en.wikipedia.org/wiki/Calling_convention

转载于:https://www.cnblogs.com/feng9exe/p/8342231.html