Share via


Microsoft Specific

The __fastcall calling convention specifies that arguments to functions are to be passed in registers, when possible. The following list shows the implementation of this calling convention.



Argument-passing order

The first two DWORD or smaller arguments are passed in ECX and EDX registers; all other arguments are passed right to left.

Stack-maintenance responsibility

Called function pops the arguments from the stack.

Name-decoration convention

At sign (@) is prefixed to names; an at sign followed by the number of bytes (in decimal) in the parameter list is suffixed to names.

Case-translation convention

No case translation performed.


Future compiler versions may use different registers to store parameters.

Using the /Gr compiler option causes each function in the module to compile as fastcall unless the function is declared with a conflicting attribute, or the name of the function is main.

On Itanium Processor Family (IPF) and AMD64 machines, __fastcall is accepted and ignored by the compiler; on an IPF chip, by convention, parameters are passed in register.

For non-static class functions, if the function is defined out-of-line, the calling convention modifier does not have to be specified on the out-of-line definition. That is, for class non-static member methods, the calling convention specified during declaration is assumed at the point of definition. Given this class definition,

struct CMyClass {
   void __fastcall mymethod();


void CMyClass::mymethod() { return; }

is equivalent to this

void __fastcall CMyClass::mymethod() { return; }


In the following example, the function named DeleteAggrWrapper is passed arguments in registers:

// Example of the __fastcall keyword
#define FASTCALL    __fastcall
void FASTCALL DeleteAggrWrapper(void* pWrapper);
// Example of the __ fastcall keyword on function pointer
typedef BOOL (__fastcall *funcname_ptr)(void * arg1, const char * arg2, DWORD flags, ...);

See Also


Argument Passing and Naming Conventions

C++ Keywords