Holy cow, I wrote a book!
In the 16-bit world, part of the calling convention was fixed
by the instruction set: The BP register defaults to the SS selector,
whereas the other registers default to the DS selector.
So the BP register was necessarily the register used for
accessing stack-based parameters.
The registers for return values were also chosen automatically
by the instruction set.
The AX register acted as the accumulator and therefore was the
obvious choice for passing the return value.
The 8086 instruction set also has special instructions
which treat the DX:AX pair as a single 32-bit value,
so that was the obvious choice to be the register pair
used to return 32-bit values.
That left SI, DI, BX and CX.
(Terminology note: Registers that do not need to be preserved
across a function call are often called "scratch".)
When deciding which registers should be preserved by a calling
convention, you need to balance the needs of the caller against
the needs of the callee. The caller would prefer that all
registers be preserved, since that removes the need for the caller
to worry about saving/restoring the value across a call.
The callee would prefer that no registers be preserved, since
that removes the need to save the value on entry and restore it
If you require too few registers to be preserved, then callers
become filled with register save/restore code. But if you
require too many registers to be preserved, then callees become
obligated to save and restore registers that the caller might
not have really cared about. This is particularly important for
leaf functions (functions that do not call any other functions).
The non-uniformity of the x86 instruction set was also a contributing
factor. The CX register could not be used to access memory, so you
wanted to have some register other than CX be scratch, so that a leaf
function can at least access memory without having to preserve any
registers. So BX was chosen to be scratch, leaving SI and DI as
So here's the rundown of 16-bit calling conventions:
In summary: Caller cleans the stack, parameters pushed right to left.
Function name decoration consists of a leading underscore.
My guess is that the leading underscore prevented a function
name from accidentally colliding with an assembler reserved word.
(Imagine, for example, if you had a function called "call".)
Nearly all Win16 functions are exported as Pascal calling convention.
The callee-clean convention saves three bytes at each call point,
with a fixed overhead of two bytes per function. So if a function
is called ten times, you save 3*10 = 30 bytes for the call points,
and pay 2 bytes in the function itself, for a net savings of 28 bytes.
It was also fractionally faster. On Win16, saving a few hundred bytes
and a few cycles was a big deal.
Consequently, __fastcall was typically faster only for short leaf functions,
and even then it might not be.
Okay, those are the 16-bit calling conventions I remember.
Part 2 will discuss 32-bit calling conventions, if I ever get around
to writing it.