Addressing mode — immediate, register, base+offset আর PC-relative

১ · Addressing mode কী — instruction কীভাবে তার operand খুঁজে পায়

কুরিয়ারের একজন লোক তিনটি পার্সেল হাতে নিয়েছেন। প্রথমটির গায়ে লেখা “২০০ টাকা” — টাকাটা পার্সেলের সাথেই আছে, কোথাও খুঁজতে হবে না। দ্বিতীয়টিতে লেখা “বাড়ি নং ৫০০” — সেই বাড়িতে গেলেই প্রাপককে পাওয়া যাবে। তৃতীয়টিতে লেখা “বাড়ি নং ৫০০-এ গিয়ে আসল ঠিকানা জেনে নিন” — অর্থাৎ ৫০০ নম্বর বাড়িতে আরেকটি ঠিকানা লেখা কাগজ আছে, তারপর সেখানে যেতে হবে। একই রকম একটি সংখ্যা, কিন্তু তিনটি আলাদা পড়ার নিয়ম, আর প্রতিটির জন্য হাঁটাহাঁটির পরিমাণও আলাদা।

CPU-র প্রতিটি instruction-এর একই সমস্যা। পর্ব ২৫-এ (ISA কী) দেখেছেন, instruction-এ থাকে কী করতে হবে (opcode) আর কার ওপর করতে হবে, অর্থাৎ operand কোথায় আছে। operand থাকতে পারে instruction-এর ভেতরেই, কোনো register-এ, বা মেমরির কোনো ঘরে। Instruction-এর বিটগুলো থেকে operand-এর আসল অবস্থান কীভাবে বের করতে হবে, সেই নিয়মের নাম addressing mode.

এই পর্বে চিহ্নগুলো এভাবে লিখব: A = instruction-এর address field (বা offset/displacement) — instruction-এর ভেতরে লেখা সংখ্যাটি; R = কোনো register-এর মান; M[x] = মেমরির x ঠিকানার মান; PC = program counter. তাহলে “direct” মানে EA = A, “indirect” মানে EA = M[A], “register indirect” মানে EA = R. বাকি সবকিছু এই তিনটি মৌলিক ভাবনার মিশ্রণ: সংখ্যা নিজেই, সংখ্যা যোগ, আর মেমরি থেকে আরেকবার পড়া।

ISA-ডিজাইনারের কাছে এটি একটি দর-কষাকষি। বেশি mode মানে প্রতিটি instruction বেশি কাজ করতে পারে, program ছোট হয়; কিন্তু instruction-এ mode বোঝাতে বাড়তি বিট লাগে, hardware জটিল হয়, আর pipeline চালানো কঠিন হয়। ১৯৭০-এর দশকের VAX-এর মতো CISC মেশিন প্রায় প্রতিটি operand-এ আলাদা mode বেছে নিতে দিত; অন্যদিকে RISC-V ইচ্ছা করে মাত্র কয়েকটি রেখেছে। কেন — সেটিই এই পর্বের মূল গল্প।

২ · ক্লাসিক addressing mode — সংজ্ঞা, EA সূত্র আর তুলনা

বিশ্ববিদ্যালয়ের Computer Organization বই (যেমন Mano বা Stallings-এর ধাঁচের বই) আর চাকরির লিখিত পরীক্ষায় যে তালিকাটি বারবার আসে, সেটি এক এক করে দেখি। প্রতিটিতে আমরা জানতে চাই: operand কোথায়, EA-র সূত্র কী, instruction fetch করার পরে operand আনতে মেমরিতে আর কতবার যেতে হয়, আর কোথায় কাজে লাগে। উদাহরণগুলো একটি কাল্পনিক accumulator মেশিনের LOAD instruction দিয়ে, যা operand-টি accumulator (AC) register-এ আনে।

যাদের operand মেমরিতে নেই

• Implied (inherent): operand-এর কথা instruction-এ আলাদা করে লেখাই নেই, opcode-ই বলে দেয়। যেমন CMA (accumulator-এর complement), CLC (carry flag মুছে দেওয়া), x86-এর cbw, বা stack মেশিনের ADD. মেমরিতে বাড়তি যাওয়া: ০. সুবিধা: সবচেয়ে ছোট instruction. অসুবিধা: কেবল নির্দিষ্ট কয়েকটি কাজের জন্য।
• Immediate: address field-এই মানটি আছে — operand = A. যেমন LOAD #500 মানে AC ← ৫০০; RISC-V-তে addi x5, x5, 1. মেমরিতে বাড়তি যাওয়া: ০. সুবিধা: দ্রুত, ধ্রুবক রাখার সেরা উপায়। অসুবিধা: মানের পরিসর address field-এর বিট-সংখ্যায় সীমিত (RISC-V-তে ১২ বিট, −২০৪৮ থেকে ২০৪৭)। কিছু বই বলে immediate-এর কোনো EA নেই; Mano-র ধাঁচে বলা হয় EA = address field-টি যে মেমরি-ঘরে বসে আছে, অর্থাৎ instruction-এর দ্বিতীয় word-এর ঠিকানা। পরীক্ষায় যে বই অনুসরণ করা হয়, তার রীতি মানুন।
• Register: operand একটি register-এ — operand = R. যেমন add x5, x6, x7. মেমরিতে বাড়তি যাওয়া: ০. সুবিধা: সবচেয়ে দ্রুত, আর register-এর নাম মাত্র ৩–৫ বিটে লেখা যায়। অসুবিধা: register সংখ্যায় কম — RISC-V-তে ৩২টি, x86-64-এ ১৬টি general-purpose register থাকে।

যাদের operand মেমরিতে

