Assembly Language & x86 Low-Level Systems Programming · Lesson

Data Movement Instructions (MOV, PUSH, POP)

Master instructions for moving data between registers, memory, and the stack, including MOV, PUSH, POP, and LEA.

Data Movement Instructions (MOV, PUSH, POP) is a free Assembly Language & x86 Low-Level Systems Programming lesson on CoddyKit — lesson 1 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Assembly Language & x86 Low-Level Systems Programming learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

Data on the Move

In assembly language, programs constantly move data around. This data lives in different places: inside the CPU's registers or in memory.

Understanding how to move data is fundamental. It's like learning to pick up and place objects before you can build anything complex.

Registers: Fast, small storage directly inside the CPU.
Memory: Slower, larger storage outside the CPU (RAM).
Stack: A special area in memory used for temporary storage and function calls.

Moving Data with MOV

The MOV instruction is your primary tool for copying data. It stands for "move," but it actually copies the source to the destination, leaving the source unchanged.

Its basic form is MOV destination, source. The destination can be a register or a memory location, and the source can be an immediate value, a register, or a memory location.

Here's how to put a number directly into a register:

section .text
    global _start

_start:
    mov eax, 123    ; Copy the immediate value 123 into the EAX register
    mov ebx, 456    ; Copy 456 into EBX

    ; Exit system call
    mov eax, 1
    xor ebx, ebx
    int 0x80

Register to Register Moves

You can also copy data from one register to another. This is a very common operation for temporary storage or preparing data for other operations.

When you move data between registers, the original register's value remains, and the destination register gets a copy.

Consider this example:

section .text
    global _start

_start:
    mov eax, 10     ; EAX = 10
    mov ebx, eax    ; EBX gets a copy of EAX (EBX = 10), EAX is still 10
    mov ecx, 20     ; ECX = 20
    mov edx, ecx    ; EDX gets a copy of ECX (EDX = 20), ECX is still 20

    ; Exit system call
    mov eax, 1
    xor ebx, ebx
    int 0x80

Storing and Loading from Memory

Moving data between registers and memory is crucial for working with variables. Memory addresses are often enclosed in square brackets [].

To store a register's value into a memory location, you use MOV [memory_address], register. To load a value from memory into a register, it's MOV register, [memory_address].

Let's define a variable in memory and interact with it:

section .data
    my_var dd 50    ; Define a double-word (4-byte) variable 'my_var' and initialize it to 50

section .text
    global _start

_start:
    mov eax, [my_var] ; Load the value from 'my_var' (50) into EAX
    mov ebx, 100      ; EBX = 100
    mov [my_var], ebx ; Store the value of EBX (100) into 'my_var'.
                      ; Now 'my_var' holds 100, EAX still holds 50.

    ; Exit system call
    mov eax, 1
    xor ebx, ebx
    int 0x80

Understanding the Stack

The stack is a crucial area of memory used for temporary storage. It operates on a "Last-In, First-Out" (LIFO) principle, like a stack of plates.

When you "push" something onto the stack, it goes on top.
When you "pop" something off, you always get the item that was most recently pushed.

The Stack Pointer (ESP) register always points to the "top" of the stack (the last item pushed).

Adding Data with PUSH

The PUSH instruction adds data to the top of the stack. When you PUSH a value:

The ESP (Stack Pointer) register is decremented by 4 (for 32-bit values).
The value is then stored at the new memory address pointed to by ESP.

This means the stack grows downwards in memory (towards lower addresses).

section .text
    global _start

_start:
    mov eax, 10     ; EAX = 10
    mov ebx, 20     ; EBX = 20

    push eax        ; Push EAX's value (10) onto the stack
    push ebx        ; Push EBX's value (20) onto the stack (now on top of 10)
    push 30         ; Push the immediate value 30 onto the stack (now on top of 20)

    ; At this point, the stack contains 30, then 20, then 10 (from top to bottom).

    ; Exit system call
    mov eax, 1
    xor ebx, ebx
    int 0x80

