_stdcall vs. _fastcall

I think that there are some cases when you have to pass arguments using the stack
(__stdcall) such as function with variable number of arguments ex "function(int x, ...)" The stack can handle any number of arguments but i don't think you can do that with registers (__fastcall).

Let your compiler sort it out. It can choose the calling convention fairly effectively by itself.

Besides __stdcall is in no way outdated. What do you think happens when all your arguments cant fit into registers?

Compilers don't choose calling conventions; they need to be specified by the coder: either explicitly by using one of the calling convention attributes or implicitly by compiler settings. For example, MSVC uses __cdecl for all functions without an explicit calling convention if /Gd is used (which is default), but uses __fastcall for all functions without an explicit calling convention if /Gr is used.

To quote Raymond Chen in his article The history of calling conventions, part 1, `Consequently, __fastcall was typically faster only for short leaf functions, and even then it might not be.'

1 (16-bit)
2 (old 32-bit)
3 (32-bit)
4 (ia64)
5 (amd64)

In addition to what's been said already, if function call overhead is causing you performance issues then by far the simplest and quickest solution is to make sure those functions gets inlined. The compiler will probably do that for you automatically in most cases anyway.

It can also be worthwhile to minimize the number of parameters you pass to functions in some cases (like say recursive functions which generally won't get inlined). Passing large structures / classes by value will obviously also be slow, use references or pointers instead.

Also note that in C++ the this pointer is passed in a register (ecx) anyway.

Quote:

Original post by VanillaSnake21 I think that there are some cases when you have to pass arguments using the stack (__stdcall) such as function with variable number of arguments ex "function(int x, ...)" The stack can handle any number of arguments but i don't think you can do that with registers (__fastcall).

Varargs are passed __cdecl, as __stdcall and __fastcall aren't able to cleanup the stack correctly.

__stdcall can result in slightly smaller code, especially if you do a lot of function calling.

Also as Adam_42 says, these calling conventions are only for free/static functions. Member functions are always called as "thiscall", where this is passed in ecx, and all other arguments are on the stack.


Also note, the above is only for MSVC, different compilers pass arguments in different ways.

If a function call overhead becomes/is-by-design a problem, factor the function call out. For example, if you know that a function will be called frequently (tens/hundreds of millions of times per second), then remove the function call.

Calling conventions don't matter enough to be worth it, since inlining is where the big benefits lie. These days, bottle-necks at this granularity come from memory access, so preventing that will generally dwarf any benefits obtained by function call anyway.

fastcall is also MSVC specific, and as such a rather poor choice. It's also very easy to run into linking problems when mixing calling conventions.

But again, it's very very rarely that the function calling mechanism will be the bottle-neck. The obvious solution is just too trivial - prefer to not call the function.

Thank you very much for the responses everyone. They're exactly what I was looking for and they clear up my confusion :)