Why Learning Assembly Is Essential: A Beginner’s Guide to CPU, Registers, and Memory

What Is Assembly Language?

High‑level languages are designed for humans, but computers only understand binary machine code. Assembly language provides a readable textual representation of those binary instructions, allowing programmers to see exactly what the CPU executes.

Historical Background

Early computers required programmers to input raw binary via switches or punched tape. To improve readability, engineers first used octal, then switched to mnemonic text (e.g., ADD) and labels, creating the process known as assembling and the tool called an assembler . Modern assembly languages are standardized as assembly language (often abbreviated asm).

Registers

Registers are small, fast storage locations inside the CPU used for the most frequently accessed data. They are addressed by name rather than by memory address, making them the CPU’s “zero‑level cache.”

EAX

EBX

ECX

EDX

EDI

ESI

EBP

ESP (holds the current stack pointer)

Most early x86 CPUs had only these eight registers; modern CPUs have many more, but the original names remain for compatibility.

Memory Model: Heap

The operating system allocates a contiguous block of memory for a program, for example from 0x1000 to 0x8000. Dynamic allocations (e.g., malloc) carve out sub‑ranges from this block, growing upward from the start address. This region is called the Heap and must be released manually or by a garbage collector.

Memory Model: Stack

The stack stores temporary data for function calls. Each function call creates a frame that holds its local variables. Frames are pushed onto the stack ("push") and removed when the function returns ("pop"). The stack grows downward from high memory addresses toward low addresses.

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

When main starts, a frame is allocated; variables a and b reside in that frame. After main finishes, the frame is reclaimed.

CPU Instructions – Example Walkthrough

Consider the following C program:

int add_a_and_b(int a, int b) {
   return a + b;
}

int main() {
   return add_a_and_b(2, 3);
}

Compiling with gcc -S example.c produces example.s, an assembly file. After simplification, the relevant portion looks like:

_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

Each line corresponds to a single CPU operation. Below is a detailed explanation of the most important instructions:

push

The push instruction decrements the stack pointer ( ESP) by the operand size (4 bytes for an int) and stores the operand at the new address. In the example, push 3 and push 2 place the arguments on the stack for the called function.

call

call _add_a_and_b

saves the return address on the stack and jumps to the label _add_a_and_b, creating a new frame for that function.

mov

mov %eax, [%esp+8]

reads the value at ESP+8 (the first argument, 2) and stores it in register EAX. Similarly, mov %ebx, [%esp+12] loads the second argument (3) into EBX.

add

add %eax, %ebx

adds the contents of EBX to EAX, leaving the result (5) in EAX.

pop

pop %ebx

restores the original value of EBX from the stack and increments ESP by 4 bytes.

ret

ret

pops the return address from the stack and jumps back to the caller, effectively discarding the current frame.

After _add_a_and_b returns, the caller _main executes add %esp, 8 to clean up the two argument slots, then ret ends the program.

References

Introduction to reverse engineering and Assembly, by Youness Alaoui

x86 Assembly Guide, by University of Virginia Computer Science