ARM Registers: x0-x30, sp, lr, pc

Your Task

Before you write AArch64 assembly that calls or is called by C, you need to know where every value lives. Build an AAPCS64 (the standard Linux AArch64 ABI) calculator. Given a C signature, print the register or stack slot of each argument and of the return value. Given a register name, print its role in the calling convention.

Input

cCopy
Loading…

Types: char (1 byte), short (2), int (4), long (8), ptr (8), float (4), double (8), i128 (16, 16-byte aligned), and void (return type only).

Argument rules

Keep NGRN (the next general register, 0..8), NSRN (the next SIMD/FP register, 0..8) and NSAA (the next stack offset), all starting at 0. Assign the arguments left to right:

• Integer types and ptr: if NGRN < 8, use wN (size ≤ 4) or xN, then NGRN++. Otherwise use the stack: align NSAA up to 8, the slot is [sp, #NSAA], then NSAA += 8 (standard AAPCS64 rounds small stack arguments up to 8 bytes; Apple's variant does not).
• float / double: if NSRN < 8, use sN / dN, then NSRN++. Otherwise use an 8-byte stack slot as above.
• i128: round NGRN up to even (an odd register is left unused). If NGRN ≤ 6, use the pair xN:xN+1 and NGRN += 2. Otherwise set NGRN = 8, align NSAA to 16, use a 16-byte stack slot, and NSAA += 16.

Return values: w0/x0 for integers (by size), s0/d0, x0:x1 for i128, and none for void.

Output

cCopy
Loading…

Register roles:

These print as x19: callee-saved and v9: …. Aliases print as:

• w5 = low 32 bits of x5 (writes zero the upper half): ROLE;
• d3 = low 64 bits of v3: ROLE (and sN with 32 bits);
• fp = x29: ROLE and lr = x30: ROLE;
• sp: stack pointer, 16-byte aligned at calls;
• xzr: zero register (reads 0, writes are discarded) (same for wzr).

Errors:

• error: unknown register R (including leading zeros, like x07);
• error: unknown type T;
• error: bad signature (missing parentheses or name, void among the arguments, or more than 16 arguments);
• error: bad command: LINE.

Example

Input:

cCopy
Loading…

Output:

cCopy
Loading…

Requirements

1. Track NGRN, NSRN and NSAA exactly as the rules say. The expected placements were checked against clang's AArch64 code generation.
2. Solve it in any language. ARM assembly submissions are only compile-checked.

Hidden tests cover more than 8 integer arguments, i128 alignment both in registers and on the stack, running out of FP registers while integer registers are still free, void functions, every register class, and malformed input.