Addressing modes: Visual walkthrough — Hinglish deep dive

5.1.3 · D2 · Hardware › Instruction Set Architecture (ISA) › Addressing modes

Humein sirf teen ideas chahiye, aur hum har ek ko use karne se pehle draw karenge:

ek memory cell (ek numbered box jo ek number hold karta hai),
ek register (CPU ke andar ek super-fast box),
ek instruction (bits ki ek strip jo ek kya-karna-hai part aur ek kahan part mein split hoti hai).

Neeche sab kuch bas yeh hai: "kahan" part ko ek real box mein kaise badlein?

Step 1 — Memory aur register aakhir hote kya hain

KYA: humne memory ko numbered boxes aur register ko ek box ki tarah draw kiya. KYUN: har addressing mode ek sentence hai jaise "start from $A$ , maybe add $(R)$ , maybe follow the arrow." Agar tum boxes aur arrows dekh sako, to formula khud likh jaata hai. PICTURE: neeche, addresses left mein neeche jaate hain; contents andar hain; register R1 side mein float kar raha hai holding $400$ .

Hum parent note ki table ke exact numbers use karte hain taaki har example ek real box pe land kare: $M [100] = 500$ , $M [400] = 700$ , $M [500] = 800$ , $M [403] = 900$ , aur $(R 1) = 400$ , $(R 2) = 3$ , $P C = 200$ .

Step 2 — Goal: EA ek function hai, uske inputs draw karo

KYA: humne machine ko $f$ naam diya aur uske teen possible inputs. KYUN: har mode in teeno inputs ki ek alag wiring hai jo ek output address mein jaati hai. Ab se, neeche har mode ka formula literally " $f$ kuch inputs ignore karke" hai — Direct hai $f = A$ , Register-indirect hai $f = (R)$ , Displacement hai $f = A + (R)$ , PC-relative hai $f = P C + A$ . Dekho $f$ har step mein wapas aata hai. PICTURE: teen clue-arrows ( $A$ , $(R)$ , $P C$ ) ek funnel ko feed karte hain jis par $f$ likha hai; bahar ek single address girta hai, jo ek memory box ko point karta hai.

Step 3 — Zero-arrow modes: Immediate & Register

KYA: do modes jo kabhi koi memory box nahi kholte — yahan $f$ ko call bhi nahi kiya jaata, kyunki koi address ki zaroorat nahi. YAHAN SE KYUN SHURU KAREIN? Kyunki yeh base case hain: woh ek input directly use karte hain zero arrows to follow ke saath. Baad ke har mode ka matlab hai "yeh wale, lekin phir memory mein ek ya zyada steps lo." PICTURE: left side pe instruction ka $A$ box khud value hai (ek self-loop, koi travel nahi). Right side pe ek arrow CPU register mein jaata hai aur wahan ruk jaata hai.

Step 4 — Ek arrow: Direct mode

KYA: humne instruction ke $A$ ko address ki tarah treat kiya aur exactly ek box khola — funnel $f$ sirf $A$ ko straight pass kar deta hai. KYUN yeh rule? Kisi specific location ko point karne ka yeh sabse seedha tarika hai. Cost: $A$ itna wide hona chahiye ki memory ka koi bhi box naam le sake. PICTURE: LOAD 100. Ek yellow arrow $A = 100$ se nikalta hai, box $100$ pe land karta hai, aur hum $500$ padhte hain.

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

Step 5 — Register ke through ek arrow: Register-indirect

KYA: register ke contents hi effective address hain; $f$ $A$ aur $P C$ ko ignore karta hai aur $(R)$ return karta hai. EK ALAG MODE KYUN? Iss tarah tum ek pointer follow karte ho jo register mein rehta hai (jaise ek this-pointer, ya stack ka top). Yeh run time pe pata chalne wale data tak pahunchne ka sabse sasta tarika hai — ek arrow, do nahi. PICTURE: LOAD (R1), $(R 1) = 400$ . Ek pink arrow register R1 se nikalta hai, seedha box $400$ pe land karta hai, aur hum $700$ padhte hain.

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

Step 6 — Do arrows: Indirect mode (memory mein pointer follow karo)

KYA: humne box $A$ khola, andar ek address mila, phir woh box khola. DOOSRA ARROW KYUN CHAHIYE? Taaki instruction us data ko point kar sake jiska pointer memory mein rehta hai — linked lists follow karne ke liye, pointers chase karne ke liye. Price: har baar ek extra memory read. PICTURE: LOAD (100). Arrow ① box $100$ ko hit karta hai aur $500$ milta hai; arrow ② wahan se box $500$ pe jaata hai aur $800$ padhta hai.

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

