Moving x86 assembly to 64-bit (x86-64)

While 64-bit x86 processors have now been on the market for more than 5 years, software support is only slowly catching on. 64-bit x86, or x86-64 as its inventors at AMD called it, not only offers programmers the ability to manipulate and address data in larger chunks, but added some other niceties like an additional 8 general purpose registers.

Transitioning assembly code from x86 to x86-64 is pretty straightforward, but there are some changes worth noting.

1. Full 64-bit registers are prefixed with r. So for 64-bit operations, you use rax rather than eax, rdi rather than edi and so forth.
2. The 8 new integer registers are labeled r8, r9, ... r15. To use only a part of the register, a suffix is added. 8-bits = b, 16-bits = w, 32-bits = d, meaning r8b, r8w and r8d in the case of r8.
3. 32-bit operations on a register automatically zero out the upper 32-bits of that register. For instance, if you load 0 into eax, rax is guaranteed to be 0.
4. The C ABI and calling conventions are substantially different. On standard x86 (32-bit), arguments are passed on the stack. On x86-64, many of the arguments are passed via registers.

   For Linux, the calling conventions are as follow:

   Registers rbp, rbx and r12 through r15 belong to the calling function. If the called function intends to modify them, it should save them at the beginning and restore them before returning. The caller must assume that all other registers can be changed by the called function.

   As in x86, integral return values are passed in rax. Parameters are trickier. The first 6 integral parameters are passed left-to-right, in rdi, rsi, rdx, rcx, r8 and r9 respectively. Remaining integral parameters are passed on the stack, but from right-to-left.

   p. 21 of the x86-64 ABI has a good explanation.

   In Windows x64, the system is similar. Registers rbp rbx, rdi, rsi and r12 through r15 belong to the calling function. All others belong to the called function. Return values are via rax. Input parameters are passed first in rcx, rdx, r8 and r9 (left to right). Remaining arguments are passed via the stack, right to left.

5. pushad and popad are gone. There are no 64-bit equivalent instructions. Presumably this is because with a greater number of registers, there should be no need to save and restore all registers when entering and exiting a function.
6. cqo is the new cdq. For sign-extending from eax to edx (32 bit), cdq was used. For sign-extending rax to rdx, cqo (convert-quad-to-oct) is used. It’s a handy little instruction, and not one that I managed to find easily.