• Direct (absolute): EA = A. LOAD 500 মানে AC ← M[৫০০]. মেমরিতে বাড়তি: ১. ব্যবহার: নির্দিষ্ট ঠিকানার global variable, পুরোনো ৮-বিট মেশিনের hardware register. অসুবিধা: পুরো ঠিকানা instruction-এ ধরাতে হয় — ৩২ বা ৬৪ বিটের ঠিকানা একটি ৩২-বিট instruction-এ আঁটে না; আর program অন্য ঠিকানায় সরালে ঠিকানাটি বদলাতে হয়।
• Indirect (memory indirect): EA = M[A]. ঠিকানা ৫০০-তে আসল ঠিকানা লেখা আছে। মেমরিতে বাড়তি: ২ (প্রথমে ঠিকানা, তারপর মান)। ব্যবহার: pointer-এর মাধ্যমে ডেটা, ছোট address field দিয়ে বড় মেমরিতে পৌঁছানো, jump table. অসুবিধা: ধীর; আধুনিক RISC-এ নেই।
• Register indirect: EA = R. register-এ ঠিকানা রাখা আছে। LOAD (R1); RISC-V-তে lw x5, 0(x10). মেমরিতে বাড়তি: ১. ব্যবহার: C-র *p. সুবিধা: indirect-এর সুবিধা, কিন্তু এক মেমরি-যাত্রা কম, আর instruction ছোট।
• Displacement / base + offset: EA = R_base + A. RISC-V-র lw x5, 8(x10) মানে EA = x10 + ৮. মেমরিতে বাড়তি: ১. ব্যবহার: struct-এর field, stack-এর local variable (sp + offset), array-র নির্দিষ্ট উপাদান। অসুবিধা: offset-এর পরিসর সীমিত। এটিই সবচেয়ে বেশি ব্যবহৃত mode.
• Indexed: EA = A + R_index. গঠন displacement-এর মতোই, ভাবনা উল্টো: এখানে A হলো array-র শুরুর (বড়) ঠিকানা, আর index register (XR)-এ থাকে কত দূরে যেতে হবে। ব্যবহার: a[i], যখন a-র ঠিকানা compile-এর সময় জানা। মেমরিতে বাড়তি: ১.
• Base + index (+ scale): EA = R_base + R_index × s (+ A). দুটি register যোগ, index-কে ১, ২, ৪ বা ৮ দিয়ে গুণ — x86-এর [rbx + rcx*4 + 8]. ব্যবহার: a[i] যখন a নিজেই একটি pointer, বা struct-এর array-র ভেতরের field. মেমরিতে বাড়তি: ১. অসুবিধা: hardware-এ একটি বাড়তি adder আর shifter লাগে, encoding জটিল।
• Relative (PC-relative): EA = PC + A, A সাধারণত signed. ব্যবহার: branch, jump, function call, আর code-এর কাছাকাছি থাকা ডেটা। সুবিধা: offset ছোট রাখা যায়, আর program পুরোটা সরালেও কাজ করে। সতর্কতা: কোন PC? Mano-র বইয়ে fetch-এর পরের PC (পরের instruction-এর ঠিকানা), RISC-V-তে instruction-এর নিজের ঠিকানা, x86-64-এর RIP-relative-এ পরের instruction-এর ঠিকানা।
• Auto-increment / auto-decrement: register indirect, সাথে register-এর মান নিজে থেকে বদলায়। Post-increment (R)+: EA = R, তারপর R ← R + d. Pre-decrement -(R): আগে R ← R − d, তারপর EA = R. d = operand-এর মাপ (byte-addressed মেমরিতে ১, ২, ৪ বা ৮; word-addressed পরীক্ষার মেশিনে ১)। PDP-11 আর Motorola 68000-এর বিখ্যাত বৈশিষ্ট্য, ARM-এ writeback নামে আছে (অংশ ৬)। ব্যবহার: array ধরে এগোনো, stack-এ push/pop. অসুবিধা: একটি instruction দুটি register লেখে (operand আর ঠিকানা) — pipeline-এর জন্য জটিল।
• Stack: operand stack-এর মাথায়, EA = SP; push-pop-এ SP বদলায়, অর্থাৎ আসলে SP-এর ওপর auto-increment/decrement. Stack মেশিনে (যেমন Java bytecode-এর নকশা) ADD instruction stack-এর ওপরের দুটি মান তুলে যোগফল রাখে — operand-এর নাম লিখতেই হয় না।

এক টেবিলে সব mode

“বাড়তি মেমরি-যাত্রা” মানে instruction fetch হয়ে যাওয়ার পরে শুধু operand আনতে কতবার মেমরিতে যেতে হয়। Mano-র ধাঁচের মেশিনে address field প্রায়ই instruction-এর দ্বিতীয় word-এ থাকে; তখন সেটি পড়তেও একবার মেমরিতে যেতে হয় — প্রশ্নে কোনটি গুনতে বলা হয়েছে, সাবধানে পড়ুন। Branch-এর ক্ষেত্রে relative mode ডেটা আনে না, শুধু নতুন PC হিসাব করে, তাই সেখানে বাড়তি যাত্রা ০.

৩ · পরীক্ষার ক্লাসিক numerical — একই instruction, ভিন্ন mode

এবার সেই প্রশ্ন, যা Computer Organization-এর পরীক্ষায় প্রায়ই কোনো না কোনো রূপে আসে। অবস্থাটি এমন:

• একটি দুই-word-এর LOAD instruction মেমরির ঠিকানা ২০০ আর ২০১-এ। ২০০-তে opcode আর mode, ২০১-এ address field A = ৫০০.
• instruction fetch শেষে PC = ২০২ (পরের instruction-এর ঠিকানা)।
• Register: R1 = ৪০০, index register XR = ১০০, stack pointer SP = ১০০০, AC = ৭৫. মেমরি word-addressed, তাই auto-increment-এ d = ১.

প্রশ্ন: প্রতিটি mode-এ EA কত, আর AC-তে কোন মান আসবে? প্রথমে ছয়টি মূল mode ধাপে ধাপে দেখুন — প্রতিটি ধাপে কোন ঘরটি ছোঁয়া হলো, খেয়াল করুন:

instruction at 200-201, A = 500, PC = 202
LOAD #500
EA      = 201  (A sits in the 2nd word)
operand = 500      extra memory reads: 0