Retrieving Data with POP

The POP instruction removes data from the top of the stack and places it into a specified destination (usually a register).

When you POP a value:

The value at the memory address pointed to by ESP is retrieved.
The ESP (Stack Pointer) register is then incremented by 4.

POP reverses the effect of PUSH, ensuring you get back the last item you pushed.

section .text
    global _start

_start:
    mov eax, 10
    mov ebx, 20

    push eax        ; Stack: [10]
    push ebx        ; Stack: [20, 10]

    pop ecx         ; ECX = 20. Stack: [10]
    pop edx         ; EDX = 10. Stack: []

    ; EAX = 10, EBX = 20, ECX = 20, EDX = 10.
    ; Notice ECX got EBX's original value because EBX was pushed last.

    ; Exit system call
    mov eax, 1
    xor ebx, ebx
    int 0x80

LEA: Getting an Address

The LEA instruction (Load Effective Address) is a bit special. Unlike MOV with brackets, LEA doesn't actually load the content of a memory location.

Instead, LEA calculates the address of the source operand and stores that address into the destination register.

It's super useful for working with pointers or calculating array offsets without touching memory data.

section .data
    my_array dd 10, 20, 30 ; An array of double-words

section .text
    global _start

_start:
    mov ebx, 0      ; EBX will be our index (0 for first element)
    mov ecx, 4      ; ECX will be our scale (4 bytes per double-word)

    lea eax, [my_array + ebx*ecx] ; Calculate address of my_array[0] and put it in EAX
                                  ; EAX now holds the memory address of 'my_array'

    ; If we used MOV EAX, [my_array + ebx*ecx], EAX would hold the value 10.
    ; With LEA, EAX holds the *address* where 10 is stored.

    ; Exit system call
    mov eax, 1
    xor ebx, ebx
    int 0x80

Data Movement Challenge

Consider the following x86 assembly code snippet. Assume EAX and EBX initially contain 0.

mov eax, 5
push eax
mov ebx, 10
push ebx
pop eax
pop ebx

What will be the final values in the EAX and EBX registers?

Summary of Data Movement

Great job! You've learned the fundamental instructions for moving data in x86 assembly:

MOV: Copies data between registers, memory, and immediate values. It's your workhorse for assigning and loading data.
PUSH & POP: Manage data on the stack, following a LIFO principle. Essential for temporary storage and procedure calls.
LEA: Calculates and loads an address into a register, without touching the data at that address. Crucial for pointer arithmetic.

These instructions are the building blocks for almost every assembly program. Next, we'll explore how to perform arithmetic and logical operations on this data!

Frequently asked questions

Is the “Data Movement Instructions (MOV, PUSH, POP)” lesson free?

Yes — the full text of “Data Movement Instructions (MOV, PUSH, POP)” is free to read here on the web, and the Assembly Language & x86 Low-Level Systems Programming course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Assembly Language & x86 Low-Level Systems Programming course, upgrade to CoddyKit PRO.

What will I learn in “Data Movement Instructions (MOV, PUSH, POP)”?

Master instructions for moving data between registers, memory, and the stack, including MOV, PUSH, POP, and LEA. You practise Assembly Language & x86 Low-Level Systems Programming with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Assembly Language & x86 Low-Level Systems Programming?

No prior experience is required. Assembly Language & x86 Low-Level Systems Programming on CoddyKit is structured for beginners through advanced learners; this is — lesson 1 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Data Movement Instructions (MOV, PUSH, POP)” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Assembly Language & x86 Low-Level Systems Programming lesson?

Yes. Every Assembly Language & x86 Low-Level Systems Programming lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

Data Movement Instructions (MOV, PUSH, POP)
Arithmetic and Logic Operations
Conditional Jumps and Loops
Bitwise and Shift Instructions

← Back to Assembly Language & x86 Low-Level Systems Programming