Instructions Are the CPU's Language

Instructions Are the CPU's Language

Think about a vending machine. It's a computer of sorts—it has buttons, logic, and memory. But it can only do a handful of things: accept money, dispense items, make change. Now think about your smartphone. It can do almost anything. Yet under the hood, the chip inside your phone also only knows how to do a limited set of operations—just a somewhat larger limited set.

That finite list of operations is called the Instruction Set Architecture, or ISA. Every command a CPU can understand is baked into the chip design from the very beginning. Every Python loop, every JavaScript function, every line of C code you've ever written eventually gets translated into some combination of these instructions before the CPU will touch it.

Core Concepts

The ISA Is a Contract

Think of the ISA as a legal contract between chip designers and software developers: "Here's the list of commands my chip understands. If your software translates itself into these commands, it'll run on my hardware."

The two dominant ISAs today couldn't be more different in philosophy:

┌──────────────────────────────────────────────────────────────┐
│                   x86-64  vs  ARM (AArch64)                  │
├────────────────┬─────────────────────┬────────────────────── ┤
│ Feature        │ x86-64              │ ARM (AArch64)         │
├────────────────┼─────────────────────┼───────────────────────┤
│ Philosophy     │ CISC (complex)      │ RISC (reduced)        │
│ Instruction    │ Variable (1-15 B)   │ Fixed (4 bytes)       │
│ Registers      │ 16 general purpose  │ 31 general purpose    │
│ Memory ops     │ Direct in most instr│ Load/store only       │
│ Power usage    │ Higher              │ Lower                 │
│ Common use     │ PCs, servers        │ Phones, Apple Silicon │
└────────────────┴─────────────────────┴───────────────────────┘

x86's "complex" instructions can do a lot in one shot—like adding a number directly from memory to another memory location. ARM's "reduced" instructions require you to load data into a register first, then operate on it. ARM's regularity makes pipeline design simpler and power consumption much lower, which is exactly why your phone runs an ARM chip and not an x86 one.

The Four Families of Instructions

No matter how large or exotic an instruction set gets, almost everything falls into four families:

1. Data Movement (MOV) — Shuffling data around

MOV  RAX, 42        ; Load the number 42 into register RAX
MOV  [RBX], RAX     ; Write the value in RAX to the memory address in RBX

2. Arithmetic and Logic (ADD/SUB/AND/OR) — Doing math

ADD  RAX, RBX       ; RAX = RAX + RBX
SUB  RCX, 1         ; RCX = RCX - 1
AND  RAX, 0xFF      ; Keep only the lowest 8 bits of RAX

3. Compare and Jump (CMP/JMP) — Controlling flow

CMP  RAX, 0         ; Compare RAX to 0 (sets flags, no output)
JE   done           ; Jump to "done" if they were Equal
JMP  loop_start     ; Unconditional jump to loop_start

4. Call and Return (CALL/RET) — Function calls

CALL my_function    ; Call a function (saves return address first)
RET                 ; Return from function

The Three-Layer Tower

Between the code you write and the raw bits the CPU executes, there are multiple layers of translation:

┌──────────────────────────────────────┐
│       High-Level Language (C/Python) │  ← You write this
│   int sum = a + b;                   │
└──────────────────┬───────────────────┘
                   │  compiler / interpreter
                   ▼
┌──────────────────────────────────────┐
│         Assembly Language            │  ← Humans can read this
│   ADD RAX, RBX                       │
└──────────────────┬───────────────────┘
                   │  assembler
                   ▼
┌──────────────────────────────────────┐
│    Machine Code (binary)             │  ← CPU executes this
│   01001000 00000001 11000011         │
└──────────────────────────────────────┘

What does a simple C function look like once compiled? Here's a concrete example:

// C: add two integers
int add(int a, int b) {
    return a + b;
}

And here's the x86-64 assembly GCC produces for it (with optimizations enabled):

add:
    ; By calling convention: first arg in EDI, second in ESI
    mov    eax, edi     ; put 'a' into EAX
    add    eax, esi     ; EAX = EAX + b
    ret                 ; return (return value lives in EAX)

Three lines. Your entire return a + b expression maps to exactly three instructions. That's the tower in action.

Try It Yourself

On Linux or macOS, you can watch C code become assembly in real time:

# Compile to assembly (-O0 = no optimization, easier to read)
gcc -O0 -S -o add.s add.c

# Read the output
cat add.s

If you prefer Python, the dis module shows you CPython's own internal instruction set:

import dis

def add(a, b):
    return a + b

dis.dis(add)
# Output:
#   LOAD_FAST    0 (a)
#   LOAD_FAST    1 (b)
#   BINARY_OP    0 (+)
#   RETURN_VALUE

This isn't x86 machine code—it's CPython's virtual machine instructions. Python has its own mini-ISA that runs inside a software interpreter.

For a visual, browser-based experience, open Compiler Explorer at godbolt.org. Paste any C, C++, or Rust code and instantly see the assembly output from dozens of compilers and optimization levels side by side.

🔬 Going Deeper

Why do CISC and RISC still coexist?

In theory, RISC's simplicity should have won decades ago. But x86 carries an enormous legacy—billions of programs compiled for it. Intel and AMD's solution was clever: internally, modern x86 chips secretly decompose complex x86 instructions into simpler micro-operations (micro-ops) that look a lot like RISC instructions. The chip presents an x86 face to the world while internally running a RISC-style pipeline. CISC on the outside, RISC on the inside.

Instructions go way beyond basic math

Modern ISAs include massive extension families. x86's SSE and AVX instructions let you add eight floating-point numbers simultaneously with a single instruction—this is called SIMD (Single Instruction, Multiple Data). Your video codec, neural network inference, and image processing pipelines all rely heavily on SIMD. ARM's equivalents are called NEON and SVE. Without SIMD, running a large language model locally would be orders of magnitude slower.

Where to go next

• Computer Systems: A Programmer's Perspective (CSAPP) by Bryant & O'Hallaron — Chapter 3 is the definitive introduction to x86-64 assembly for programmers. Highly recommended.
• Computer Organization and Design by Patterson & Hennessy — Uses the open-source RISC-V ISA to teach instruction set design from first principles.
• godbolt.org (Compiler Explorer) — Anytime you wonder "what does my code actually become?", this is the tool to open first.