Introduction to x86 Assembly Language: Registers, Memory Model, and Stack Operations

Programming in high‑level languages ultimately requires a compiler to translate source code into binary instructions that the CPU can execute. Assembly language is the textual form of those binary instructions, providing a one‑to‑one mapping between human‑readable mnemonics and machine opcodes.

This article gives a concise tutorial on x86 assembly, covering what assembly is, its historical origin, the role of registers, and the memory models (heap and stack) used by programs.

What is assembly language? It is a low‑level language that directly describes CPU operations. For example, the binary opcode 00000011 corresponds to the mnemonic ADD for an addition instruction.

Origin – Early computers required programmers to input raw binary via switches or punched tape. To improve readability, engineers introduced symbolic names (e.g., ADD ) and a translation step called assembling , performed by an assembler that produces an assembly file.

Registers – Registers are fast, small storage locations inside the CPU. The classic x86 register set includes EAX , EBX , ECX , EDX , EDI , ESI , EBP , and ESP . ESP holds the stack pointer, pointing to the current top of the stack.

Memory model – Heap – Dynamic memory is allocated from a low address (e.g., 0x1000 ) upward. The heap grows toward higher addresses and must be released manually or by a garbage collector.

Memory model – Stack – The stack is used for function calls. Each call creates a frame that stores local variables and return information. The stack grows from high addresses downwards.

int main() {
    int a = 2;
    int b = 3;
}

When main starts, a frame is allocated and the stack pointer ( ESP ) is updated. The following assembly illustrates the compilation of a simple program:

_add_a_and_b:
   push   %ebx
   mov    %eax, [%esp+8]
   mov    %ebx, [%esp+12]
   add    %eax, %ebx
   pop    %ebx
   ret

_main:
   push   3
   push   2
   call   _add_a_and_b
   add    %esp, 8
   ret

Key instructions demonstrated:

push – Decrements ESP by 4 bytes and stores the operand on the stack.

call – Creates a new frame for the called function.

mov – Moves data between registers and memory.

add – Adds two operands, storing the result in the first.

pop – Retrieves the most recent stack value and increments ESP .

ret – Pops the return address and transfers control back to the caller.

Understanding these low‑level operations helps developers grasp how high‑level code is executed on the hardware.

Reference links

Introduction to reverse engineering and Assembly, by Youness Alaoui

x86 Assembly Guide, by University of Virginia Computer Science