Question

I have seen the fastcall notation appended before many functions. Why it is used?

Answer 1

That notation before the function is called the “calling convention.” It specifies how (at a low level) the compiler will pass input parameters to the function and retrieve its results once it’s been executed.

There are many different calling conventions, the most popular being stdcall and cdecl.

You might think there’s only one way of doing it, but in reality, there are dozens of ways you could call a function and pass variables in and out. You could place the input parameters on a stack (push, push, push to call; pop, pop, pop to read input parameters). Or perhaps you would rather stick them in registers (this is fastcall – it tries to fit some of the input params in registers for speed).

But then what about the order? Do you push them from left to right or right to left? What about the result – there’s always only one (assuming no reference parameters), so do you place the result on the stack, in a register, at a certain memory address?

Also, let’s assume you’re using the stack for communication – who’s job is it to actually clear the stack after the function is called – the caller or the callee?

What about backing up and then restoring the contents of (certain) CPU registers – should the caller do it, or will the callee guarantee that it’ll return everything the way it was?

The most popular calling convention (by far) is cdecl, which is the standard calling convention in both C and C++. The WIN32 API uses stdcall, which means any code that calls the WIN32 API needs to use stdcall for those function calls (making it another popular choice).

fastcall is a bit of an oddball – people realized for many functions with only one in/out parameter, pushing and popping from a memory-based stack is quite a bit of overhead and makes function calls a little bit heavy so the different compilers introduced (different) calling conventions that will place one or more parameters in registers before placing the rest in the stack for better performance. The problem is, not all compilers used the same rules for what goes where and who does what with fastcall, and as a result you have to be careful when using it because you’ll never know who does what. Finally, see Is fastcall really faster? for info on fastcall performance benefits.

Complicated stuff.

Something important to keep in mind: don’t add or change calling conventions if you don’t know exactly what you’re doing, because if both the caller and the callee do not agree on the calling convention, you’ll likely end up with stack corruption and a segfault. This usually happens when you have the function being called in a DLL/shared library and a program is written that depends on the DLL/SO/dylib being a certain calling convention (say, cdecl), then the library is recompiled with a different calling convention (say, fastcall). Now the old program can no longer communicate with the new library.