LOAD 500
EA      = 500
operand = M[500] = 800    extra memory reads: 1

LOAD @500
read 1 : M[500] = 800  -> this is the address
EA      = 800
read 2 : operand = M[800] = 300   extra reads: 2

LOAD (R1)        R1 = 400
EA      = 400
operand = M[400] = 700    extra memory reads: 1
(A = 500 is not used at all)

LOAD 500(XR)     XR = 100
EA      = 500 + 100 = 600
operand = M[600] = 900    extra memory reads: 1

LOAD 500(PC)     PC = 202 (already past the instruction)
EA      = 202 + 500 = 702
operand = M[702] = 325    extra memory reads: 1
wrong-PC trap: 200 + 500 = 700 -> not in table

বাকি mode-গুলোও একই নিয়মে। নিচের JavaScript calculator-টি পুরো প্রশ্নের তেরোটি সারি একসাথে হিসাব করে। প্রতিটি সারি একই register দিয়ে শুরু হয় (auto-increment-এর পার্শ্বপ্রতিক্রিয়া পরের সারিতে যায় না), আর “mem-reads” কলামে instruction fetch-এর পরের মেমরি-যাত্রা গোনা হয়েছে। “চালান” চেপে দেখুন, তারপর নিজের হাতের হিসাবের সাথে মেলান:

// Classic exam problem: one LOAD instruction, address field A = 500, 13 modes.
const M = {399: 450, 400: 700, 500: 800, 600: 900, 702: 325,
           800: 300, 900: 250, 1000: 600};
const A = 500, PC = 202;                 // PC already points past the 2-word instruction
let R1 = 400, XR = 100, SP = 1000, AC = 75;
const modes = [
  //  name                  EA                operand            extra mem reads
  ["Implied    (AC)",      () => null,       () => AC,           0],
  ["Immediate  #A",        () => 201,        () => A,            0],
  ["Register   R1",        () => null,       () => R1,           0],
  ["Direct     A",         () => A,          ea => M[ea],        1],
  ["Indirect   @A",        () => M[A],       ea => M[ea],        2],
  ["Reg indir  (R1)",      () => R1,         ea => M[ea],        1],
  ["Relative   PC+A",      () => PC + A,     ea => M[ea],        1],
  ["Indexed    XR+A",      () => XR + A,     ea => M[ea],        1],
  ["Base+disp  R1+A",      () => R1 + A,     ea => M[ea],        1],
  ["Base+index R1+XR*4",   () => R1 + XR * 4, ea => M[ea],       1],
  ["Autoinc    (R1)+",     () => R1,         ea => M[ea],        1, () => R1++],
  ["Autodec    -(R1)",     () => --R1,       ea => M[ea],        1],
  ["Stack pop  (SP)+",     () => SP,         ea => M[ea],        1, () => SP++],
];
console.log("mode                  EA     operand  mem-reads  side effect");
for (const [name, eaFn, opFn, reads, after] of modes) {
  const saveR1 = R1, saveSP = SP;        // every row starts from the same registers
  const ea = eaFn();
  const op = opFn(ea);
  if (after) after();
  const side = R1 !== saveR1 ? `R1 = ${R1}` : SP !== saveSP ? `SP = ${SP}` : "";
  console.log(name.padEnd(22) + String(ea ?? "-").padEnd(7) +
              String(op).padEnd(9) + String(reads).padEnd(11) + side);
  R1 = saveR1; SP = saveSP;
}

mode                  EA     operand  mem-reads  side effect
Implied    (AC)       -      75       0
Immediate  #A         201    500      0
Register   R1         -      400      0
Direct     A          500    800      1
Indirect   @A         800    300      2
Reg indir  (R1)       400    700      1
Relative   PC+A       702    325      1
Indexed    XR+A       600    900      1
Base+disp  R1+A       900    250      1
Base+index R1+XR*4    800    300      1
Autoinc    (R1)+      400    700      1          R1 = 401
Autodec    -(R1)      399    450      1          R1 = 399
Stack pop  (SP)+      1000   600      1          SP = 1001

৪ · RISC-V-এর ইচ্ছাকৃত ছোট তালিকা — immediate, register, base+offset আর PC-relative

এত mode দেখার পরে RISC-V-এর তালিকা দেখে অবাক লাগতে পারে। RISC-V-এর মূল integer অংশ RV32I-তে আছে মাত্র চারটি:

পর্ব ২৬-এ (RISC-V-এর instruction) load আর store-এর পরিচয় পেয়েছেন, আর পর্ব ২৭-এ (instruction encoding) দেখেছেন এই offset আর immediate-গুলো ৩২ বিটের কোন ঘরে বসে। এখানে মূল কথাটি হলো: RISC-V একটি load-store architecture. Arithmetic instruction কেবল register আর immediate নিয়ে কাজ করে; মেমরি ছোঁয় শুধু load আর store, আর তাদের ঠিকানা সবসময় EA = rs1 + sign-extended imm12.

এই একটি mode আসলে আরও দুটি ক্লাসিক mode-কে বিনা খরচে ঢেকে দেয়:

• Register indirect = offset ০: lw x5, 0(x10) মানে EA = x10, অর্থাৎ C-র *p.
• ছোট ঠিকানায় direct = base x0: x0 সবসময় ০, তাই lw x5, 100(x0) মানে EA = ১০০. শুধু −২০৪৮ থেকে ২০৪৭-এর মধ্যের ঠিকানায় কাজ করে — ছোট embedded সিস্টেমে মাঝে মাঝে কাজে লাগে।

PC-relative-এর দিকে তিনটি instruction গুরুত্বপূর্ণ। Branch (beq, bne, blt…) PC + offset-এ লাফ দেয় — শর্ত, লুপ আর তাদের offset-এর বিস্তারিত হিসাব পর্ব ২৯-এ (শাখা আর লুপ assembly-তে)। jal function call-এর জন্য, আর jalr হলো register + offset-এ লাফ — function pointer আর ret-এর জন্য register indirect jump. আর auipc (add upper immediate to PC) কোথাও লাফ দেয় না: rd ← PC + (imm20 << ১২) — শুধু একটি PC-ভিত্তিক ঠিকানা register-এ রাখে, যাতে পরের instruction সেখান থেকে ডেটা পড়তে পারে। এর জুড়ি lui (load upper immediate): rd ← imm20 << ১২, PC ছাড়া।

