The calling routine uses a calling convention to determine the order in which to pass arguments (parameters) to another routine. This convention can be specified in a mixed-language interface statement or declaration.The term “calling convention” refers to the way a language implements a call. The choice of calling convention affects the machine instructions that a compiler generates to execute (and return from) a function, procedure, or subroutine call.
It is crucial that the two routines concerned (the routine issuing a call and the routine being called) use the same protocol. Otherwise, the processor may receive inconsistent instructions, causing the program to behave incorrectly.
The use of a calling convention affects programming in three ways:
The calling routine uses a calling convention to determine the order in which to pass arguments (parameters) to another routine. This convention can be specified in a mixed-language interface statement or declaration.
The called routine uses a calling convention to determine the order in which to receive the parameters passed to it. In most languages, this convention can be specified in the routine's heading. BASIC, however, always uses its own convention to receive parameters.
Both the calling routine and the called routine must agree on which of them is responsible for adjusting the stack in order to remove parameters.
In other words, each call to a routine uses a certain calling convention; each routine heading specifies or assumes some calling convention. The two conventions must be compatible. With all languages except BASIC, it is possible to change the calling convention at the point of the call or at the declaration of the called routine. Usually, however, it is easier to adopt the convention of the called routine. For example, a C function would use its own convention to call another C function, and would use the Pascal convention to call Pascal.
C++, BASIC, FORTRAN, and Pascal use the same standard calling convention. C uses a different convention.
Effects of Calling Conventions
Calling conventions dictate three things:
The way parameters are communicated from one routine to another (in Microsoft mixed-language programming, parameters or pointers to the parameters are passed on the stack)
The order in which parameters are passed from one routine to another
The part of the program responsible for adjusting the stack
Summary: Some languages pass parameters in a different order than C.
The C++, BASIC, FORTRAN and Pascal calling conventions push parameters onto the stack in the order in which they appear in the source code. For example, the BASIC statement
CALL Calc( A, B )
pushes argument A onto the stack before it pushes B. These conventions also specify that the stack is adjusted by the called routine just before returning control to the caller.
The C calling convention pushes parameters onto the stack in the reverse order from their appearance in the source code. For example, the C function call
calc( a, b );
pushes b onto the stack before it pushes a. In contrast with the other high-level languages, the C calling convention specifies that a calling routine always adjusts the stack immediately after the called routine returns control.
The BASIC, FORTRAN, and Pascal conventions produce slightly less object code. However, the C convention makes calling with a variable number of parameters possible. (Because the first parameter is always the last one pushed, it is always on the top of the stack; therefore it has the same address relative to the frame pointer, regardless of how many parameters were actually passed.) If a C++ function is declared to accept a variable number of parameters, the function automatically uses the C calling convention.
Note:
The __fastcall keyword, which specifies that parameters are to be passed in registers, is incompatible with programs written in other languages. Avoid using __fastcall or the /Gr command-line option for C or C++ functions that you intend to make public to BASIC, FORTRAN, or Pascal programs.