x86 and x86-64 calling conventions compared

Four ABIs cover nearly all x86 code: System V x86-64 for Linux, macOS and the BSDs, Microsoft x64 for Windows and UEFI, and their 32-bit counterparts, System V i386 and the 32-bit Windows conventions, of which the tables show __cdecl, the default. The overview says which platform uses which. The columns of every table link to the page of their ABI.

Arguments#

Tables 1 and 2 are not typed in. Each function of a small example returns its Nth argument, and the build reads where the argument comes from out of the function’s first instruction, for each ABI; a stack slot is given relative to the stack pointer on entry, when it points at the return address.

The two 64-bit ABIs differ in more than the registers. System V keeps two independent sequences: integers take the next of six general-purpose registers and floating-point values the next of eight vector registers, whatever their order. Microsoft gives each of the first four positions one slot: the second argument is in RDX if it is an integer and in XMM1 if it is a double. Microsoft’s stack arguments also start 32 bytes further up, past the shadow space that the caller reserves. On 32-bit x86, every argument is on the stack, and a double takes two slots.

/* Mixed arguments: System V fills integer and vector registers from
   separate sequences, Microsoft x64 gives each position one slot. */
double second_double(int a, double b)
{
	return b;
}

int second_int(double a, int b)
{
	return b;
}

second_double:
        ret

second_int:
        movl    %edi, %eax
        ret

second_double:
        ret

second_int:
        mov     eax, edi
        ret

second_double:
        movaps  %xmm1, %xmm0
        retq

second_int:
        movl    %edx, %eax
        retq

second_double:
        movaps  xmm0, xmm1
        ret

second_int:
        mov     eax, edx
        ret

Return values#

Callee-saved registers#

A callee-saved register must have the same value when a function returns as when it was called; the function saves and restores it if it uses it. All other registers are scratch, and any call may change them.

The difference in the first two columns is the cost of calling across ABIs: a Windows function called from System V code may overwrite nothing the caller expects kept, but a System V function called from Windows code may overwrite RSI, RDI and XMM6 to XMM15, which the caller expects back. The Microsoft x64 page shows the code that saves them.

Structs, floating point and vectors#

/* A 16-byte vector, like SSE's __m128, as argument and result. */
typedef float v4sf __attribute__((vector_size(16)));

v4sf vadd(v4sf a, v4sf b)
{
	return a + b;
}

vadd:
        addps   %xmm1, %xmm0
        ret

vadd:
        addps   xmm0, xmm1
        ret

vadd:
        movaps  (%rcx), %xmm0
        addps   (%rdx), %xmm0
        retq

vadd:
        movaps  xmm0, xmmword ptr [rcx]
        addps   xmm0, xmmword ptr [rdx]
        ret

vadd:
        addps   %xmm1, %xmm0
        ret

vadd:
        addps   xmm0, xmm1
        ret

_vadd:
        addps   %xmm1, %xmm0
        retl

_vadd:
        addps   xmm0, xmm1
        ret

The stack#

The stack frames page shows how a function lays out its frame in each ABI.