64 bit assembly, when to use smaller size registers
64-bit, assembly, cpu-registers, nasm, x86-64
Solution
First and foremost would be when loading a smaller (e.g. 8-bit) value from memory (reading a char, working on a data structure, deserialising a network packet, etc.) into a register.
MOV AL, [0x1234]
versus
MOV RAX, [0x1234]
SHR RAX, 56
# assuming there are actually 8 accessible bytes at 0x1234,
# and they're the right endianness; otherwise you'd need
# AND RAX, 0xFF or similar...
Or, of course, writing said value back to memory.
(Edit, like 6 years later):
Since this keeps coming up:
MOV AL, [0x1234]
- only reads a single byte of memory at 0x1234 (the inverse would only overwrite a single byte of memory)
- keeps whatever was in the other 56 bits of RAX
- This creates a dependency between the past and future values of RAX, so the CPU can't optimise the instruction using register renaming.
By contrast:
MOV RAX, [0x1234]
- reads 8 bytes of memory starting at 0x1234 (the inverse would overwrite 8 bytes of memory)
- overwrites all of RAX
- assumes the bytes in memory have the same endianness as the CPU (often not true in network packets, hence my `SHR` instruction years ago)
Also important to note:
MOV EAX, [0x1234]
- reads 4 bytes of memory starting at 0x1234 (the inverse would overwrite 4 bytes of memory)
- overwrites all of RAX, but the high bits will all be zero
- see: Why do most x64 instructions zero the upper part of a 32 bit register
Then, as mentioned in the comments, there is:
MOVZX EAX, byte [0x1234]
- only reads a single byte of memory at 0x1234
- extends the value to fill all of EAX (and thus RAX) with zeroes (eliminating the dependency and allowing register renaming optimisations).
In all of these cases, if you want to write from the 'A' register into memory you'd have to pick your width:
MOV [0x1234], AL ; write a byte (8 bits)
MOV [0x1234], AX ; write a word (16 bits)
MOV [0x1234], EAX ; write a dword (32 bits)
MOV [0x1234], RAX ; write a qword (64 bits)
Problem
I understand in x86_64 assembly there is for example the (64 bit) rax register, but it can also be accessed as a 32 bit register, eax, 16 bit, ax, and 8 bit, al. In what situation would I not just use the full 64 bits, and why, what advantage would there be? As an example, with this simple hello world program: ``` section .data msg: db "Hello World!", 0x0a, 0x00 len: equ $-msg section .text global start start: mov rax, 0x2000004 ; System call write = 4 mov rdi, 1 ; Write to standard out = 1 mov rsi, msg ; The address of hello_world string mov rdx, len ; The size to write syscall ; Invoke the kernel mov rax, 0x2000001 ; System call number for exit = 1 mov rdi, 0 ; Exit success = 0 syscall ; Invoke the kernel ``` rdi and rdx, at least, only need 8 bits and not 64, right? But if I change them to dil and dl, respectively (their lower 8-bit equivalents), the program assembles and links but doesn't output anything. However, it still works if I use eax, edi and edx, so should I use those rather than the full 64-bits? Why or why not?