Addressing modes: Visual walkthrough — Hardware deep dive

We only need three ideas, and we will draw each before using it:

a memory cell (a numbered box that holds a number),
a register (a super-fast box inside the CPU),
an instruction (a strip of bits split into a what-to-do part and a where part).

Everything below is just: how do we turn the "where" part into a real box?

Step 1 — What memory and a register even are

WHAT: we drew memory as numbered boxes and a register as one box. WHY: every addressing mode is a sentence like "start from $A$ , maybe add $(R)$ , maybe follow the arrow." If you can see the boxes and arrows, the formula writes itself. PICTURE: below, addresses run down the left; contents sit inside; the register R1 floats to the side holding $400$ .

We use the exact numbers from the parent note's table so every example lands on a real box: $M [100] = 500$ , $M [400] = 700$ , $M [500] = 800$ , $M [403] = 900$ , and $(R 1) = 400$ , $(R 2) = 3$ , $P C = 200$ .

Step 2 — The goal: EA is a function, draw its inputs

WHAT: we named the machine $f$ and its three possible inputs. WHY: every mode is just a different wiring of these same three inputs into one output address. From now on, each mode's formula below is literally " $f$ with some inputs ignored" — Direct is $f = A$ , Register-indirect is $f = (R)$ , Displacement is $f = A + (R)$ , PC-relative is $f = P C + A$ . Watch $f$ reappear in every step. PICTURE: three clue-arrows ( $A$ , $(R)$ , $P C$ ) feed a funnel labelled $f$ ; out drops a single address, which points at one memory box.

Step 3 — The zero-arrow modes: Immediate & Register

WHAT: two modes that never open a memory box — here $f$ is not even called, because no address is needed. WHY start here? Because they are the base case: they use an input directly with zero arrows to follow. Every later mode is "these, but then take one or more steps into memory." PICTURE: on the left the instruction's $A$ box is the value (a self-loop, no travel). On the right an arrow reaches into the CPU register and stops there.

Step 4 — One arrow: Direct mode

WHAT: we treat the instruction's $A$ as an address and open exactly one box — the funnel $f$ passes $A$ straight through. WHY this rule? It's the simplest way to point at a specific location. Cost: $A$ must be wide enough to name any box in memory. PICTURE: LOAD 100. One yellow arrow leaves $A = 100$ , lands on box $100$ , and we read $500$ .

$= 100 E A = 100 A \Rightarrow operand = M [100] = 500$

Step 5 — One arrow via a register: Register-indirect

WHAT: the register's contents are the effective address; $f$ ignores $A$ and $P C$ and returns $(R)$ . WHY a distinct mode? This is how you follow a pointer that lives in a register (e.g. a this-pointer, or the top of a stack). It is the cheapest way to reach data whose address is only known at run time — one arrow, not two. PICTURE: LOAD (R1), $(R 1) = 400$ . A pink arrow leaves register R1, lands directly on box $400$ , and we read $700$ .

$E A = (R 1) = 400 \Rightarrow operand = M [400] = 700$

Step 6 — Two arrows: Indirect mode (follow a pointer in memory)

WHAT: we opened box $A$ , found an address inside, then opened that box. WHY need a second arrow? So the instruction can point at data whose pointer lives in memory — following linked lists, chasing pointers. Price: an extra memory read every time. PICTURE: LOAD (100). Arrow ① hits box $100$ and finds $500$ ; arrow ② hops from there to box $500$ and reads $800$ .

$E A = M [100] = 500 \Rightarrow operand = M [500] = 800$

Step 7 — Adding two clues: Displacement (the workhorse)

WHAT: we added a register's contents to the instruction's constant before opening a box — $f$ now uses both $A$ and $(R)$ . WHY add, not just use one? Because arrays and structs live at a run-time base $(R)$ , but the element you want (offset $A$ ) is a fixed, small number known at compile time. Addition marries the run-time start to the compile-time step — that's why array[3] is cheap. PICTURE: LOAD 3(R1), $(R 1) = 400$ . Draw the base arrow to $400$ , then step $+ 3$ down the boxes to $403$ , and read $900$ .

$E A = 3 A + 400 (R 1) = 403 \Rightarrow M [403] = 900$

Step 8 — Using the PC as the base: PC-relative

WHAT: we used the PC itself as the base and added a signed offset; $f$ here uses $P C$ and $A$ . WHY offsets, not absolute targets? Because the program might be loaded anywhere in memory. "Jump forward 6" stays correct no matter where the code sits; "jump to 206" would break if loaded elsewhere. This is position independence. PICTURE: BRANCH +6. A yellow arrow of length $+ 6$ from the PC-reference marker lands on the target box.

$E A = 200 P C_{next} + + 6 A = 206 (signed immediate A)$

Step 9 — Modes with a side effect: Auto-increment / decrement

WHAT: register-indirect (Step 5), plus the register silently advances (or retreats) by $d$ . WHY bake stepping in? Streaming through an array or pushing/popping a stack needs "read, then move pointer" every iteration. Folding the move into the access removes an entire instruction from the loop — that's while(*p++). PICTURE: LOAD (R1)+, $(R 1) = 400$ , $d = 1$ . Read box $400$ → $700$ ; then the R1 label slides from $400$ to $401$ (dashed arrow), ready for the next read.

$Step 1: E A = (R 1) = 400, M [400] = 700 Step 2: R 1 \leftarrow 400 + 1 = 401$

The one-picture summary

Everything above is one funnel $f$ fed by ${A, (R), P C}$ , followed by zero, one, or two arrows into memory. Read the modes as a family by how many arrows they follow:

Recall Feynman: the whole walkthrough in plain words

Memory is a street of numbered houses; a register is a tiny house you keep in your pocket. An instruction hands you a scrap of paper with a number $A$ on it. The addressing mode is just what the scrap means: "The gold is this number" (immediate — no walking). "It's in your pocket house" (register — no walking). "Go to house $A$ " (direct — one walk). "Your pocket note IS a house number — go straight there" (register-indirect — one walk). "House $A$ has a note with another address; go there" (memory-indirect — two walks). "Start at your pocket-house address, walk $A$ more doors" (displacement — one walk, and this is the one you'll use constantly for arrays). "Walk $A$ doors from where you're standing right now — measured from the next step you were about to take" (PC-relative — works no matter where the street starts). "Read your pocket-house door, then automatically nudge your pocket note to the next door" (auto-increment — perfect for reading a whole array). Count the walks into the street and you know the cost. That's the entire subject.

Recall Quick self-check

LOAD (100) with $M [100] = 500$ , $M [500] = 800$ — operand? ::: $800$ (memory-indirect: $E A = M [100] = 500$ , then $M [500] = 800$ ) LOAD (R1) with $(R 1) = 400$ , $M [400] = 700$ — operand? ::: $700$ (register-indirect: $E A = (R 1) = 400$ , one access) LOAD 3(R1) with $(R 1) = 400$ — EA? ::: $403$ BRANCH +6 measured from $P C_{next} = 200$ — target? ::: $206$ Displacement with $A = 0$ becomes which mode? ::: Register-indirect ( $E A = (R)$ )

See also: Addressing modes · Instruction Format · Registers and Register File · Memory Hierarchy · Pointers and Arrays · Stack and Subroutines · RISC vs CISC