৫ · বাকি mode RISC-V-তে বানানো — indexed, direct আর post-increment

যে mode RISC-V-তে নেই, compiler সেটি দুই-তিনটি সরল instruction জুড়ে বানায়। প্রশ্ন একটাই: কত instruction লাগে, আর তাতে কী হারাই বা পাই।

Indexed: a[i] = shift + add + load

C-তে int a[]-এর a[i]-এর ঠিকানা = a + i × ৪, কারণ প্রতিটি int ৪ byte জায়গা নেয়। x86-এ এটি একটি operand-এই হয়; RISC-V-তে তিন ধাপ: i-কে ২ ঘর বাঁয়ে সরানো (× ৪), base-এর সাথে যোগ, তারপর offset ০ দিয়ে load. নিচে a[i] += 1 — a-র ঠিকানা x10 = 0x1000, i = x11 = ৩, আর a[3]-এ আছে ৪০:

1slli x5, x11, 2    # x5 = i * 42add  x5, x10, x5   # x5 = &a[i]3lw   x6, 0(x5)     # EA = x5 + 04addi x6, x6, 1     # x6 = a[i] + 15sw   x6, 0(x5)     # EA = x5 + 0

RISC-V-র ঐচ্ছিক Zba extension (bit manipulation-এর অংশ, ২০২১ সালের দিকে অনুমোদিত) ঠিক এই ধাঁচটির জন্য sh1add, sh2add, sh3add দিয়েছে: sh2add x5, x11, x10 মানে x5 = (x11 << ২) + x10. তখন a[i] পড়তে লাগে দুটি instruction — পুরো scaled-index mode না এনেও খরচ কমল।

Direct বা global variable: lui + lw

একটি global int g ধরুন 0x00012F40 ঠিকানায়। ৩২-বিটের ঠিকানা ১২-বিটের offset-এ আঁটে না, তাই দুই ভাগ করা হয়: ওপরের ২০ বিট lui দিয়ে register-এ, নিচের ১২ বিট load-এর offset হিসেবে। Assembly-তে লেখা হয় lui x5, %hi(g) আর lw x6, %lo(g)(x5). একটি সূক্ষ্ম ব্যাপার: offset sign-extend হয়। g-এর নিচের ১২ বিট 0xF40 — এর সর্বোচ্চ বিট ১, তাই load সেটিকে −১৯২ হিসেবে পড়বে। ক্ষতিপূরণ দিতে %hi-কে এক বাড়াতে হয়: %hi = (g + 0x800) >> ১২ = 0x13, %lo = −১৯২. যাচাই: 0x13000 − ১৯২ = 0x12F40 ✓.

PC-relative ঠিকানা: auipc + addi (la)

Program কোন ঠিকানায় load হবে জানা না থাকলে (অংশ ৮) পরম ঠিকানা লেখা যায় না, কিন্তু “এই instruction থেকে কত দূরে” লেখা যায়। la x10, msg (load address) একটি pseudo-instruction: assembler এটিকে auipc + addi-তে ভাঙে (PIC-এ global symbol হলে auipc + lw দিয়ে GOT থেকে — assembler-এর option-ভেদে; শুধু PC-relative রূপের জন্য lla নামে আরেকটি pseudo-instruction আছে)। ধরুন auipc আছে 0x00010080-এ আর msg আছে 0x00012F40-এ:

PC of auipc   = 0x00010080
msg           = 0x00012F40
offset        = msg - PC = 0x2EC0  (11968 bytes)

0x2EC0 = 0x00002 _ EC0
naive hi20 = 0x2,  lo12 = 0xEC0
lo12 bit 11 = 1   -> sign problem

addi reads 12-bit 0xEC0 as signed:
0xEC0 - 0x1000 = -320
naive result = PC + 0x2000 - 320 = 0x11F40  (wrong)

hi20 = (0x2EC0 + 0x800) >> 12 = 0x36C0 >> 12 = 3
lo12 = -320
check: 3 * 4096 - 320 = 12288 - 320 = 11968 = 0x2EC0

x10 = 0x00010080 + 0x00003000
    = 0x00013080   (no memory access, no jump)

x10 = 0x00013080 - 0x140 = 0x00012F40 = msg
loaded 0x40000 higher?  PC and msg both move:
offset still 0x2EC0 -> same two instructions work

Post-increment: lw + addi

Array-র সব উপাদান যোগ করার লুপে PDP-11 বা ARM-এর একটি instruction “পড়া আর pointer এগিয়ে দেওয়া” দুটোই করে। RISC-V-তে সেটি lw x6, 0(x10) আর addi x10, x10, 4 — দুটি instruction. নিচের ছোট interpreter চারটি কাজের RV32I sequence চালায়, প্রতিটি load/store-এর EA ছাপে, আর শেষে মোট instruction সংখ্যার পাশে CISC বা ARM-এর একক-instruction রূপটি দেখায়:

// RV32I-lite: run short sequences, print every effective address (EA).
const h = v => "0x" + (v >>> 0).toString(16);
const mem = {0x100c: 40, 0x12f40: 7, 0x2008: 99, 0x3000: 1, 0x3004: 2, 0x3008: 3};
function run(title, prog, regs, cisc, pc0 = 0x10080) {
  const x = new Array(32).fill(0);
  for (const k in regs) x[k] = regs[k];
  const r = s => x[+s.slice(1)], set = (s, v) => { if (s !== "x0") x[+s.slice(1)] = v | 0; };
  let i = 0, n = 0;
  console.log("== " + title);
  while (i < prog.length) {
    const [op, ...a] = prog[i].replace(/[(),]/g, " ").trim().split(/\s+/);
    const pc = pc0 + 4 * i, ea = () => r(a[2]) + Number(a[1]);
    let note = "", next = i + 1;
    if (op === "addi") set(a[0], r(a[1]) + Number(a[2]));
    else if (op === "add") set(a[0], r(a[1]) + r(a[2]));
    else if (op === "slli") set(a[0], r(a[1]) << Number(a[2]));
    else if (op === "lui") set(a[0], Number(a[1]) << 12);
    else if (op === "auipc") set(a[0], pc + (Number(a[1]) << 12));
    else if (op === "lw") { set(a[0], mem[ea()]); note = `EA ${h(ea())} -> ${mem[ea()]}`; }
    else if (op === "sw") { mem[ea()] = r(a[0]); note = `EA ${h(ea())} <- ${r(a[0])}`; }
    else if (op === "bne" && r(a[0]) !== r(a[1])) next = i + Number(a[2]) / 4;
    console.log(`  ${h(pc)}  ${prog[i].padEnd(18)}${note}`);
    i = next; n++;
  }
  console.log(`  -> ${n} instructions, x6 = ${x[6]}, x7 = ${x[7]} | CISC: ${cisc}`);
}
run("indexed: a[i] += 1, a = 0x1000, i = 3", ["slli x5, x11, 2", "add x5, x10, x5",
  "lw x6, 0(x5)", "addi x6, x6, 1", "sw x6, 0(x5)"], {10: 0x1000, 11: 3},
  "add dword ptr [rdi+rsi*4], 1 (1)");
run("direct: global g at 0x12f40", ["lui x5, 0x13", "lw x6, -192(x5)"], {}, "mov eax, [g] (1)");
run("PC-relative: same g", ["auipc x5, 3", "lw x6, -320(x5)"], {}, "mov eax, g[rip] (1)");
run("struct field: p->y, p = 0x2000", ["lw x6, 8(x10)"], {10: 0x2000}, "mov eax, [rdi+8] (1)");
run("post-increment: sum 3 ints", ["lw x6, 0(x10)", "addi x10, x10, 4",
  "add x7, x7, x6", "bne x10, x11, -12"], {10: 0x3000, 11: 0x300c},
  "ARM ldr r6, [r0], #4 = lw+addi (1)");

== indexed: a[i] += 1, a = 0x1000, i = 3
  0x10080  slli x5, x11, 2
  0x10084  add x5, x10, x5
  0x10088  lw x6, 0(x5)      EA 0x100c -> 40
  0x1008c  addi x6, x6, 1
  0x10090  sw x6, 0(x5)      EA 0x100c <- 41
  -> 5 instructions, x6 = 41, x7 = 0 | CISC: add dword ptr [rdi+rsi*4], 1 (1)
== direct: global g at 0x12f40
  0x10080  lui x5, 0x13
  0x10084  lw x6, -192(x5)   EA 0x12f40 -> 7
  -> 2 instructions, x6 = 7, x7 = 0 | CISC: mov eax, [g] (1)
== PC-relative: same g
  0x10080  auipc x5, 3
  0x10084  lw x6, -320(x5)   EA 0x12f40 -> 7
  -> 2 instructions, x6 = 7, x7 = 0 | CISC: mov eax, g[rip] (1)
== struct field: p->y, p = 0x2000
  0x10080  lw x6, 8(x10)     EA 0x2008 -> 99
  -> 1 instructions, x6 = 99, x7 = 0 | CISC: mov eax, [rdi+8] (1)
== post-increment: sum 3 ints
  0x10080  lw x6, 0(x10)     EA 0x3000 -> 1
  0x10084  addi x10, x10, 4
  0x10088  add x7, x7, x6
  0x1008c  bne x10, x11, -12
  0x10080  lw x6, 0(x10)     EA 0x3004 -> 2
  0x10084  addi x10, x10, 4
  0x10088  add x7, x7, x6
  0x1008c  bne x10, x11, -12
  0x10080  lw x6, 0(x10)     EA 0x3008 -> 3
  0x10084  addi x10, x10, 4
  0x10088  add x7, x7, x6
  0x1008c  bne x10, x11, -12
  -> 12 instructions, x6 = 3, x7 = 6 | CISC: ARM ldr r6, [r0], #4 = lw+addi (1)

সংক্ষেপে instruction-এর হিসাব:

Instruction কম মানেই দ্রুত নয়। পর্ব ০৩-এর iron law মনে করুন: সময় = instruction সংখ্যা × CPI × clock period. RISC-V বেশি instruction চালায়, কিন্তু প্রতিটি সরল — তাই CPI কম আর clock দ্রুত রাখা সহজ। আধুনিক x86 আবার ভেতরে জটিল instruction-কে ছোট micro-op-এ ভাঙে। শেষ পর্যন্ত দুই পথ প্রায় একই জায়গায় মেলে।

৬ · x86-64 আর ARM — এক instruction-এ জটিল ঠিকানা

x86-64: [base + index*scale + disp]

x86-64-এর প্রায় যেকোনো instruction-এর একটি operand মেমরিতে থাকতে পারে, আর তার ঠিকানার সাধারণ রূপ (এই পর্বে x86 লেখা Intel syntax-এ; gcc-র ডিফল্ট AT&T syntax-এ [rbx + rcx*4 + 8]-কে লেখা হয় 8(%rbx,%rcx,4)):

Instruction encoding-এ ModRM আর SIB (scale-index-base) নামের byte এই অংশগুলো বলে দেয়; যেকোনো অংশ বাদ দেওয়া যায়। তাই mov eax, [rbx + rcx*4 + 8] একাই base + index × scale + displacement — struct-এর array থেকে একটি field পড়ার জন্য নিখুঁত। কিছু নিয়ম আছে: scale ৩ হয় না, আর rsp index হতে পারে না (তার encoding দিয়ে “index নেই” বোঝানো হয়)। x86-এ সাধারণ instruction-এ দুটি operand একসাথে মেমরিতে থাকতে পারে না — movs-এর মতো string instruction ব্যতিক্রম।

