Instructions de déplacement des données (MOV, PUSH, POP)

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.

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:

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:

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:

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).

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

1. The ESP (Stack Pointer) register is decremented by 4 (for 32-bit values).
2. 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).

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:

1. The value at the memory address pointed to by ESP is retrieved.
2. 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.

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.

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?

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!