CPU Registers Explained

A register is a small, extremely fast storage location built directly into the CPU itself, holding a fixed number of bits — 64 on a modern x86-64 processor. Unlike RAM, which sits outside the CPU chip and requires dozens of clock cycles to access, a register can typically be read or written in a single clock cycle, making registers the fastest storage a program can use. Every arithmetic or logic operation an x86-64 CPU performs — addition, comparison, bitwise AND — operates on values sitting in registers, not directly on memory in most cases; data must first be loaded from RAM into a register before the CPU can compute on it. Because there are only a limited number of registers (16 general-purpose 64-bit registers on x86-64), assembly programmers and compilers must constantly decide which values are important enough to keep in a register versus which should be spilled back out to memory, a process called register allocation.

On x86-64, the general-purpose registers are named RAX, RBX, RCX, RDX, RSI, RDI, RBP, RSP, and R8 through R15, each 64 bits wide, though many can also be accessed as smaller 32-bit (EAX), 16-bit (AX), or 8-bit (AL) sub-portions of the same physical register. While these are called 'general-purpose,' several carry conventional roles by tradition and by the calling convention a platform uses: RAX typically holds a function's return value, RCX, RDX, RSI, and RDI are commonly used to pass the first four integer arguments to a function under the System V AMD64 calling convention used on Linux and macOS, and RSP always points to the top of the current call stack. RBP is conventionally used as a frame pointer to reference local variables and function parameters relative to a fixed point within a stack frame, though optimizing compilers sometimes free it up as a thirteenth general-purpose register when frame-pointer omission is enabled.

Beyond the general-purpose set, x86-64 has registers with fixed, non-negotiable hardware roles. RIP, the instruction pointer, always holds the memory address of the next instruction the CPU will fetch and execute; a jmp or call instruction works by directly overwriting RIP, which is exactly how loops, function calls, and if/else branching are implemented at the hardware level. RFLAGS is a register where individual bits (flags) are automatically set or cleared as a side effect of arithmetic and comparison instructions — the Zero Flag (ZF) is set when a result equals zero, the Carry Flag (CF) is set on unsigned overflow, and the Sign Flag (SF) reflects the sign of a result. Conditional jump instructions such as je (jump if equal) or jl (jump if less) don't compare values themselves; they simply inspect the flags left behind by a preceding cmp instruction, which is why cmp is almost always immediately followed by a conditional jump in real assembly code.