Opérations arithmétiques et logiques

Welcome to the world of x86 Assembly's core operations! Today, we'll learn how CPUs perform basic math and logic.

These instructions are fundamental. They allow your programs to calculate values, make decisions, and manipulate data at the lowest level.

The ADD instruction is used to add two numbers. It takes two operands: a destination and a source.

• Syntax: ADD destination, source
• The source value is added to the destination value.
• The result is stored back in the destination operand.
• Operands can be registers, memory locations, or immediate values (constants).

For example, ADD EAX, EBX adds the value in EBX to EAX, storing the sum in EAX.

Let's see ADD in a simple program. We'll add 3 to 5, storing the result in the EAX register.

Try running this example:

The SUB instruction is the opposite of ADD. It subtracts the source operand from the destination operand.

• Syntax: SUB destination, source
• The source value is subtracted from the destination value.
• The result is stored back in the destination operand.

Like ADD, SUB can use registers, memory, or immediate values as operands. It's essential for basic arithmetic and comparisons.

Here's SUB at work. We'll load 10 into EAX and then subtract 4 from it.

Run this code to see the subtraction:

Multiplication in x86 Assembly uses MUL for unsigned numbers and IMUL for signed numbers.

• MUL and IMUL often use the AX, EAX, or RAX register implicitly as one operand.
• For 32-bit multiplication, if you multiply a value in EAX by another register (e.g., EBX), the 64-bit result is stored across two registers: the lower 32 bits in EAX and the higher 32 bits in EDX.

Always remember to consider the size of your operands and the potential size of the result!

Let's multiply 5 by 6 using MUL. The result will be 30.

After execution, EAX will hold the lower part of the result, and EDX will hold the higher part (which will be 0 in this case).

Division is handled by DIV (unsigned) and IDIV (signed). These instructions are a bit more complex.

• For 32-bit division, the dividend (number to be divided) is expected to be in EDX:EAX (EDX holds the high 32 bits, EAX holds the low 32 bits).
• The divisor is specified as an operand (e.g., a register or memory location).
• After division, the quotient (result) is stored in EAX, and the remainder is stored in EDX.

Always ensure EDX is correctly set (often cleared to 0) before an unsigned division if your dividend fits in EAX.

Let's divide 10 by 3. We expect a quotient of 3 and a remainder of 1.

Observe how EDX is cleared before the division, as our dividend (10) fits entirely within EAX.

Beyond arithmetic, assembly excels at bitwise operations. These instructions manipulate individual bits within a number.

• AND: Sets a bit if both corresponding bits are 1. Useful for masking bits.
• OR: Sets a bit if at least one corresponding bit is 1. Useful for setting specific bits.
• XOR: Sets a bit if corresponding bits are different. Useful for toggling bits or quickly clearing a register (e.g., XOR EAX, EAX).
• NOT: Inverts all bits (flips 0s to 1s, and 1s to 0s). This is a unary operation (takes one operand).

These are crucial for low-level control, flags, and data manipulation.

Consider the following assembly snippet:

mov al, 0b11001010
and al, 0b00001111

What will be the final value stored in the AL register after these instructions execute?

Great job! You've learned the essential arithmetic and bitwise logic operations in x86 Assembly.

• Arithmetic: ADD, SUB, MUL/IMUL, DIV/IDIV perform calculations.
• Logic: AND, OR, XOR, NOT manipulate individual bits for masking, setting, toggling, and inverting.

These instructions are the building blocks for complex programs, enabling your CPU to process data and make decisions effectively. Keep practicing!