Machine Language Basics

Introduction

Machine language is the only language a processor truly understands — raw binary patterns that directly control hardware operations. Every other language (Assembly, C, Python) must eventually be translated into machine language before the CPU can execute it. Understanding machine language gives you the deepest possible insight into how software meets hardware.

What is Machine Language?

Machine language consists of binary instruction words — fixed patterns of 0s and 1s that encode:

• What operation to perform (opcode)
• What data to use (operand specifiers)
• Where to store results (destination)

Each instruction is just a number. When the CPU fetches the value 0x01284820 from memory, it interprets it as "ADD register 9, register 9, register 8" (in MIPS). There's nothing inherently "instruction-like" about this bit pattern — it's the CPU's decode logic that gives it meaning.

Machine Language vs Assembly Language

Assembly language is just human-readable machine language — a one-to-one mapping where each assembly mnemonic corresponds to exactly one machine instruction. An assembler converts assembly to machine code.

Encoding Example: MIPS R-Type

The MIPS instruction ADD $t1, $t2, $t3 (add registers t2 and t3, put result in t1):

This 32-bit number IS the instruction. That's what lives in memory and what the CPU fetches.

Encoding Example: MIPS I-Type

The instruction LW $t0, 12($s0) (load word from address s0+12 into t0):

How the CPU Interprets Machine Code

When the CPU fetches an instruction:

1. Read the opcode field — determines instruction type and format
2. Identify the format — R-type, I-type, or J-type (in MIPS)
3. Extract operand fields — register numbers, immediate values, addresses
4. Generate control signals — the opcode maps to specific ALU operations, register enables, etc.

Program in Machine Language

A simple program to add 5 + 3:

To the CPU, this is just three 32-bit numbers stored at consecutive memory locations. It fetches each one in sequence, decodes it, and executes.

Why We Don't Program in Machine Language

Writing 0x014B4820 instead of ADD $t1, $t2, $t3 is:

• Error-prone (one wrong bit = completely different instruction)
• Unreadable (can't easily see what a program does)
• Tedious (must manually calculate addresses for branches)
• Platform-specific (different binary encoding for each CPU architecture)

That's why assembly language exists — same information, human-readable form.

Endianness: Byte Order in Memory

A 32-bit instruction stored in memory can be arranged two ways:

Big-Endian (most significant byte at lowest address):

Little-Endian (least significant byte at lowest address):

x86 is little-endian; many RISC architectures are big-endian (or configurable).

Key Takeaways

1. Machine language is the binary encoding that the CPU directly executes
2. Each instruction is a fixed-size binary number with fields for opcode and operands
3. Assembly language is a human-readable one-to-one mapping of machine code
4. The CPU's decode logic interprets bit patterns as operations and operand specifiers
5. Different ISAs have completely different binary encodings (x86 ≠ ARM ≠ MIPS)
6. Understanding machine encoding helps with debugging, reverse engineering, and hardware design
7. Endianness determines byte order when multi-byte values are stored in memory