0Pricing
Assembly Language & x86 Low-Level Systems Programming · Lesson

Arithmetic and Logic Operations

Learn to perform basic arithmetic (ADD, SUB, MUL, DIV) and logical operations (AND, OR, XOR, NOT) on data in registers and memory.

Arithmetic and Logic Operations is a free Assembly Language & x86 Low-Level Systems Programming lesson on CoddyKit — lesson 2 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.

Intro to Assembly Ops

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.

Addition: The ADD Instruction

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.

ADD in Action

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:

section .text
  global _start

_start:
  mov eax, 5   ; Load 5 into EAX
  add eax, 3   ; Add 3 to EAX (EAX becomes 8)

  ; Exit the program (Linux 32-bit syscall)
  mov eax, 1   ; sys_exit syscall number
  xor ebx, ebx ; Exit code 0
  int 0x80     ; Call kernel

Subtraction: The SUB Instruction

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.

SUB in Action

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

Run this code to see the subtraction:

section .text
  global _start

_start:
  mov eax, 10  ; Load 10 into EAX
  sub eax, 4   ; Subtract 4 from EAX (EAX becomes 6)

  ; Exit the program (Linux 32-bit syscall)
  mov eax, 1   ; sys_exit syscall number
  xor ebx, ebx ; Exit code 0
  int 0x80     ; Call kernel

Multiplication: MUL & IMUL

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!

Multiplication Example

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

section .text
  global _start

_start:
  mov eax, 5   ; Load 5 into EAX
  mov ebx, 6   ; Load 6 into EBX
  mul ebx      ; Multiply EAX by EBX. Result in EDX:EAX
               ; EAX will be 30, EDX will be 0

  ; Exit the program (Linux 32-bit syscall)
  mov eax, 1   ; sys_exit syscall number
  xor ebx, ebx ; Exit code 0
  int 0x80     ; Call kernel

Division: DIV & IDIV

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.

Division Example

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.

section .text
  global _start

_start:
  mov eax, 10  ; Load 10 into EAX (low part of dividend)
  mov edx, 0   ; Clear EDX (high part of dividend for 32-bit)
  mov ebx, 3   ; Load 3 into EBX (divisor)
  div ebx      ; Divide EDX:EAX by EBX.
               ; Quotient in EAX (3), Remainder in EDX (1)

  ; Exit the program (Linux 32-bit syscall)
  mov eax, 1   ; sys_exit syscall number
  xor ebx, ebx ; Exit code 0
  int 0x80     ; Call kernel

Bitwise Logic: AND, OR, XOR, NOT

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.

Quick Check: Bitwise Ops

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?

Recap: Fundamental Operations

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!

Frequently asked questions

Is the “Arithmetic and Logic Operations” lesson free?

Yes — the full text of “Arithmetic and Logic Operations” 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 “Arithmetic and Logic Operations”?

Learn to perform basic arithmetic (ADD, SUB, MUL, DIV) and logical operations (AND, OR, XOR, NOT) on data in registers and memory. 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 2 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Arithmetic and Logic Operations” 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

  1. Data Movement Instructions (MOV, PUSH, POP)
  2. Arithmetic and Logic Operations
  3. Conditional Jumps and Loops
  4. Bitwise and Shift Instructions
← Back to Assembly Language & x86 Low-Level Systems Programming