RIP-relative: ৬৪-বিট মোডে mov eax, DWORD PTR g[rip] মানে EA = পরের instruction-এর ঠিকানা + ৩২-বিট displacement, পরিসর প্রায় ±২ GiB. ৩২-বিট x86-এ data-র জন্য এমন কোনো mode ছিল না (অংশ ৮-এ এর পরিণাম)। AMD যখন x86-64 নকশা করে, ৩২-বিট মোডের একটি “শুধু displacement” encoding-কে ৬৪-বিট মোডে RIP-relative-এ বদলে দেয়; পরম ঠিকানা লাগলে SIB byte দিয়ে এখনো লেখা যায়।

LEA — ঠিকানা হিসাব, মেমরি নয়। lea ঠিকানার পুরো হিসাবটি করে, কিন্তু মেমরিতে যায় না — ফলটি register-এ রাখে। ফলে এটি একটি “বিনা পয়সার” যোগ-গুণের যন্ত্র: lea eax, [rdi + rdi*2] মানে eax = ৩ × edi, lea eax, [rdi + rsi + 7] মানে তিনটি সংখ্যার যোগ, flag না বদলিয়ে। gcc আর clang ছোট ধ্রুবক দিয়ে গুণ (৩, ৫, ৯) প্রায়ই এভাবেই করে। নিচের evaluator কয়েকটি operand-এর EA হিসাব করে, আর অবৈধ গঠন ধরে ফেলে:

// x86-64 memory operand: EA = base + index*scale + disp (any part may be missing).
const reg = {rbx: 0x7000n, rcx: 5n, rsi: 3n, rdi: 7n, rsp: 0x7ffe0n};
const RIP_NEXT = 0x401020n;        // RIP-relative uses the address of the NEXT instruction
function ea({ base, index, scale = 1, disp = 0 }) {
  if (![1, 2, 4, 8].includes(scale)) throw new Error("scale must be 1, 2, 4 or 8");
  if (index === "rsp") throw new Error("rsp cannot be an index register");
  const b = base === "rip" ? RIP_NEXT : base ? reg[base] : 0n;
  const i = index ? reg[index] * BigInt(scale) : 0n;
  return b + i + BigInt(disp);
}
const hex = v => "0x" + v.toString(16);
const tests = [
  ["mov eax, [rbx]",              { base: "rbx" }],
  ["mov eax, [rbx + 8]",          { base: "rbx", disp: 8 }],
  ["mov eax, [rbx + rcx*4 + 8]",  { base: "rbx", index: "rcx", scale: 4, disp: 8 }],
  ["mov rax, [rbx + rcx*8 - 16]", { base: "rbx", index: "rcx", scale: 8, disp: -16 }],
  ["mov eax, [rsi*4 + 0x601040]", { index: "rsi", scale: 4, disp: 0x601040 }],
  ["mov eax, [rip + 0x2fe0]",     { base: "rip", disp: 0x2fe0 }],
  ["lea eax, [rdi + rdi*2]",      { base: "rdi", index: "rdi", scale: 2 }],
  ["mov eax, [rsp + 12]",         { base: "rsp", disp: 12 }],
  ["mov eax, [rbx + rcx*3]",      { base: "rbx", index: "rcx", scale: 3 }],
  ["mov eax, [rbx + rsp*2]",      { base: "rbx", index: "rsp", scale: 2 }],
];
for (const [text, op] of tests) {
  let out;
  try { out = "EA = " + hex(ea(op)); } catch (e) { out = "invalid: " + e.message; }
  console.log(text.padEnd(30) + out + (text.startsWith("lea") ? "  (no memory access)" : ""));
}

mov eax, [rbx]                EA = 0x7000
mov eax, [rbx + 8]            EA = 0x7008
mov eax, [rbx + rcx*4 + 8]    EA = 0x701c
mov rax, [rbx + rcx*8 - 16]   EA = 0x7018
mov eax, [rsi*4 + 0x601040]   EA = 0x60104c
mov eax, [rip + 0x2fe0]       EA = 0x404000
lea eax, [rdi + rdi*2]        EA = 0x15  (no memory access)
mov eax, [rsp + 12]           EA = 0x7ffec
mov eax, [rbx + rcx*3]        invalid: scale must be 1, 2, 4 or 8
mov eax, [rbx + rsp*2]        invalid: rsp cannot be an index register

ARM: pre-index আর post-index writeback

ARM-এর load-store-ও base + offset ভিত্তিক, তবে offset-এর সাথে base register হালনাগাদ করার দুটি রূপ আছে। ৩২-বিট ARM (A32) syntax-এ, r1 = 0x100 ধরে:

