NASM Memory Addressing and the x86-64 Stack: A Practical Guide.

Registers provide the processor with very fast working storage. Main memory provides a much larger space for storing instructions and data. Assembly instructions can operate directly on registers, use immediate values, or access data stored in memory.

Consider the following instruction:

mov rax, rbx

This copies the value currently held in RBX into RAX. It does not access the memory location whose address might happen to be stored in RBX.

Now compare it with:

mov rax, [rbx]

Here the square brackets indicate a memory operand. The value in RBX is interpreted as an address, and the processor reads the data stored at that memory location.

A common x86-64 addressing form can be represented conceptually as:

base + index × scale + displacement

The base register provides a starting address. The index register can represent an element position. The scale accounts for the size of each element, and the displacement provides an additional fixed offset.

mov rax, [rbx + rcx*8]

If RBX represents the beginning of an array and RCX represents an element index, multiplying the index by eight is appropriate when each element occupies eight bytes. The resulting effective address identifies the requested element.

lea rax, [rbx + rcx*8]

The instruction above calculates the effective address represented by the expression inside the brackets and places that address into RAX. It does not load the value stored at that address.

This makes LEA useful for address calculations and certain arithmetic expressions where the addressing hardware can efficiently construct the desired result.

mov rax, [rbx + rcx*8]
lea rdx, [rbx + rcx*8]

The first instruction accesses memory and retrieves the value. The second calculates the address itself. Understanding this distinction is essential when reading compiler-generated assembly.

Unlike a general-purpose data structure, the stack follows a particular access discipline. Data is typically added and removed according to a last-in, first-out pattern.

In x86-64, RSP is the stack pointer. It tracks the current stack position, while instructions such as PUSH and POP adjust the stack as data is added or removed.

push rax
push rbx

pop rbx
pop rax

In the example, the values are restored in reverse order. The last value pushed is the first value popped.

mov rax, 100
mov rbx, 200

push rax
push rbx

pop rcx
pop rdx

The values are pushed in the order RAX and then RBX. Because the stack is last-in, first-out, POP places RBX's saved value into RCX and RAX's saved value into RDX.

This simple pattern demonstrates why stack order matters when saving registers or temporary values.

A traditional stack-frame model often uses RBP as a stable reference point and RSP to track the current top of the stack. Local variables and saved state can then be accessed at known offsets.

push rbp
mov rbp, rsp

; procedure body

mov rsp, rbp
pop rbp
ret

This is a simplified educational model of a procedure prologue and epilogue. Modern compilers may omit the frame pointer or organise the stack differently, especially when optimisation is enabled.

Nevertheless, understanding this conventional model provides a strong foundation for reading assembly and examining stack frames in a debugger.