Visual walkthrough — x86 architecture overview

This is the central result of real-mode addressing, the fossil that shaped the whole ISA.

---

Step 1 — What is a bit, a number, and an "address"?

WHAT: We line up boxes and count how many different numbers they can name.

WHY: Before we can ask "how big an address can we make," we must know exactly what a group of boxes can count to. Everything later is just counting.

PICTURE: Below, each box is one bit. A row of $n$ boxes can hold $2^n$ different patterns, so it can name the byte-numbers $0$ up to $2^n-1$.

$\underset{\text{each box: 2 choices}}{\underbrace{2}}{}^{\underset{\text{number of boxes}}{\underbrace{n}}}=\underset{\text{how many addresses}}{\underbrace{2^n}}$

• $2$ — every single box is either $0$ or $1$, so two possibilities per box.
• $n$ — the count of boxes; each new box doubles the reach.
• $2^n$ — the grand total of distinct byte-numbers those boxes can point to.

---

Step 2 — A 16-bit register can only reach 64 KB

WHAT: We compute the reach of one 16-bit register.

WHY: This is the wall Intel hit. It sets up the entire need for a trick — you cannot escape it with a single 16-bit number.

$2^{16}=65536=64\text{ KB}$

• $2^{16}$ — sixteen boxes, each doubling, from Step 1.
• $65536$ — the exact count of addresses reachable.
• $64\text{ KB}$ — the same number in human units ($1\text{ KB}=1024$).

PICTURE: A 16-bit register is a short ruler that only reaches to byte $65535$. Intel wanted a ruler reaching $1048576$ bytes ($1$ MB $=2^{20}$). The gap between the two rulers is the whole story.

---

Step 3 — Why shifting left is the same as multiplying

WHAT: We show that sliding a binary number left by $k$ boxes multiplies it by $2^k$.

WHY: In decimal, writing a $0$ on the right of $7$ gives $70$ — a $\times 10$. In binary, adding a $0$ on the right is a $\times 2$. This is the bridge between "$\ll 4$" (what the hardware does) and "$\times 16$" (what the formula says).

$\text{value}\ll k=\text{value}\times 2^k$

• $\ll k$ — physically move every bit $k$ boxes to the left, filling zeros on the right.
• $2^k$ — the multiplier this sliding produces.
• For us $k=4$, and $2^4=16$, so $\ll 4$ is $\times 16$.

PICTURE: Watch the same bits ride $4$ boxes to the left; four fresh zero-boxes appear on the right. The number got $16\times$ bigger without a single multiplication happening — just wires.

---

Step 4 — Stretch the segment across the top 20 bits

WHAT: Take the 16-bit segment, shift it $\ll 4$, and lay the result over a 20-bit ruler.

WHY: Step 2 said we were 4 bits short at the top; Step 3 gave us the tool. Now we actually place the segment into bits $4$ through $19$, leaving the bottom 4 bits empty (all zero).

$\text{Segment}\ll 4=\text{Segment}\times 16$

• The segment's 16 bits now occupy address-positions $4\dots 19$.
• Positions $0\dots 3$ are zero — a hole waiting to be filled.

PICTURE: The red band is the shifted segment sitting high on the 20-bit ruler. Notice the four empty boxes at the bottom — that emptiness is exactly the room the offset will fill in Step 5.

---

Step 5 — Drop the offset into the low bits

WHAT: Add the 16-bit offset to the shifted segment.

WHY: The segment picked the neighbourhood; the offset picks the exact house. We add here (not shift) because we are combining two positioned quantities into one final number — the hardware address adder does this in one pass.

PICTURE: Segment (red, high) and offset (black, low) overlap in the middle and sum to one 20-bit address. That overlap is why $16+16$ bits give only $20$, not $32$: the two numbers share the middle bits.

---

Step 6 — Worked number: watch it land

WHAT: Run the parent note's example through our machine.

WHY: To prove the pictures produce the exact hex the hardware would.

Segment $=\text{0x1000}$, Offset $=\text{0x0020}$:

$(\underset{\text{segment}}{\underbrace{\text{0x1000}}}\times 16)+\underset{\text{offset}}{\underbrace{\text{0x0020}}}=\underset{\ll 4\text{ result}}{\underbrace{\text{0x10000}}}+\text{0x0020}=\text{0x10020}$

• $\text{0x1000}\times 16=\text{0x10000}$ — the shift appends one hex zero (hex digit = 4 bits, so $\ll 4$ = one hex place).
• $+\text{0x0020}$ — the offset fills the freshly opened low nibble.

---

Step 7 — The edge cases you must never be surprised by

Every case, every quirk — the contract demands we show them all.

PICTURE: The number line of reachable addresses, with the four cases pinned on it — zero, low, aliased, and the over-the-edge wrap.

---

The one-picture summary

Two 16-bit numbers → one shift → one add → a 20-bit address. That is the whole machine, and the whole reason x86 carried segment registers for 40 years (mostly disabled in contrast to cleaner designs, and unlike the fixed-width worlds of RISC).

Recall Feynman retelling — say it like a story

Imagine your house number has to fit in a tiny 16-digit slot, but your city grew and now needs 20-digit house numbers. Trick: use two small numbers. First number (the segment) says which block of the city — but we slide it up four places so it means "block", not "house". That sliding-left-by-four is secretly a multiply-by-sixteen, done by wires, not math. The second number (the offset) is the exact house on that block, and it drops neatly into the four empty slots the slide just opened. Add the two and you have your full 20-digit address. And because the block-number and house-number share some middle digits, two different (block, house) pairs can point at the exact same house — that overlap is real-mode aliasing. Push both numbers to their max and you spill past the edge of the city — the old chip just wrapped you back to the start. That wrap is a fossil you can still poke at today.

---

Recall

Recall Walkthrough checkpoints

1. How many addresses does an $n$-box register reach? ::: $2^n$.
2. How many bits short is a 16-bit register of a 1 MB space? ::: 4 bits ($20-16$).
3. What operation replaces "$\times 16$" in hardware? ::: Left shift by 4 ($\ll 4$).
4. Physical address of segment $\text{0x0400}$, offset $\text{0x0010}$? ::: $\text{0x04000}+\text{0x0010}=\text{0x04010}$.
5. Why can two (segment, offset) pairs name one byte? ::: Their ranges overlap in the middle bits (aliasing).