Memory Addressing Modes

An addressing mode is the specific way an instruction's operand tells the CPU where to find the actual value it should operate on. The same mnemonic, mov, behaves completely differently depending on the addressing mode of its operands: mov eax, 5 places a literal constant into a register, while mov eax, [rbx] tells the CPU to treat the value in RBX as a memory address, go fetch the 4 bytes stored there, and load that into EAX. Choosing the right addressing mode is central to writing correct and efficient assembly, because array traversal, struct field access, and pointer dereferencing are all implemented purely through the addressing modes an ISA provides — there is no separate 'array' or 'struct' concept at the machine level, only combinations of base registers, index registers, scale factors, and displacement constants.

Immediate addressing embeds the actual constant value right inside the instruction itself, as in mov eax, 42, where 42 is encoded directly into the machine code bytes and requires no memory access at all beyond fetching the instruction. Register addressing uses a register's contents directly as the operand, such as add eax, ebx, which is fast because both operands already live in on-chip storage with no RAM access required. Direct (absolute) addressing specifies a fixed, literal memory address to read from or write to, as in mov eax, [0x404000], which is useful for accessing a global variable at a known, fixed location but becomes fragile the moment code is relocated in memory, which is why position-independent code typically avoids pure direct addressing in favor of RIP-relative addressing instead.

Register-indirect addressing treats a register's value as a pointer: mov eax, [rbx] reads the 4-byte value found at the memory address currently stored in RBX, which is how dereferencing a pointer variable is implemented in every compiled C program. x86-64's most powerful mode combines four components in a single instruction — base register, index register, scale factor, and constant displacement — written as mov eax, [rbx + rcx*4 + 8], which computes the effective address as RBX + (RCX × 4) + 8 in one step; this single instruction form is precisely how compilers implement array indexing like array[i] for a 4-byte-element array, where RBX is the array's base address, RCX is the index i, the scale factor 4 matches the element size, and the displacement offsets past any leading struct fields. Understanding this addressing form explains why choosing data types with power-of-two sizes (1, 2, 4, or 8 bytes) lets a compiler use the hardware's built-in scale factor instead of emitting extra multiply instructions.