Understand x86-64 System V ABI Calling Conventions at CPU Level

Topic Overview

System V AMD64 ABI

On Linux and macOS, compiled C functions follow the System V AMD64 ABI. The first six integer or pointer arguments arrive in registers; additional args sit on the stack. Return values land in RAX (integer) or XMM0 (float).

cCopy
Loading…

Stack and Saved Registers

• Caller-saved: RAX, RCX, RDX, RSI, RDI, R8-R11 (scratch)
• Callee-saved: RBX, RBP, R12-R15 (preserve if used)
• Stack: must stay 16-byte aligned before CALL

For this exercise, you will trace a function call in assembly and label which registers hold arguments and return values. This task asks you to read the ABI the way Ghidra does when it recovers main's parameters from a stripped binary.

Working Through the Exercise

Keep the relevant datasheet, ISA manual, or architecture textbook chapter open while you implement. When your output disagrees with the reference trace on the same program, the bug is usually a mis-decoded opcode, a stale register read, or a flag bit left unchanged after arithmetic.

• Trace first: walk one failing input by hand before changing random lines
• Read the manual: skim the official doc for the mechanism named in this task
• Compare baselines: save measurements from the prior step so speedups are honest

For this exercise, you will use those habits while implementing the requirement in the starter code. Microarchitectural product names change across CPU generations, but the control ideas (fetch, bypass, cache lines, vector lanes) stay stable enough to debug from first principles.

Your Task

Write the part of a compiler that decides where each argument lives under the x86-64 System V ABI, the calling convention used on Linux, macOS and the BSDs. Given C function prototypes, print the register or stack slot each parameter arrives in, using the correctly sized register name. Also print where the return value goes and how much stack the caller must reserve.

Rules

• Integer class (char, short, int, long, long long, their unsigned forms, and any pointer T *): the first six go in rdi, rsi, rdx, rcx, r8, r9, in that order.
• SSE class (float, double): the first eight go in xmm0: xmm7.
• The two classes are counted independently: f(int, double, int) uses edi, xmm0, esi.
• An argument that finds its class's registers used up goes on the stack. Stack arguments take 8-byte slots in parameter order. At function entry, the first one is at [rsp+8] ([rsp] holds the return address), the next at [rsp+16], and so on.
• Register names follow the size: 1 byte (char), 2 (short), 4 (int, float), 8 (long, long long, pointers, double).

• Return values: integer class → al/ax/eax/rax by size; float/double → xmm0; void → none.

Input

One prototype per line, e.g. long f(int a, double b, char *s);. Every parameter has a name. () and (void) mean no parameters. Types use the keywords above, optionally with const (kept in the printed type, no effect on the class), and * may touch the name (char *s, char* s, char*s).

Output

cCopy
Loading…

M is N rounded up to a multiple of 16, because rsp must be 16-byte aligned at the call. Print a blank line between functions. For the void return, print return (void) -> none.

Example

Input:

cCopy
Loading…

Output:

cCopy
Loading…

Requirements

1. Classify each parameter, then allocate from two independent counters (integer registers, SSE registers) and a stack-offset counter.
2. Look up sized register names from a table rather than string-mangling.

Hidden tests cover more than six integer arguments, more than eight floating-point arguments, char/short/unsigned sizes, void and float returns, and (void) parameter lists.