৬৪-বিট ARM (AArch64)-এ একই ধারণা: ldr x0, [x1, #8]! আর ldr x0, [x1], #8; PC-relative-এর জন্য adr (±১ MiB) আর adrp + add (৪ KiB page ধরে, প্রায় ±৪ GiB) — RISC-V-র auipc + addi-এর কাছাকাছি ভাবনা। একটি ঐতিহাসিক খুঁটিনাটি: A32-এ instruction-এর ভেতরে PC পড়লে মান হয় instruction-এর ঠিকানা + ৮ (Thumb-এ + ৪) — পুরোনো pipeline-এর উত্তরাধিকার; AArch64-এ PC মানে instruction-এর নিজের ঠিকানা। বিস্তারিত ARM-এর reference manual-এ মিলিয়ে নেওয়াই নিরাপদ, কারণ সংস্করণভেদে নিয়মের খুঁটিনাটি আলাদা।

৭ · C-এর গঠন থেকে addressing mode

Compiler-এর চোখে C-র প্রতিটি variable বা expression একটি প্রশ্ন: “এর ঠিকানা কীভাবে বানাব?” উত্তরগুলো একটি টেবিলে আনা যায়:

Struct-এর field-এর offset কীভাবে ঠিক হয় — padding আর alignment-সহ — তা পর্ব ০৬-এ (alignment আর padding) offsetof দিয়ে দেখেছেন; সেই offset-টিই এখানে displacement হিসেবে instruction-এ বসে। আর পর্ব ০৬-এর endianness মনে রাখুন: EA বলে কোন byte থেকে শুরু, আর endianness বলে সেই byte-গুলো কোন ক্রমে মান গড়ে। C-র দিক থেকে pointer আর array-র সম্পর্ক বিস্তারিত আছে C কোর্সের pointer পর্বে আর pointer ও array পর্বে।

একটি ছোট ফাংশন দেখি, যেখানে চারটি ভিন্ন ঠিকানা-ধরন একসাথে আছে:

struct Node { int val; struct Node *next; };
int g;

int f(int *a, int i, struct Node *p) {
    return a[i] + g + p->next->val;
}

# RV32 (pointer = 4 byte)          ; x86-64 (pointer = 8 byte)
f:                                 f:
    slli  a1, a1, 2                    movsx  rsi, esi
    add   a0, a0, a1                   mov    rax, QWORD PTR [rdx+8]
    lw    a5, 0(a0)       # a[i]       mov    eax, DWORD PTR [rax]
    lui   a4, %hi(g)                   add    eax, DWORD PTR [rdi+rsi*4]
    lw    a4, %lo(g)(a4)  # g          add    eax, DWORD PTR g[rip]
    lw    a3, 4(a2)       # p->next    ret
    lw    a3, 0(a3)       # ->val
    add   a0, a5, a4
    add   a0, a0, a3
    ret

RISC-V-তে দশটি instruction, x86-64-এ ছয়টি। next-এর offset RV32-এ ৪ (pointer ৪ byte) কিন্তু x86-64-এ ৮ — int val-এর পরে ৪ byte padding, কারণ ৮-byte pointer-কে ৮-এর গুণিতকে বসতে হয়। x86-এর movsx দরকার, কারণ int i ৩২ বিটের, অথচ ঠিকানার হিসাব ৬৪ বিটে। আর p->next->val হলো দুটি নির্ভরশীল load: প্রথমটি শেষ না হলে দ্বিতীয়টির ঠিকানাই জানা নেই। Linked list ধরে হাঁটা (C কোর্সের linked list পর্ব) ঠিক এমন শিকল — একে বলে pointer chasing, আর প্রতিটি ধাপে cache miss হলে (পর্ব ৪৫) পুরো শিকলটি ধীর হয়ে যায়।

Local variable নিয়ে একটি সতর্কতা: -O0-এ প্রায় প্রতিটি local stack-এ থাকে (sw a0, -20(s0)), কিন্তু -O2-এ বেশিরভাগ local register-এই থেকে যায়, মেমরিতে যায়ই না। Stack frame কীভাবে সাজানো হয় আর sp-relative offset কীভাবে ঠিক হয়, সেটি পর্ব ৩০-এ (function call আর stack); পুরো C-থেকে-assembly পথ পর্ব ৩১-এ (C থেকে assembly) দেখবেন।

আসল মেমরিতে base + offset আর index × scale

নিচের C প্রোগ্রাম একটি local array, একটি global struct-এর array আর একটি global ২-মাত্রিক array-র উপাদানের ঠিকানা ছাপে — তবে পরম ঠিকানা নয়, শুধু শুরুর ঠিকানা থেকে দূরত্ব। কারণ ASLR (অংশ ৮) প্রতিবার পরম ঠিকানা বদলে দেয়, কিন্তু দূরত্ব বদলায় না — আর addressing mode ঠিক এই দূরত্ব দিয়েই কাজ করে:

#include <stdio.h>
#include <stddef.h>
#include <stdint.h>

struct Item { char tag; int qty; double price; };   /* offsets 0, 4, 8 */
int gtable[4][3];                                   /* global: static data area */
struct Item gitems[3];

static long off(const void *p, const void *base) {  /* distance in bytes */
    return (long)((uintptr_t)p - (uintptr_t)base);
}

int main(void) {
    int local[5];                                   /* local: on the stack */
    printf("int local[5]:      &local[i] - &local[0] =");
    for (int i = 0; i < 5; i++) printf(" %ld", off(&local[i], local));
    printf("   (i * %zu)\n", sizeof local[0]);

    printf("struct Item:       sizeof %zu, tag@%zu qty@%zu price@%zu\n",
           sizeof(struct Item), offsetof(struct Item, tag),
           offsetof(struct Item, qty), offsetof(struct Item, price));
    printf("&gitems[2].price - &gitems[0] = %ld  (2*%zu + %zu)\n",
           off(&gitems[2].price, gitems), sizeof(struct Item),
           offsetof(struct Item, price));
    printf("&gtable[2][1] - &gtable[0][0] = %ld  ((2*3 + 1) * 4)\n",
           off(&gtable[2][1], gtable));

    long far = off(&local[0], &gtable[0][0]);
    printf("stack vs global far apart (> 1 MiB)? %s\n",
           (far > (1L << 20) || far < -(1L << 20)) ? "yes" : "no");
    return 0;
}

int local[5]:      &local[i] - &local[0] = 0 4 8 12 16   (i * 4)
struct Item:       sizeof 16, tag@0 qty@4 price@8
&gitems[2].price - &gitems[0] = 40  (2*16 + 8)
&gtable[2][1] - &gtable[0][0] = 28  ((2*3 + 1) * 4)
stack vs global far apart (> 1 MiB)? yes

৮ · PC-relative-এর আসল কদর, আর জটিল mode-এর দাম

Position-independent code, shared library আর ASLR

আপনার ফোনে বা কম্পিউটারে একটি C library (Linux-এ libc.so) একই সময়ে শত শত program ব্যবহার করে। Library-র code-টি RAM-এ একবারই থাকে, সব program-এর মধ্যে ভাগ করে — একে বলে shared library. কিন্তু প্রতিটি program-এর virtual address space-এ library-টি ভিন্ন ঠিকানায় বসতে পারে। Code-এর ভেতরে যদি direct mode-এ পরম ঠিকানা লেখা থাকে, প্রতিটি ঠিকানায় বসানোর সময় সেই সংখ্যাগুলো বদলাতে হবে (relocation) — তখন code page আর ভাগ করা যায় না, প্রতিটি program নিজের কপি চায়।

সমাধান position-independent code (PIC): code এমনভাবে লেখা, যাতে কোনো পরম ঠিকানা না থাকে, শুধু PC থেকে দূরত্ব। Library-র code আর তার নিজের ডেটার দূরত্ব link-এর সময়েই স্থির, তাই PC-relative ঠিকানা যেকোনো জায়গায় সঠিক (অংশ ৫-এর stepper-এর শেষ ধাপ)। অন্য module-এর variable বা function-এর ঠিকানা আগে জানা নেই; সেগুলোর জন্য প্রতিটি module-এ একটি টেবিল থাকে — GOT (global offset table). Program load হওয়ার সময় loader GOT-এ আসল ঠিকানাগুলো লিখে দেয়, আর code PC-relative mode-এ GOT থেকে ঠিকানা পড়ে, তারপর register indirect দিয়ে ডেটা — অর্থাৎ ক্লাসিক indirect mode, দুটি instruction-এ।

ASLR এই ক্ষমতাকেই নিরাপত্তায় ব্যবহার করে: প্রতিবার program চালু হলে stack, heap, library আর (PIE হলে) program-এর নিজের code এলোমেলো ঠিকানায় বসে। আক্রমণকারী মেমরির কোন ঠিকানায় কী আছে আগে থেকে অনুমান করতে পারে না, ফলে অনেক ধরনের আক্রমণ কঠিন হয়। Program যদি PC-relative না হতো, ASLR-এর জন্য প্রতিবার পুরো code relocate করতে হতো। এ কারণেই অনেক Linux distribution-এ gcc এখন ডিফল্ট হিসেবে position-independent executable (PIE) বানায়। OS-এর দিক থেকে logical আর physical ঠিকানা দেখুন OS কোর্সের মেমরির ভিত্তি পর্বে, আর ASLR-সহ নিরাপত্তা-কৌশল OS নিরাপত্তা পর্বে।

জটিল mode আর pipeline

পর্ব ৩৫-এ (pipelining) পাঁচ ধাপের pipeline দেখবেন: fetch, decode, execute, memory, write-back. সেখানে প্রতিটি instruction-এর কাজ একটি নির্দিষ্ট ছাঁচে বসাতে হয়। RISC-V-র base + offset ছাঁচে নিখুঁত বসে: EA হিসাব execute ধাপে ALU-র একটি যোগ, memory ধাপে একটি মেমরি-যাত্রা, write-back-এ একটি register লেখা। এবার জটিল mode-গুলো ভাবুন:

• Memory indirect: দুটি মেমরি-যাত্রা — একটি memory ধাপে আঁটে না; instruction-কে pipeline-এ দুবার ঘুরতে হয় বা আলাদা micro-op লাগে।
• Auto-increment / writeback: একটি instruction দুটি register লেখে (load-এর ফল আর নতুন base), তাই register file-এ বাড়তি write port, আর hazard-এর হিসাবও জটিল (পর্ব ৩৬)।
• Base + index × scale + disp: দুটি register পড়া, একটি shift আর তিনটি সংখ্যার যোগ — address-এর হিসাব একটি সরল যোগের চেয়ে দীর্ঘ, তাই অনেক x86 core-এ আলাদা address generation unit (AGU) থাকে।
• Exception মাঝপথে: instruction-এর মাঝখানে page fault হলে (পর্ব ৩৮, ৫০), auto-increment ইতিমধ্যে register বদলে ফেলেছে কি না — সেটি মনে রেখে instruction আবার শুরু করতে হয়। পুরোনো কিছু CISC chip এ কারণে virtual memory ঠিকমতো সমর্থন করতে কষ্ট পেয়েছে (ভাবনার প্রশ্ন ০৫)।

এর মানে এই নয় যে জটিল mode “খারাপ”। ARM AArch64-এর মতো আধুনিক RISC-ও post-index রেখেছে, কারণ লুপে এটি সত্যিই instruction বাঁচায়, আর আধুনিক out-of-order core-এ বাড়তি write port-এর খরচ সামলানো যায়। মূল শিক্ষা হলো: প্রতিটি mode-এর একটি hardware-মূল্য আছে, আর ISA-ডিজাইনার মাপজোখ দেখে ঠিক করেন কোনটি দাম দেওয়ার যোগ্য।

৯ · AI-এর যুগে — addressing-এর হিসাব যাচাই

Addressing mode-এর প্রশ্নে AI সাধারণত সংজ্ঞাগুলো ঠিক বলে, কিন্তু সংখ্যায় আর ISA-র রীতিতে ভুল করে — বিশেষ করে যেখানে “কোন PC” বা “কোন বই-এর রীতি” গুরুত্বপূর্ণ। নিচের টেবিলের ভুলগুলো খুব পরিচিত:

AI-এর উত্তর হাতে পেলে — যাচাইয়ের চেকলিস্ট

• প্রতিটি EA আর operand নিজে হাতে বা একটি ছোট স্ক্রিপ্টে আবার হিসাব করেছি
• relative mode-এ কোন PC ধরা হয়েছে, প্রশ্নের শর্তের সাথে মিলিয়েছি
• RISC-V বা ARM assembly-র syntax আর পরিসর (১২-বিট offset, branch ±৪ KiB) ISA manual-এ দেখেছি, MIPS-এর নিয়ম মেশেনি
• %hi/%lo ভাগ করলে hi × ৪০৯৬ + lo = মূল মান কি না যাচাই করেছি
• compiler-এর আসল আউটপুট (gcc -O2 -S বা Compiler Explorer) দেখে মিলিয়েছি, AI-এর বানানো assembly-তে ভরসা করিনি