Step 7 — Do clues add karna: Displacement (the workhorse)

KYA: humne box kholne se pehle register ke contents ko instruction ke constant mein add kiya — $f$ ab dono $A$ aur $(R)$ use karta hai. ADD KYUN, SIRF EK KYUN NAHI USE KAREIN? Kyunki arrays aur structs ek run-time base $(R)$ pe rehte hain, lekin jo element chahiye (offset $A$ ) woh ek fixed, chhota number hai jo compile time pe pata hota hai. Addition run-time start ko compile-time step se jodhta hai — isliye array[3] sasta hai. PICTURE: LOAD 3(R1), $(R 1) = 400$ . Base arrow $400$ tak draw karo, phir boxes mein $+ 3$ step karo $403$ tak, aur $900$ padho.

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

Step 8 — PC ko base ki tarah use karna: PC-relative

KYA: humne PC ko hi base ki tarah use kiya aur ek signed offset add kiya; $f$ yahan $P C$ aur $A$ dono use karta hai. Absolute targets ki jagah offsets kyun? Kyunki program memory mein kahin bhi load ho sakta hai. "Aage 6 jaao" sahi rehta hai chahe code kahaan bhi ho; "206 pe jaao" agar kahin aur load ho to toot jaayega. Yeh position independence hai. PICTURE: BRANCH +6. PC-reference marker se $+ 6$ ki lambaai ka ek yellow arrow target box pe land karta hai.

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

Step 9 — Side effect wale modes: Auto-increment / decrement

KYA: register-indirect (Step 5), plus register chupke $d$ se aage (ya peeche) badh jaata hai. STEPPING ANDAR KYUN RAKHO? Streaming through an array ya stack push/pop karna chahta hai "padho, phir pointer move karo" har iteration mein. Move ko access mein fold karna loop se poori ek instruction hata deta hai — yahi while(*p++) hai. PICTURE: LOAD (R1)+, $(R 1) = 400$ , $d = 1$ . Box $400$ → $700$ padho; phir R1 label $400$ se $401$ pe slide karta hai (dashed arrow), agla read ready.

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

Ek-picture summary

Upar sab kuch ek funnel $f$ hai jo ${A, (R), P C}$ se feed hoti hai, uske baad memory mein zero, ek, ya do arrows. Modes ko ek family ki tarah padho — kitne arrows follow karte hain iske hisaab se:

Recall Feynman: plain words mein poora walkthrough

Memory numbered ghar wali ek gali hai; register ek chhota ghar hai jo tum apni jeb mein rakhte ho. Ek instruction tumhe ek parchchi deta hai jisme number $A$ likha hai. Addressing mode bas woh matlab hai jo parchchi ka hota hai: "Sona yahi number hai" (immediate — koi chalna nahi). "Yeh tumhare jeb waale ghar mein hai" (register — koi chalna nahi). "Ghar $A$ pe jaao" (direct — ek chalna). "Tumhari jeb ki parchchi ek ghar ka number hai — seedha wahan jaao" (register-indirect — ek chalna). "Ghar $A$ mein ek doosre address wali parchchi hai; wahan jaao" (memory-indirect — do chalna). "Apne jeb-ghar ke address se shuru karo, $A$ darwaze aur chalo" (displacement — ek chalna, aur yahi woh hai jo tum arrays ke liye bar bar use karoge). "Jahan tum abhi khade ho wahan se $A$ darwaze chalo — us agli kadam se measure karo jo tum lene hi wale the" (PC-relative — koi fark nahi padta gali kahaan se shuru hoti hai). "Apne jeb-ghar ka darwaza padho, phir apni jeb ki parchchi ko automatically agli darwaze pe badha do" (auto-increment — poori array padhne ke liye perfect). Gali mein jaane ki walks count karo aur tumhe cost pata chal jaata hai. Yahi poora subject hai.

Recall Quick self-check

LOAD (100) jab $M [100] = 500$ , $M [500] = 800$ ho — operand? ::: $800$ (memory-indirect: $E A = M [100] = 500$ , phir $M [500] = 800$ ) LOAD (R1) jab $(R 1) = 400$ , $M [400] = 700$ ho — operand? ::: $700$ (register-indirect: $E A = (R 1) = 400$ , ek access) LOAD 3(R1) jab $(R 1) = 400$ ho — EA? ::: $403$ BRANCH +6 measured from $P C_{next} = 200$ — target? ::: $206$ Displacement jab $A = 0$ ho to kaun sa mode ban jaata hai? ::: 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