Lesson 4 — Intermediate

Addressing Modes

Instruction bol rahi hai "data le aao" — lekin data exactly kahan se? Us "kahan se" ka tareeka hi addressing mode hai. Is lesson mein hum har mode ko example ke saath samjhenge, effective address calculate karna seekhenge, aur dekhenge kaunsa mode kis kaam (constants, arrays, pointers) ke liye bana hai.

Addressing mode kya hai

Operand ka final address jahan se data uthaana hai use kehte hain Effective Address (EA). Har mode ka apna tareeka hai EA nikaalne ka — koi seedha deta hai, koi calculate karke.

Main addressing modes (examples ke saath)

1. Immediate     : operand instruction ke andar hi likha
   MOV R1, #5        → R1 = 5  (number tohdi, khud diya)

2. Direct        : effective address instruction mein seedha
   MOV R1, [1000]    → R1 = Mem[1000]

3. Indirect      : instruction mein address ka ADDRESS hai
   MOV R1, [[1000]]  → adla = Mem[1000], R1 = Mem[adla]

4. Register      : operand register mein hi hai
   MOV R1, R2        → R1 = R2  (memory nahi chahiye — tez)

5. Register Indirect : register ke andar address hai
   MOV R1, [R2]      → R1 = Mem[R2]  (pointers yahin se)

6. Displacement   : base + offset (register + chhota number)
   MOV R1, 100[R2]   → R1 = Mem[R2 + 100]

7. Implied        : operands pehle se fixed hain
   CLC / CLD        → carry flag = 0 (koi operand likha nahi)

Displacement modes detail (arrays, loops, pointers)

a) Relative (PC-relative) : base = Program Counter
   branch target = PC + offset
   → loops aur jumps ke liye (JMP label)

b) Base + Displacement : base register +12-bit offset
   MOV R1, disp(Rb)  → EA = Rb + disp
   → structure members ke liye

c) Indexed : index register badhta rehta hai
   MOV R1, [Rbase + Rindex]
   → ARRAYS ke liye sabse common mode
d) Auto-increment : access ke baad register = register + size
   MOV R1, (R2)+     → R1 = Mem[R2], R2 = R2 + 4
   → array traversal / stack pop
e) Auto-decrement : pehle register chhota, phir access
   MOV R1, -(R2)     → R2 = R2 - 4, R1 = Mem[R2]
   → stack push (reverse traversal)

Index register array ke loop mein har iteration badhta hai — isi liye indexed mode arrays ka default hai. Auto-increment/decrement stack aur pointer walking ke liye banayi gayi hain, ek instruction mein access + update ho jaata hai.

Kaunsa mode kis kaam ke liye

• Immediate: constants, initialization — MOV R1, #0 (sabse fast, memory access zero).
• Direct: jab address compile time pe fixed ho — global variables.
• Indirect: pointers aur jab address runtime pe change ho — flexible but ek extra memory read.
• Register: jab operand CPU ke paas ho — fastest (no memory access).
• Indexed/Base: arrays aur structures — offset calculate hota rehta hai.
• Relative: jumps/branches — position-independent code banata hai.

Speed order (approx):
  Register > Immediate > Direct > Register Indirect > Indirect

Trade-off :
  Direct    : ek memory read, address instruction mein
  Indirect  : do memory read (pehle address, phir data) — slow,
              lekin POINTER update karna aasaan
  Immediate : zero memory read — but value instruction mein fixed

Memory read jitna kam, program utna fast — isi logic se
RISC mein register-to-register operations ka emphasise hai

Exercise

Common mistakes

• Direct aur Indirect ka farak ulta bolna: Direct = address instruction mein. Indirect = us address mein jaakar phir address milega (pointer). Ek extra memory read indirection mein hai.
• Immediate ko memory wala samajhna: Immediate operand instruction ke andar hi hota hai — memory access hi nahi hota. Isliye ye sabse fast modes mein hai.
• Indexed aur base addressing confuse karna: Indexed = index register loop mein badhta hai (arrays). Base + displacement = fixed offset (structures). Dono displacement family ke hain par use alag.

Immediate      : "ye lo,5 page ka note" (khud likh ke de di)
Direct         : "B-14 ghar pe padi hai" (seedha address)
Indirect       : "uska dost batayega kahan hai" (pointer)
Register       : "bag mein daal di, khud le lo" (paas mein)
Displacement   : "Sector-22, House 105" (area + ghar number)