Addressing Modes

Definition: The technique used to specify the operand address in an instruction is called addressing mode. It tells how Effective Address (EA) of operand is calculated.

5 Important Addressing Modes with Examples (assume 8-bit opcode + address field)

1. Implied / Implicit Mode

   • Operand is implicit in opcode itself.
   • CLC (clear carry), STC, HALT
   • EA not needed. Size 1 byte, fast.

2. Immediate Mode

   • Operand itself is in instruction.
   • MOV A, #30H ; ADD #5 → AC ← AC + 5
   • EA = PC+1 (operand field). Fast, no memory reference but limited range ($0$ to $2^{24}-1$ for 24-bit field).

3. Direct / Absolute Mode

   • Address field gives effective address directly.
   • LOAD A, [1000H] → AC ← M[1000H]
   • EA = Address field. Simple but needs $24$ bits to address $16$ MB only, one memory access.

4. Indirect Mode

   • Address field contains address of address.
   • LOAD A, @2000H → AC ← M[M[2000H]]
   • EA = M[Address field]. Can address $2^{32}$ via pointer but needs 2 memory accesses, slow.

5. Register Mode

   • Operand in register.
   • ADD R1, R2 → R1 ← R1+R2 ; MOV A,B
   • EA = Register ID. Very fast, no memory, limited registers.

6. Register Indirect Mode

   • Register holds address of operand.
   • LOAD A, (R1) where R1=2000H → AC ← M[R1]
   • EA = (R). Flexible for pointer/array traversal.

7. Indexed / Base-Relative Mode (extra)

   • LOAD A, 1000H(X) → EA = X + 1000 where X is index register. Useful for arrays. EA = R + displacement.

Comparison Table (5+ modes)

Feature	Immediate	Direct	Indirect	Register	Register Indirect	Indexed
EA =	operand	A	M[A]	R	M[R]	R + disp
Memory refs	0	1	2	0	1	1
Speed	Fastest	Medium	Slow	Fastest	Medium	Medium
Address range	Limited to field	$2^{24}=16$MB	Full $2^{32}$	$2^{k}$ regs	Full	Full
Use	Constants	Global var	Pointers	CPU ops	Pointers/tables	Arrays
Instruction size	1 word	1 word	1 word	1 word	1 word	1 word+disp
Example	ADD #5	LD 1000H	LD @1000H	ADD R1,R2	LD (R1)	LD 1000(X)

Effective Address Calculation summary:

• Direct: $EA = A$
• Immediate: $Operand = A$
• Indirect: $EA = M[A]$
• Register: $EA = R$
• Indexed: $EA = R + A$

Direct needs large field for address; indirect saves field but extra fetch; register fastest; indexed best for relocatable/array structures.