Addressing Modes

An addressing mode says how to find the operand from the bits in the instruction. The address of the operand in memory is the effective address (EA).

The modes

Two details that GATE likes:

• In PC-relative mode, the PC usually already points to the next instruction when the address is computed, so the displacement is measured from the address of the instruction after the branch.
• Indirect mode costs an extra memory access, which is why RISC machines leave it out and use register indirect instead.

Working through an example

Registers: R1 = 300, R2 = 4. Memory: M[200] = 500, M[300] = 700, M[304] = 750, M[500] = 900, M[204] = 650. The instruction's address field is A = 200.

memory = {200: 500, 204: 650, 300: 700, 304: 750, 500: 900}
R = {"R1": 300, "R2": 4}
A = 200

modes = {
    "immediate":         (None,             lambda: A),
    "direct":            (A,                lambda: memory[A]),
    "indirect":          (memory[A],        lambda: memory[memory[A]]),
    "register indirect": (R["R1"],          lambda: memory[R["R1"]]),
    "indexed (A + R2)":  (A + R["R2"],      lambda: memory[A + R["R2"]]),
    "base (R1 + 4)":     (R["R1"] + 4,      lambda: memory[R["R1"] + 4]),
}
for name, (ea, operand) in modes.items():
    print(f"{name:18} EA = {'-' if ea is None else ea:<4}  operand = {operand()}")

immediate          EA = -     operand = 200
direct             EA = 200   operand = 500
indirect           EA = 500   operand = 900
register indirect  EA = 300   operand = 700
indexed (A + R2)   EA = 204   operand = 650
base (R1 + 4)      EA = 304   operand = 750

Counting memory references

Questions often ask how many memory accesses an instruction makes in total. Count:

1. the instruction fetch (1 per word of instruction),
2. any accesses to compute the address (1 for indirect),
3. the operand read and/or result write.

For example, ADD M[X], @Y (destination direct, source indirect, result stored in memory): fetch 1, read the pointer at Y 1, read the source 1, read M[X] 1, write M[X] 1 = 5 accesses (for a one-word instruction).

Practice questions