Foundations — Memory addressing modes — immediate, register, direct, indirect, indexed

Before you can read LOAD R1, [[100]] and know it means "two trips to memory," you need a handful of tiny building blocks. This page builds every one of them from nothing, in the order they stack. This is a self-contained foundations page: every symbol used anywhere in this topic is defined right here, so you never have to look elsewhere for what a piece of notation means.

0. What is memory, really?

Figure s01 below draws this street. Look at the purple box: the label "box 100" sitting on top is the address; the big number 200 inside is the content. The whole topic is the game of telling these two apart, so fix this picture in your mind.

The two ideas you must keep separate forever:

• Address = the label on the box (e.g. 100).
• Content = what is stored inside box 100 (e.g. 200).

These are different numbers that live in the same world of numbers, which is exactly why beginners confuse them. The whole topic is a game of "is this number an address or a value?"

Related vault reading: Memory Hierarchy and Access Latency explains why reaching a mailbox is slow compared to holding a value in your hand.

1. The notation $M[\cdot ]$ — "open the box"

Picture it as a function: you feed it an address (a box number) and it hands you back the content (what was inside).

$M[\underset{\text{address, input}}{\underbrace{100}}]=\underset{\text{content, output}}{\underbrace{200}}$

2. Registers and $R[i]$ — the pockets in your coat

Figure s02 puts the two worlds side by side: the butter-coloured CPU on the left holds a few pocket-registers (R1, R2, R3); the lavender memory street on the right holds many boxes. Notice the coral double-arrow labelled "slow bus trip" — that trip is what register and immediate modes avoid entirely.

Note the deliberate symmetry with memory: $M[x]$ opens memory box $x$; $R[i]$ opens register $i$. Same "open the container" idea, two different containers — one slow (street), one fast (pocket).

3. An instruction and its fields — the command card

Figure s03 cuts one instruction into its coloured fields: the opcode (what to do), the mode tag (how to read the number), the destination register, and the operand number $A$. The take-away the arrows point at: the same bits 100 mean different things depending on the mode tag beside them.

Deeper mechanics live in Instruction Encoding & Opcodes and CPU Datapath and Control Unit (the hardware that actually reads and obeys the fields).

4. The Effective Address (EA) — the box we finally open

5. Addition inside an address — why indexed needs "+"

Figure s04 shows the array as a row of boxes from box 100 onward. Follow the mint arrow: it walks $R[i]=4$ boxes forward from the base, landing on the coral box — the effective address 104. The label stresses this walk is an addition, not a memory read, which is exactly why indexed costs only 1 access.

6. Pointers — a value that is secretly an address

How these feed the topic

Read it bottom-up: boxes and pockets give you the two "open" symbols; the instruction gives you $A$; addition and pointers give you the ways to transform $A$; all of it converges on the effective address, and every mode is just one way to compute it — for a read or a write alike.

Equipment checklist

Below, each line is a self-test in Question ::: Answer form: read the question, say your answer out loud, then check it against the text after the triple colon.

Parent topic: Memory addressing modes