Calling convention)

The _ stdcall and _ stdcall keywords force the compiler to generate function callusing the standard calling convention. functions must pass the correct number and type of arguments; this is unlike normal c use, which permits a variable number of function arguments. such functions comply with the standard Win32 argument-passing convention.

The above means that __stdcall forces the compiler to generate a function call using a standard call conversion. The function must pass the correct number and type of parameters. This is not like C, which allows variable parameters. Such a function follows the Win32 parameter transfer and conversion.

Stdcall has two meanings:

The first is to pass the parameter in the C style, that is, the parameter is pushed from right to left into the stack, and the parameter is read from left to right in the function.

Second, the function execution clears the stack. That is, the call function occupies a location where the parameters are input in the stack station. The called function is responsible for clearing these locations. If the number of parameters is unknown, the function does not know the number of bytes to be cleared in the stack during the compilation period, so that _ stdcall cannot be used. Such a function is like sprintf.

Calling convention: determines the order in which function parameters are transferred to and from the stack. The caller or the caller pushes the parameter to the stack and the modifier Convention used by the compiler to identify the function name.

There are many function call conventions. Here is a simple introduction:

1. The _ stdcall call convention is equivalent to the Pascal call convention that is frequently used in 16-bit dynamic libraries. In 32-bit VC ++ 5.0, Pascal's call Convention is no longer supported (actually it has been defined as _ stdcall. In addition to _ Pascal, __fortran and _ syscall are not supported). Instead, they are replaced by the _ stdcall call convention. The two are essentially the same, that is, the function parameter is passed from right to left through the stack. The called function clears the memory stack of the transfer parameter before returning, but the difference is the function name modifier section (the modification section of the function name will be described in detail later ).

_ Stdcall is the default calling method of the PASCAL program. It is usually used in Win32 API. The function uses the stack pressure method from right to left and clears the stack when it exits. After compiling a function, VC adds an underline prefix to the function name, and adds "@" and the number of bytes of the parameter to the function name.

2. c call conventions (which are described by the _ cdecl keyword) are pushed to the stack in sequence from right to left. The caller pushes the parameters to the stack. The memory stack of the transfer parameter is maintained by the caller (because of this, the function that implements the variable parameter can only use this call Convention ). In addition, the function name modification conventions are also different.

_ Cdecl is the default call Method for C and C ++ programs. Every function that calls it contains the code to clear the stack. Therefore, the size of the executable file generated is larger than that of the call to the _ stdcall function. The function uses the stack pressure mode from right to left. After compiling a function, VC adds an underline prefix to the function name. Is the default MFC call convention.

3. The _ fastcall call convention is "person" as its name. Its main feature is fast because it transmits parameters through registers (in fact, it uses ECx and EDX to transmit the first two DWORD or smaller parameters. The remaining parameters are still transmitted from the right to the left pressure stack, the called function clears the memory stack of the transfer parameter before returning). In terms of the function name modification conventions, it is different from the previous two.

_ Fastcall functions use registers to pass parameters. After compiling a function, VC adds the "@" prefix to the function name, and adds "@" and the number of parameters after the function name.

4. thiscall is only applied to "C ++" member functions. This pointer is stored in the Cx register and the parameter is pressed from right to left. Thiscall is not a keyword and cannot be specified by programmers.

5. Naked call uses 1-4 call timing. If necessary, the compiler will generate code to save the ESI, EDI, EBX, and EBP registers when entering the function, when you exit the function, the code is generated to restore the content of these registers. Naked call does not generate such code. The naked call is not a type modifier, so it must be used together with _ declspec.
 

The keywords _ stdcall, _ cdecl, and _ fastcall can be directly added before the function to be output, or in the setting environment... select/C ++/code generation. When the keywords added before the output function are different from those selected in the compiling environment, the keywords directly added before the output function are valid. Their corresponding command line parameters are/GZ,/GD, And/GR. The default status is/GD, Which is _ cdecl.

To fully imitate Pascal's call convention, you must first use the _ stdcall call Convention. As for the function name Modification Convention, you can use other methods to imitate it. Another thing worth mentioning is winapi macro, windows. h supports this macro. It can translate the function into an appropriate call convention. In Win32, it is defined as _ stdcall. You can use the winapi macro to create your own APIs.

 

Summary:

The call conventions such as Pascal are used to clear stacks, while the _ cdecl function is implemented by the caller. in actual use, I think the biggest difference between the two is that the number of function parameters of __cdecl can be declared as uncertain, such as printf and scanf, pascal's functions cannot do this. In this case, it does not know how many arguments there are.

In VC: Pascal = callback = winapi ==__ stdcall