RISC-V-এর instruction — register, arithmetic, load আর store

১ · Programmer-এর চোখে RISC-V — register, মেমরি আর load-store-এর নিয়ম

পর্ব ২৫-এ (ISA কী) দেখেছেন, ISA হলো hardware আর software-এর চুক্তি। এবার সেই চুক্তির একটি আসল উদাহরণ খুলে পড়ার পালা। এই কোর্সের প্রধান ISA RISC-V, আর তার সবচেয়ে ছোট, বাধ্যতামূলক অংশটির নাম RV32I — “RV” মানে RISC-V, “32” মানে register ৩২ বিটের, আর “I” মানে base integer instruction set. গুণ-ভাগ (M), floating point (F, D), atomic (A), ছোট ১৬-বিটের instruction (C) — এসব আলাদা extension; RV32I-এর ওপর জোড়া লাগে। কেন এই মডিউলার নকশা, তার আলোচনা পর্ব ২৫-এ। এই পর্বে আমরা RV32I-কে দেখব একজন programmer-এর চোখ দিয়ে: কী কী আছে, কীভাবে লিখতে হয়, কোথায় ফাঁদ।

একজন assembly programmer RISC-V-এর ভেতরে মাত্র তিনটি জিনিস দেখেন:

• ৩২টি integer register — x0 থেকে x31, প্রতিটি ৩২ বিটের (RV32-এ)। এর মধ্যে x0 সবসময় ০।
• Program counter (pc) — এখন যে instruction চলছে তার ঠিকানা। প্রতিটি instruction ৪ byte, তাই সাধারণত pc প্রতিবার ৪ করে বাড়ে। pc সরাসরি লেখা যায় না; শাখা আর jump দিয়ে বদলায়।
• মেমরি — byte-এর একটি লম্বা সারি, প্রতিটি byte-এর নিজস্ব ঠিকানা। RV32-এ ঠিকানা ৩২ বিটের, অর্থাৎ তাত্ত্বিকভাবে ৪ GiB. একাধিক byte-এর মান RISC-V little-endian ক্রমে রাখে — কম গুরুত্বের byte ছোট ঠিকানায় (পর্ব ০৬-এর endianness).

আর সবচেয়ে গুরুত্বপূর্ণ নিয়মটি হলো: হিসাব হয় শুধু register-এ. add, sub, and, sll — কোনোটিই মেমরির কোনো ঘর সরাসরি পড়তে বা লিখতে পারে না। মেমরি থেকে মান আনতে হয় load দিয়ে, ফেরত রাখতে হয় store দিয়ে। এমন নকশাকে বলে load-store architecture. ARM, MIPS, SPARC, PowerPC — সব RISC ISA এই নিয়ম মানে। x86-এর মতো CISC ISA-তে আবার add [rbx], 5-এর মতো instruction আছে, যা এক instruction-এই মেমরি পড়ে, যোগ করে, আবার লেখে।

কেন এই কড়া নিয়ম? কারণ এতে প্রতিটি instruction-এর কাজ ছোট আর অনুমানযোগ্য থাকে: একটি arithmetic instruction কখনো মেমরির জন্য অপেক্ষা করবে না, আর একটি load শুধু মেমরি পড়বে। Pipeline-এ (পর্ব ৩৫) এই নিয়মিততাই বড় সুবিধা দেয়। দাম: একই কাজে instruction সংখ্যা বেশি। অংশ ৯-এ দেখবেন, C-র ছোট্ট a[i] += 5 RISC-V-তে পাঁচটি instruction, x86-এ একটি বা দুটি।

২ · ৩২টি register আর তাদের ABI নাম

Hardware-এর চোখে register-গুলোর নাম শুধু x0, x1 … x31. কিন্তু assembly-তে প্রায় কেউ x10 লেখেন না, লেখেন a0. এই দ্বিতীয় নামগুলো এসেছে ABI (Application Binary Interface) থেকে — compiler, library আর operating system-এর মধ্যে একটি চুক্তি, কোন register কোন কাজে ব্যবহার হবে। ফলে আপনার লেখা function আর অন্য কারও লেখা library একসাথে চলতে পারে। পুরো টেবিল:

শেষ কলামটি calling convention-এর মূল কথা। “হ্যাঁ” মানে callee-saved: যে function ডাকা হলো (callee), সে এই register বদলাতে চাইলে আগে পুরোনো মান stack-এ রেখে ফেরার আগে ফিরিয়ে দেবে — তাই ডাকনেওয়ালা (caller) নিশ্চিন্তে s-register-এ মান রাখতে পারে। “না” মানে caller-saved: call-এর পরে t আর a register-এ কী থাকবে তার নিশ্চয়তা নেই; দরকার হলে caller নিজে আগে বাঁচিয়ে রাখবে। এই নিয়মের পুরো ব্যবহার, stack pointer দিয়ে stack frame বানানো আর recursion — সব পর্ব ৩০-এ (Function call আর stack). এখানে শুধু নামগুলো চিনে রাখুন।

তিনটি বিশেষ কথা মনে রাখুন। প্রথমত, x0-এর নাম zero register: এটি পড়লে সবসময় ০ আসে, আর এতে লিখলে কিছুই হয় না। এই একটি ছোট সুবিধা থেকে অনেক কিছু বিনা খরচে পাওয়া যায় — mv, neg, nop, j সব আসলে x0 ব্যবহার করা সাধারণ instruction (অংশ ৮)। দ্বিতীয়ত, hardware-এর কাছে x1–x31 প্রায় পুরোপুরি সমান; “a0 মানে argument” নিয়মটি software-এর, hardware-এর নয়। (সামান্য ব্যতিক্রম: কিছু instruction, যেমন C extension-এর ছোট c.jal, ra-কে নির্দিষ্টভাবে ব্যবহার করে, আর বড় CPU-র return-address predictor ra দেখে অনুমান করে।) তৃতীয়ত, return address, gp আর tp-এ সাধারণ প্রোগ্রামে হাত দেবেন না — linker আর operating system এগুলো ঠিক করে রাখে।

৩ · Assembly লেখার নিয়ম — operand-এর ক্রম, comment, label আর directive

Assembly language হলো machine code-এর মানুষ-পড়ার রূপ। একটি প্রোগ্রাম, যার নাম assembler, প্রতিটি লাইনকে ৩২-বিটের একটি instruction-এ বদলে দেয় (কোন বিট কোথায় বসে, তা পর্ব ২৭-এর instruction encoding-এ)। RISC-V-এর লেখার ধরন খুবই নিয়মিত — চারটি ছাঁচ চিনলেই প্রায় সব পড়তে পারবেন:

# উদাহরণ — RV32I-এর চার ছাঁচ (GNU assembler-এর লেখার ধরন)
add   rd, rs1, rs2        # register-register:  rd = rs1 op rs2
addi  rd, rs1, imm        # register-immediate: rd = rs1 op imm (12-bit signed)
lw    rd, offset(rs1)     # load:   rd = memory[rs1 + offset]
sw    rs2, offset(rs1)    # store:  memory[rs1 + offset] = rs2   (no rd!)

• গন্তব্য আগে: প্রথম operand সাধারণত গন্তব্য register (rd), তারপর উৎস (rs1, rs2). sub t0, t1, t2 মানে t0 = t1 − t2, উল্টো নয়।
• Store ব্যতিক্রম: sw t0, 8(sp)-এ t0 উৎস — store কোনো register লেখে না, তাই rd নেই। প্রথম operand এখানে যে মান মেমরিতে যাবে। নতুনদের সবচেয়ে প্রচলিত ভুলগুলোর একটি এটি।
• Immediate: instruction-এর ভেতরেই লেখা ধ্রুবক — দশমিকে (-5) বা hex-এ (0xFF). আলাদা মেমরি পড়তে হয় না।
• Comment: # থেকে লাইনের শেষ পর্যন্ত। (x86-এর NASM বা MASM-এর মতো কিছু assembler-এ comment শুরু হয় ; দিয়ে; কিন্তু RISC-V-এর GNU assembler-এ ; একই লাইনে দুটি instruction আলাদা করে, তাই comment-এর জন্য # লিখুন।)
• Label: লাইনের শুরুতে loop: বা arr: — একটি ঠিকানার নাম। Assembler নিজে হিসাব করে নেয় label-টি কোন ঠিকানায় পড়ল, আর শাখা বা la-তে সেই হিসাব বসায়।
• Directive: বিন্দু দিয়ে শুরু, CPU-র instruction নয় — assembler-এর জন্য নির্দেশ: .text (কোডের অংশ), .data (ডেটার অংশ), .word 5, 7 (৩২-বিটের মান বসানো), .byte, .asciz "hi", .globl main.

সব একসাথে একটি ছোট প্রোগ্রামে — একটি array-র প্রথম দুটি সংখ্যার যোগফল:

# উদাহরণ — RARS বা GNU as-এ লেখা যায় এমন একটি ছোট RV32I প্রোগ্রাম
        .data
arr:    .word   40, 2, 7          # three 32-bit ints, 4 bytes each
result: .word   0

        .text
        .globl  main
main:   la      t0, arr           # t0 = address of arr   (pseudo: auipc + addi)
        lw      t1, 0(t0)         # t1 = arr[0] = 40
        lw      t2, 4(t0)         # t2 = arr[1] = 2   (next word is 4 bytes later)
        add     t3, t1, t2        # t3 = 42
        la      t4, result
        sw      t3, 0(t4)         # result = 42

লক্ষ করুন 4(t0): arr[1]-এর ঠিকানা arr-এর ঠিকানা থেকে ১ নয়, ৪ byte দূরে, কারণ প্রতিটি .word ৪ byte. C-তে arr[i] লিখলে compiler এই গুণ নিজে করে; assembly-তে আপনাকে করতে হয়। আর la (load address) একটি pseudo-instruction — আসল instruction নয়, assembler এটিকে দুটি আসল instruction-এ বদলায় (অংশ ৪ আর ৮)।

৪ · Arithmetic আর ধ্রুবক — add, sub, addi, lui, auipc আর li

add, sub আর addi

add rd, rs1, rs2 দুটি register যোগ করে, sub rd, rs1, rs2 বিয়োগ করে। ফল সবসময় mod 2³² — সীমা ছাড়ালে চুপচাপ wrap-around; কোনো flag নেই, কোনো trap নেই। Overflow দরকার হলে কীভাবে ধরতে হয়, তা পর্ব ২০-এর sltu আর slt-এর কৌশল-এ বিস্তারিত আছে; এখানে আর পুনরাবৃত্তি করছি না। একই বিটের যোগফল signed আর unsigned দুই অর্থেই সঠিক, কারণ two's complement (পর্ব ০৫)।

addi rd, rs1, imm একটি register-এর সাথে একটি ধ্রুবক যোগ করে। ধ্রুবকটি instruction-এর ভেতরে মাত্র ১২ বিটে রাখা হয়, আর ব্যবহারের আগে ৩২ বিটে sign-extend করা হয়। তাই সীমা:

কেন ১২ বিট? প্রতিটি instruction ঠিক ৩২ বিটের; তার মধ্যে opcode (৭ বিট), গন্তব্য register (৫ বিট), একটি উৎস register (৫ বিট) আর ছোট একটি function field (৩ বিট) বসাতেই ২০ বিট চলে যায়; বাকি থাকে ১২. এর বিস্তারিত পর্ব ২৭-এ। এখান থেকে তিনটি ব্যবহারিক কথা:

• subi নেই। দরকারই নেই: t0 − 100 = addi t0, t0, -100. ঋণাত্মক immediate যোগ করাই বিয়োগ। একটি instruction কম মানে decoder আর encoding দুটিই সরল।
• সীমা অপ্রতিসম। addi t0, t0, -2048 বৈধ, কিন্তু addi t0, t0, 2048 নয় — assembler ভুল (error) দেখাবে। 2048 যোগ করতে দুটি addi (যেমন 2047 আর 1) বা আগে register-এ ধ্রুবক বানিয়ে add.
• বড় ধ্রুবক সরাসরি নয়। 100000 বা 0x12345FFF-এর মতো মান এক instruction-এ register-এ আনা যায় না। এর জন্য আছে lui.

lui আর auipc — উপরের ২০ বিট

lui rd, imm20 (load upper immediate) একটি ২০-বিটের ধ্রুবক নিয়ে register-এর উপরের ২০ বিটে বসায়, আর নিচের ১২ বিট শূন্য করে: rd = imm20 × 2¹² = imm20 << 12. যেমন lui t0, 0x12345 দেয় t0 = 0x12345000. এর সঙ্গী auipc rd, imm20 (add upper immediate to pc): rd = pc + (imm20 << 12). এটি দিয়ে বর্তমান instruction-এর আশেপাশের ঠিকানা বের করা যায় — প্রোগ্রাম মেমরির যেখানেই লোড হোক, ঠিকানা ঠিক থাকে। একে বলে PC-relative ঠিকানা; la আর call pseudo-instruction এর ওপর দাঁড়ানো (পর্ব ২৮-এ addressing mode হিসেবে আবার দেখবেন)।

৩২-বিট ধ্রুবক = lui + addi, আর +0x800-এর ফাঁদ

পরিকল্পনা সহজ শোনায়: উপরের ২০ বিট lui দিয়ে, নিচের ১২ বিট addi দিয়ে। কিন্তু একটি সূক্ষ্ম ফাঁদ আছে। addi-র immediate sign-extend হয়: নিচের ১২ বিটের সর্বোচ্চ বিট (bit 11) ১ হলে, অর্থাৎ নিচের অংশ 0x800 বা তার বেশি হলে, addi সেটিকে ঋণাত্মক সংখ্যা ধরে — 0x800 থেকে 0xFFF মানে −2048 থেকে −1. তখন যোগ নয়, আসলে বিয়োগ হয়, আর ফল ঠিক 0x1000 কম আসে। প্রতিকার: সেই ক্ষেত্রে lui-র মান ১ বাড়িয়ে দেওয়া। নিচে 0x12345FFF লোড করার চেষ্টা, ধাপে ধাপে — “পরে” চাপুন:

0x12345FFF  =  0x12345 │ FFF
               upper 20 bits │ lower 12 bits
lower 12 = 0xFFF = 1111 1111 1111   (bit 11 = 1)

t0 = 0x12345 << 12 = 0x12345000
(lower 12 bits are now 0)

12-bit 0xFFF = 1111 1111 1111
sign-extended to 32 bits = 0xFFFFFFFF = -1
so "addi t0, t0, 0xFFF" really means  addi t0, t0, -1
(GNU as rejects 0xFFF here: 4095 is out of range)

0x12345000 + (-1) = 0x12344FFF
wanted              0x12345FFF
difference          0x00001000   (one step of lui too low)

bit 11 of c is 1  ->  add 1 to the upper part
(0x12345FFF + 0x800) >> 12 = 0x123467FF >> 12 = 0x12346
lui t0, 0x12346      t0 = 0x12346000

0x12346000 + (-1) = 0x12345FFF   ok
li t0, 0x12345FFF   ==  lui t0, 0x12346 ; addi t0, t0, -1

সংশোধনটি কেন সবসময় ঠিক — ছোট প্রমাণ

ধরুন ধ্রুবক c-কে লিখি c = H · 2¹² + L, যেখানে H উপরের ২০ বিট আর L নিচের ১২ বিট (0 ≤ L ≤ 4095). addi L-কে sign-extend করে পড়ে, অর্থাৎ যোগ করে ℓ = L − 4096 · b, যেখানে b = bit 11 (L ≥ 2048 হলে b = 1, নাহলে 0). ফলে −2048 ≤ ℓ ≤ 2047. আমরা চাই lui-র মান h এমন হোক যাতে h · 2¹² + ℓ = c, অর্থাৎ h = H + b. এখন দেখুন, (c + 2048) >> 12 = H + ⌊(L + 2048) / 4096⌋, আর L + 2048 ≥ 4096 ঠিক তখনই, যখন L ≥ 2048, অর্থাৎ b = 1. সুতরাং (c + 0x800) >> 12 = H + b — ঠিক যা লাগবে। সব হিসাব mod 2³², তাই H = 0xFFFFF-এর মতো সীমানায় h “উপচে” ০ হয়ে গেলেও ফল সঠিক থাকে। GNU assembler-এর %hi(c) আর %lo(c) ঠিক এই নিয়মে হিসাব করে: lui t0, %hi(c) আর addi t0, t0, %lo(c).

নিয়মটি এবার অনেক ধ্রুবকে চালিয়ে দেখা যাক। নিচের simulator প্রতিটি ধ্রুবকের জন্য সঠিক lui/addi জোড়া বের করে, ৩২-বিট wrap মেনে আবার জোড়া লাগায়, আর পাশে দেখায় +0x800 ভুলে গেলে কী হতো; শেষে ১০ লক্ষ এলোমেলো ধ্রুবকে যাচাই করে। Run চাপুন:

// Split any 32-bit constant into lui (upper 20 bits) + addi (signed low 12 bits)
const hx = (v, w = 8) => "0x" + (v >>> 0).toString(16).toUpperCase().padStart(w, "0");
function split(c) {
  const lo = (c << 20) >> 20;                    // low 12 bits, sign-extended: -2048..2047
  const hi = ((c + 0x800) >>> 12) & 0xFFFFF;     // +0x800 adds 1 exactly when bit 11 is set
  return { hi, lo };
}
const rebuild = (hi, lo) => ((hi << 12) + lo) | 0;   // what lui + addi computes (mod 2^32)
const naiveHi = c => (c >>> 12) & 0xFFFFF;            // forgetting the correction
console.log("constant     lui imm   addi imm  rebuilt      | naive lui  naive result");
for (const c of [0x12345FFF, 0x12345678, 0xDEADBEEF, 0x00000800, 0x000007FF,
                 0xFFFFF800, 0x7FFFF800, 0xFFFFFFFF, 0x80000000]) {
  const { hi, lo } = split(c), r = rebuild(hi, lo), n = rebuild(naiveHi(c), lo);
  console.log(`${hx(c)}   ${hx(hi, 5)}  ${String(lo).padStart(6)}    ${hx(r)} ${r === (c | 0) ? "ok " : "BAD"}` +
              ` | ${hx(naiveHi(c), 5)}    ${hx(n)} ${n === (c | 0) ? "ok" : "off by " + hx(((c | 0) - n) >>> 0, 4)}`);
}
const { hi, lo } = split(0x12345FFF);
console.log(`\nli t0, 0x12345FFF  =>  lui t0, ${hx(hi, 5)}   then   addi t0, t0, ${lo}`);
let seed = 2026, bad = 0;                            // deterministic sweep over 1,000,000 constants
for (let i = 0; i < 1e6; i++) {
  seed = (Math.imul(seed, 1664525) + 1013904223) | 0;
  const s = split(seed);
  if (rebuild(s.hi, s.lo) !== seed || s.lo < -2048 || s.lo > 2047) bad++;
}
console.log(`random constants: 1000000, wrong rebuilds: ${bad}`);

constant     lui imm   addi imm  rebuilt      | naive lui  naive result
0x12345FFF   0x12346      -1    0x12345FFF ok  | 0x12345    0x12344FFF off by 0x1000
0x12345678   0x12345    1656    0x12345678 ok  | 0x12345    0x12345678 ok
0xDEADBEEF   0xDEADC    -273    0xDEADBEEF ok  | 0xDEADB    0xDEADAEEF off by 0x1000
0x00000800   0x00001   -2048    0x00000800 ok  | 0x00000    0xFFFFF800 off by 0x1000
0x000007FF   0x00000    2047    0x000007FF ok  | 0x00000    0x000007FF ok
0xFFFFF800   0x00000   -2048    0xFFFFF800 ok  | 0xFFFFF    0xFFFFE800 off by 0x1000
0x7FFFF800   0x80000   -2048    0x7FFFF800 ok  | 0x7FFFF    0x7FFFE800 off by 0x1000
0xFFFFFFFF   0x00000      -1    0xFFFFFFFF ok  | 0xFFFFF    0xFFFFEFFF off by 0x1000
0x80000000   0x80000       0    0x80000000 ok  | 0x80000    0x80000000 ok

li t0, 0x12345FFF  =>  lui t0, 0x12346   then   addi t0, t0, -1
random constants: 1000000, wrong rebuilds: 0

li — যা আপনি লেখেন, আর যা assembler বানায়

বাস্তবে আপনি প্রায় কখনো নিজে lui-addi ভাঙবেন না; লিখবেন li rd, constant (load immediate). এটি pseudo-instruction: assembler ধ্রুবক দেখে ঠিক করে — −2048…2047 হলে একটি addi rd, zero, c; নিচের ১২ বিট ০ হলে শুধু lui; নাহলে সংশোধিতসহ lui + addi. তাহলে এই হিসাব শেখার দরকার কী? তিনটি কারণে: compiler-এর বানানো assembly বা disassembly পড়তে গেলে lui a5, 0x12346 দেখে বুঝতে হবে আসল ধ্রুবক কত; পরীক্ষা আর ইন্টারভিউতে ঠিক এই প্রশ্নটি আসে; আর নিজের assembler, JIT বা emulator লিখলে এই নিয়ম আপনাকেই প্রয়োগ করতে হবে।

৫ · Logical, shift আর তুলনা — বিট নিয়ে কাজ

and, or, xor — আর NOT কোথায়?

and, or, xor দুটি register-এর প্রতিটি বিট জোড়ায় জোড়ায় মেলায়; andi, ori, xori একই কাজ করে একটি ১২-বিটের immediate দিয়ে — এবং এখানেও immediate sign-extend হয়। এটি MIPS থেকে আলাদা: MIPS-এর andi/ori immediate zero-extend করত। RISC-V-এর নিয়মে একটি সুবিধা আছে: andi t0, t0, -16 (−16 = 0xFFFFFFF0) এক instruction-এ নিচের চারটি বিট মুছে দেয় — ঠিকানাকে ১৬-এর গুণিতকে নামানোর প্রচলিত কৌশল।

RV32I-এ আলাদা NOT instruction নেই। কারণ x ⊕ 1 = x′ (বিটের উল্টো; এই পর্বে A′ মানে A-র সব বিট উল্টানো, কোডে ~A), আর −1-এর সব ৩২টি বিট ১. তাই xori rd, rs, -1-ই NOT — not rd, rs pseudo-instruction ঠিক এটাই বানায়। একটি bitmask দিয়ে প্রচলিত চারটি কাজ, পর্ব ০৬-এর bit manipulation-এর RISC-V রূপ:

# উদাহরণ — t0-এর বিট নিয়ে কাজ (RV32I)
andi  t1, t0, 0xFF        # keep only the low byte          (extract)
ori   t0, t0, 0x20        # set bit 5                       (set)
andi  t0, t0, -33         # clear bit 5: -33 = 0xFFFFFFDF   (clear)
xori  t0, t0, 0x1         # flip bit 0                      (toggle)
not   t2, t0              # = xori t2, t0, -1               (all bits)
# bit 20 সেট করতে mask 0x100000 লাগে — ১২ বিটে ধরে না, তাই আগে register-এ:
lui   t3, 0x100           # t3 = 0x00100000 = 1 << 20
or    t0, t0, t3

Shift — sll, srl, sra আর তাদের immediate রূপ

sll (shift left logical) বিট বাঁয়ে সরায়, ডানে ০ ঢোকায় — k ঘর সরানো মানে 2^k দিয়ে গুণ (mod 2³²). ডানে সরানোর দুই রকম: srl (logical) বাঁয়ে ০ ঢোকায় — unsigned সংখ্যার 2^k দিয়ে ভাগ; sra (arithmetic) বাঁয়ে sign-বিটের কপি ঢোকায় — signed সংখ্যার ভাগ, তবে floor-এর দিকে গোল করে (−7 sra 1 = −4; C-র −7/2 = −3 — এর সংশোধন পর্ব ২০-এর অংশ ৭-এ)। Hardware-এ এগুলো কীভাবে এক cycle-এ হয়, তা পর্ব ১৩-এর barrel shifter-এ।

Register রূপে (sll rd, rs1, rs2) কত ঘর সরাবে তা আসে rs2-এর শুধু নিচের ৫ বিট থেকে — অর্থাৎ ০ থেকে ৩১. rs2 = 33 হলে আসলে ১ ঘর সরে (33 mod 32). Immediate রূপে (slli, srli, srai) এই shift amount instruction-এই লেখা, ০ থেকে ৩১ — এর বাইরে assembler মানবে না। লক্ষ করুন, srai আছে কিন্তু slai নেই: বাঁয়ে arithmetic আর logical shift একই কাজ।

তুলনা — slt, sltu, slti, sltiu

RV32I-এ কোনো flag নেই; তুলনার ফল রাখা হয় সাধারণ register-এ, ১ বা ০ হিসেবে। slt rd, rs1, rs2 (set on less than): rs1 < rs2 (signed) হলে rd = 1, নাহলে 0. sltu একই প্রশ্ন unsigned অর্থে। slti আর sltiu immediate-এর সাথে তুলনা করে — sltiu-তেও immediate প্রথমে sign-extend হয়, তারপর unsigned তুলনা। এই দুটি দিয়ে কয়েকটি দরকারি pseudo-instruction তৈরি:

দুটি register সমান কি না জানতে? sub t0, a0, a1 (বা xor) তারপর seqz t0, t0 — দুটি instruction. আর তুলনার পর শাখা দরকার হলে আলাদা slt লাগেই না: blt, bltu-র মতো শাখা নিজেই তুলনা করে (অংশ ৮)। Signed আর unsigned তুলনা গুলিয়ে ফেলার ক্লাসিক বাগ পর্ব ২০-এর blt বনাম bltu-তে আছে।

৬ · Load আর store — base + offset, sign বনাম zero extension, alignment

RV32I-এ মেমরির সাথে কাজের instruction মাত্র আটটি: পাঁচটি load আর তিনটি store. সবগুলোর ঠিকানা একই নিয়মে: ঠিকানা = rs1 + sign-extend(offset), যেখানে offset ১২ বিটের (−2048…2047). এই যোগফলকে বলে effective address. মহল্লার গলির কথা ভাবুন: rs1 হলো গলির মুখের ঠিকানা (base), offset হলো “মুখ থেকে কয়েক বাড়ি পরে”। Stack-এর জিনিস (8(sp)), struct-এর field (12(a0)), array-র উপাদান — সব এই একটি ছাঁচে। ঠিকানা বানানোর অন্য পদ্ধতিগুলোর তুলনা পর্ব ২৮-এ (Addressing mode).

Store-এর কোনো “u” রূপ নেই — কেন? কারণ store শুধু নিচের বিটগুলো কেটে রাখে; বাঁয়ের বিট কী ছিল তাতে কিছু যায় আসে না। কিন্তু load-এ ছোট মানকে ৩২-বিটের register-এ ভরতে হয়, আর বাঁয়ের ফাঁকা ২৪ বা ১৬ বিটে কী বসবে, সেটি নির্ভর করে মানটি signed না unsigned তার ওপর — ঠিক পর্ব ০৫-এর sign আর zero extension. মেমরির একটি byte 0xF0 দিয়ে দেখুন:

address : 0x100  0x101  0x102  0x103
byte    :  F0     7F     80     00
0xF0 = 1111 0000   (signed -16, unsigned 240)

byte       :                               1111 0000
bit 7 = 1  ->  fill 24 bits with 1
t0         : 1111 1111 1111 1111 1111 1111 1111 0000
           = 0xFFFFFFF0 = -16

byte       :                               1111 0000
"u"        ->  fill 24 bits with 0
t1         : 0000 0000 0000 0000 0000 0000 1111 0000
           = 0x000000F0 = 240

lb  from 0x101 (7F): bit 7 = 0 -> 0x0000007F = 127
lbu from 0x101 (7F):             0x0000007F = 127   (same!)
lb  from 0x102 (80): bit 7 = 1 -> 0xFFFFFF80 = -128
lbu from 0x102 (80):             0x00000080 =  128

little-endian: lowest address = least significant byte
t2 = 0x00 80 7F F0 = 0x00807FF0 = 8421360
the byte F0 is now just the low 8 bits -- no extension needed

এবার একই মেমরিতে সব রকম load একসাথে, half-word আর word-সহ। নিচের simulator byte-গুলো little-endian নিয়মে জোড়া লাগায়, তারপর load-এর নাম দেখে sign বা zero extension করে; শেষ কলামে বলে ঠিকানাটি aligned কি না:

// lb/lbu/lh/lhu/lw on little-endian memory: which bytes, and how the rest of the register is filled
const mem = [0xF0, 0x7F, 0x80, 0x00, 0xEF, 0xBE, 0xAD, 0xDE];   // addresses 0..7
const hx = (v, w = 8) => "0x" + (v >>> 0).toString(16).toUpperCase().padStart(w, "0");
function load(op, addr) {
  const n = { b: 1, h: 2, w: 4 }[op[1]];                        // bytes read
  let v = 0;
  for (let k = n - 1; k >= 0; k--) v = v * 256 + mem[addr + k]; // little-endian: LSB at lowest address
  const bits = 8 * n, signed = !op.endsWith("u");
  if (bits < 32) v = signed ? (v << (32 - bits)) >> (32 - bits)  // sign-extend: copy the top bit
                            : v;                                // zero-extend: upper bits stay 0
  return { v: v | 0, aligned: addr % n === 0, raw: mem.slice(addr, addr + n) };
}
console.log("memory: " + mem.map((b, i) => `[${i}]=${b.toString(16).toUpperCase().padStart(2, "0")}`).join(" "));
console.log("\ninstr         bytes read     register         signed  aligned?");
const tests = [["lb", 0], ["lbu", 0], ["lb", 1], ["lbu", 1], ["lb", 2], ["lbu", 2],
  ["lh", 0], ["lhu", 0], ["lh", 2], ["lhu", 2], ["lh", 6], ["lhu", 6], ["lw", 0], ["lw", 4], ["lh", 1]];
for (const [op, a] of tests) {
  const r = load(op, a), bytes = r.raw.map(b => b.toString(16).toUpperCase().padStart(2, "0")).join(" ");
  console.log(`${(op + " x5, " + a + "(x0)").padEnd(14)}${bytes.padEnd(15)}${hx(r.v)}  ${String(r.v).padStart(11)}  ${r.aligned ? "yes" : "NO - may be slow or trap"}`);
}

memory: [0]=F0 [1]=7F [2]=80 [3]=00 [4]=EF [5]=BE [6]=AD [7]=DE

instr         bytes read     register         signed  aligned?
lb x5, 0(x0)  F0             0xFFFFFFF0          -16  yes
lbu x5, 0(x0) F0             0x000000F0          240  yes
lb x5, 1(x0)  7F             0x0000007F          127  yes
lbu x5, 1(x0) 7F             0x0000007F          127  yes
lb x5, 2(x0)  80             0xFFFFFF80         -128  yes
lbu x5, 2(x0) 80             0x00000080          128  yes
lh x5, 0(x0)  F0 7F          0x00007FF0        32752  yes
lhu x5, 0(x0) F0 7F          0x00007FF0        32752  yes
lh x5, 2(x0)  80 00          0x00000080          128  yes
lhu x5, 2(x0) 80 00          0x00000080          128  yes
lh x5, 6(x0)  AD DE          0xFFFFDEAD        -8531  yes
lhu x5, 6(x0) AD DE          0x0000DEAD        57005  yes
lw x5, 0(x0)  F0 7F 80 00    0x00807FF0      8421360  yes
lw x5, 4(x0)  EF BE AD DE    0xDEADBEEF   -559038737  yes
lh x5, 1(x0)  7F 80          0xFFFF807F       -32641  NO - may be slow or trap

C-তে এই একই ব্যাপার ঘটে cast-এ। int8_t-এ রূপান্তর মানে lb-এর মতো sign extension, uint8_t মানে lbu-এর মতো zero extension. নিচের প্রোগ্রাম Wandbox-এ (gcc, x86-64 Linux — সেটিও little-endian) সেটি দেখায়, আর সাথে lui-addi-র ভাগের হিসাবটি unsigned গণিতে আবার করে — সব হিসাব unsigned-এ, তাই কোনো undefined behaviour নেই:

#include <stdio.h>
#include <stdint.h>
#include <string.h>
int main(void) {
    uint8_t mem[4] = {0xF0, 0x7F, 0x80, 0x00};
    for (int i = 0; i < 3; i++) {
        int32_t  lb  = (int8_t)mem[i];   /* like lb : copy bit 7 upward (gcc: modulo 256) */
        uint32_t lbu = mem[i];           /* like lbu: upper 24 bits are 0 */
        printf("byte %02X: lb -> %4d = 0x%08X   lbu -> %3u = 0x%08X\n",
               (unsigned)mem[i], (int)lb, (unsigned)lb, (unsigned)lbu, (unsigned)lbu);
    }
    uint32_t w; memcpy(&w, mem, 4);       /* lw on a little-endian machine */
    printf("lw  -> 0x%08X\n", (unsigned)w);
    uint32_t consts[3] = {0x12345FFFu, 0xDEADBEEFu, 0x00000800u};
    for (int i = 0; i < 3; i++) {
        uint32_t c = consts[i], low = c & 0xFFFu;
        int32_t lo = (low >= 0x800u) ? (int32_t)low - 4096 : (int32_t)low;   /* signed 12-bit */
        uint32_t hi = ((c + 0x800u) >> 12) & 0xFFFFFu;
        uint32_t back = (hi << 12) + (uint32_t)lo;                           /* lui + addi, mod 2^32 */
        uint32_t naive = (((c >> 12) & 0xFFFFFu) << 12) + (uint32_t)lo;
        printf("0x%08X: lui 0x%05X, addi %5d -> 0x%08X   naive lui -> 0x%08X\n",
               (unsigned)c, (unsigned)hi, (int)lo, (unsigned)back, (unsigned)naive);
    }
    return 0;
}

byte F0: lb ->  -16 = 0xFFFFFFF0   lbu -> 240 = 0x000000F0
byte 7F: lb ->  127 = 0x0000007F   lbu -> 127 = 0x0000007F
byte 80: lb -> -128 = 0xFFFFFF80   lbu -> 128 = 0x00000080
lw  -> 0x00807FF0
0x12345FFF: lui 0x12346, addi    -1 -> 0x12345FFF   naive lui -> 0x12344FFF
0xDEADBEEF: lui 0xDEADC, addi  -273 -> 0xDEADBEEF   naive lui -> 0xDEADAEEF
0x00000800: lui 0x00001, addi -2048 -> 0x00000800   naive lui -> 0xFFFFF800

Alignment — ঠিকানাটি কি মাপের গুণিতক?

একটি N-byte-এর মান যদি N-এর গুণিতক ঠিকানায় থাকে (lw-এর জন্য ৪-এর গুণিতক, lh-এর জন্য জোড়), তবে সেটি naturally aligned (পর্ব ০৬-এর alignment আর padding). এর বাইরে গেলে misaligned access. RISC-V-এর unprivileged spec এখানে ইচ্ছা করেই নমনীয়: misaligned load-store hardware নিজে সামলাতে পারে, অথবা একটি exception (trap) তুলতে পারে, আর তখন firmware বা operating system চাইলে software-এ টুকরো টুকরো করে কাজটি সেরে দিতে পারে (trap-and-emulate). ফলে একই কোড এক chip-এ সামান্য ধীর, আরেক chip-এ শত গুণ ধীর হতে পারে, কোথাও আবার প্রোগ্রাম থেমেও যেতে পারে — কোন chip কী করে তা নির্দিষ্ট chip-এর নথিতে দেখতে হয়। x86 সাধারণত misaligned access hardware-এ সামলায়; পুরোনো ARM অনেক ক্ষেত্রে করত না। নিরাপদ নিয়ম: ডেটা aligned রাখুন — compiler নিজেই struct-এ padding দিয়ে তা করে।

৭ · সব একসাথে — একটি ছোট RV32I interpreter

এ পর্যন্ত যা শিখলেন, তা একটি কাজ করা যন্ত্রে বসানোর সময় হয়েছে। নিচের JavaScript প্রোগ্রামটি RV32I-এর একটি ছোট instruction set simulator: ৩২টি register (Int32Array, তাই প্রতিটি লেখায় আপনাআপনি ৩২-বিট wrap), ৬৪ byte-এর little-endian মেমরি, আর text assembly পড়ার একটি ছোট parser. এটি বোঝে add sub and or xor sll srl sra slt sltu, তাদের immediate রূপ, lui auipc lw lb lbu sw sb, আর pseudo-instruction li mv not neg-কে আসল instruction-এ ভেঙে নেয়। প্রতিটি instruction-এর পর যে register বা মেমরি বদলাল, তা ছাপে। (জায়গা বাঁচাতে প্রোগ্রামের instruction-গুলো | দিয়ে আলাদা করা; আসল assembler-এ প্রতি লাইনে একটি।)

// Tiny RV32I interpreter (text subset): 32 registers x 32 bits, little-endian byte memory
const ABI = "zero ra sp gp tp t0 t1 t2 s0 s1 a0 a1 a2 a3 a4 a5 a6 a7 s2 s3 s4 s5 s6 s7 s8 s9 s10 s11 t3 t4 t5 t6".split(" ");
const R = new Int32Array(32), mem = new Uint8Array(64);  R[2] = 64;            // sp = 64
const rn = n => (n === "fp" ? 8 : ABI.includes(n) ? ABI.indexOf(n) : +n.slice(1)), num = s => Number(s) | 0;
const hx = v => "0x" + (v >>> 0).toString(16).toUpperCase().padStart(8, "0");
const set = (d, v) => { if (rn(d)) R[rn(d)] = v; return `${d} = ${hx(R[rn(d)])} (${R[rn(d)]})`; };  // x0 stays 0
const ALU = { add: (a, b) => a + b, sub: (a, b) => a - b, and: (a, b) => a & b, or: (a, b) => a | b,
  xor: (a, b) => a ^ b, sll: (a, b) => a << (b & 31), srl: (a, b) => a >>> (b & 31), sra: (a, b) => a >> (b & 31), slt: (a, b) => +(a < b), sltu: (a, b) => +(a >>> 0 < b >>> 0) };
function expand(op, a) {                                 // pseudo-instructions -> real RV32I
  const P = { mv: [["addi", a[0], a[1], "0"]], not: [["xori", a[0], a[1], "-1"]], neg: [["sub", a[0], "zero", a[1]]] };
  if (op !== "li") return P[op] || [[op, ...a]];
  const v = num(a[1]), lo = (v << 20) >> 20, hi = ((v - lo) >>> 12) & 0xFFFFF;  // lo = signed low 12 bits
  return hi === 0 ? [["addi", a[0], "zero", String(lo)]] : [["lui", a[0], "0x" + hi.toString(16)], ["addi", a[0], a[0], String(lo)]];
}
function exec([op, d, x, y], pc) { const m = /^(-?\w+)\((\w+)\)$/.exec(x || "");  // m: "off(base)"
  if (op === "lui" || op === "auipc") return set(d, (op === "auipc" ? pc : 0) + (num(x) << 12));
  if (m) {                                               // loads/stores: base register + offset
    const ad = (R[rn(m[2])] + num(m[1])) >>> 0, v = R[rn(d)];
    if (op === "sw") for (let k = 0; k < 4; k++) mem[ad + k] = v >>> (8 * k);
    if (op === "sb") mem[ad] = v;                        // only the low 8 bits fit
    if (op[0] === "s") return `mem[${ad}..${ad + 3}] = ` + [...mem.slice(ad, ad + 4)].map(b => b.toString(16).padStart(2, "0")).join(" ");
    if (op === "lw") return set(d, mem[ad] | mem[ad + 1] << 8 | mem[ad + 2] << 16 | mem[ad + 3] << 24);
    return set(d, op === "lb" ? (mem[ad] << 24) >> 24 : mem[ad]);   // lb sign-, lbu zero-extends
  }
  const base = op === "sltiu" ? "sltu" : op.replace(/i$/, ""), imm = base !== op;
  const [lo, hi] = /^s(ll|rl|ra)i$/.test(op) ? [0, 31] : [-2048, 2047];         // shamt or 12-bit imm
  if (imm && (num(y) < lo || num(y) > hi)) throw Error(`${op}: immediate ${y} out of range`);
  return set(d, ALU[base](R[rn(x)], imm ? num(y) : R[rn(y)]));
}
const prog = `lui t0, 0x12346 | addi t0, t0, -1 | li t1, 0x12345FFF | xor t2, t0, t1 | andi t3, t0, 0xFF
  srli t4, t0, 16 | not t5, t3 | srai t6, t5, 4 | srli a0, t5, 4 | slt a1, t5, zero | sltu a2, t5, zero
  neg a3, t3 | sw t0, -4(sp) | lb a4, -4(sp) | lbu a5, -4(sp) | sb t4, -4(sp) | lw a6, -4(sp) | auipc a7, 1`;
let pc = 0;                                  // "|" separates instructions here only to save space
for (const [op, ...args] of prog.split(/\s*[|\n]\s*/).map(l => l.split(/[\s,]+/)))
  for (const ins of expand(op, args)) { console.log(`${pc.toString(16).padStart(2, "0")}  ${(ins[0] + " " + ins.slice(1).join(", ")).padEnd(22)} ${exec(ins, pc)}`); pc += 4; }

00  lui t0, 0x12346        t0 = 0x12346000 (305422336)
04  addi t0, t0, -1        t0 = 0x12345FFF (305422335)
08  lui t1, 0x12346        t1 = 0x12346000 (305422336)
0c  addi t1, t1, -1        t1 = 0x12345FFF (305422335)
10  xor t2, t0, t1         t2 = 0x00000000 (0)
14  andi t3, t0, 0xFF      t3 = 0x000000FF (255)
18  srli t4, t0, 16        t4 = 0x00001234 (4660)
1c  xori t5, t3, -1        t5 = 0xFFFFFF00 (-256)
20  srai t6, t5, 4         t6 = 0xFFFFFFF0 (-16)
24  srli a0, t5, 4         a0 = 0x0FFFFFF0 (268435440)
28  slt a1, t5, zero       a1 = 0x00000001 (1)
2c  sltu a2, t5, zero      a2 = 0x00000000 (0)
30  sub a3, zero, t3       a3 = 0xFFFFFF01 (-255)
34  sw t0, -4(sp)          mem[60..63] = ff 5f 34 12
38  lb a4, -4(sp)          a4 = 0xFFFFFFFF (-1)
3c  lbu a5, -4(sp)         a5 = 0x000000FF (255)
40  sb t4, -4(sp)          mem[60..63] = 34 5f 34 12
44  lw a6, -4(sp)          a6 = 0x12345F34 (305422132)
48  auipc a7, 1            a7 = 0x00001048 (4168)

৮ · বাকি instruction-এর মানচিত্র — শাখা, jump, ecall, pseudo-instruction, M extension আর RV64I

শাখা আর jump — শুধু তালিকা

প্রোগ্রাম সবসময় সোজা লাইনে চলে না; if, লুপ আর function call-এর জন্য pc বদলাতে হয়। RV32I-এ এর জন্য ছয়টি শর্তসাপেক্ষ শাখা আর দুটি jump. কীভাবে এগুলো দিয়ে if-else, while, for আর switch বানানো হয়, তা পর্ব ২৯-এ (শাখা আর লুপ assembly-তে); function call আর ফেরা পর্ব ৩০-এ। এখানে শুধু মানচিত্র:

ecall আর ebreak

ecall (environment call) হলো প্রোগ্রামের পক্ষ থেকে “উপরের স্তরকে” ডাকা — সাধারণত operating system-কে, অর্থাৎ একটি system call. কোন সেবা চাই আর তার argument কী, তা register-এ রেখে ecall; CPU তখন একটি exception তুলে উঁচু privilege-এ OS-এর handler-এ চলে যায় (বিস্তারিত পর্ব ৩৮ আর OS কোর্সের system call পর্বে)। Linux-এ RISC-V-এর প্রচলিত নিয়ম: a7-এ system call নম্বর, a0–a5-এ argument, ফল a0-তে। RARS-এর মতো শিক্ষামূলক simulator-এর নিজস্ব সেবা-নম্বর থাকে (সংখ্যা ছাপা, string ছাপা, প্রোগ্রাম শেষ) — সেগুলো Linux-এর নম্বর নয়, simulator-এর Help-এ দেখে নিন। ebreak debugger-কে ডাকে: breakpoint বসানোর জন্য debugger কোডের ওই জায়গায় সাময়িকভাবে ebreak বসায়।

প্রচলিত pseudo-instruction আর তাদের আসল রূপ

লক্ষ করুন, প্রায় প্রতিটি সারিতে x0 আছে। শূন্য register না থাকলে এদের প্রতিটির জন্য আলাদা opcode লাগত। আর %pcrel_hi-তে সেই একই +0x800 সংশোধন কাজ করে, শুধু ধ্রুবকের বদলে “label আর বর্তমান pc-এর দূরত্ব”-এর ওপর। la-র রূপ একটু ভিন্ন হতে পারে: position-independent কোডে (যেমন Linux-এর shared library) assembler auipc + lw দিয়ে একটি টেবিল (GOT) থেকে ঠিকানা পড়ে।

M extension — গুণ আর ভাগ

RV32I-এ গুণ বা ভাগের instruction নেই! খুব ছোট chip-এ multiplier বাদ দিয়ে জায়গা বাঁচানো যায়; তখন compiler গুণ-ভাগকে library function (যেমন gcc-র __mulsi3) দিয়ে করে। প্রায় সব বাস্তব chip-এ অবশ্য M extension থাকে: mul (৬৪-বিট গুণফলের নিচের ৩২ বিট), mulh, mulhu, mulhsu (উপরের ৩২ বিট — signed×signed, unsigned×unsigned, signed×unsigned), div, divu, rem, remu. এদের ব্যবহার আর hardware পর্ব ২১-এর গুণের instruction-এ, আর শূন্য দিয়ে ভাগ বা INT_MIN ÷ −1-এ কী হয় (RISC-V trap করে না, নির্দিষ্ট মান দেয়), তা পর্ব ২২-এর ভাগের সীমানা-য়।

RV64I — ৬৪-বিটে কী বদলায়

আপনার ফোন বা ল্যাপটপের মতো ৬৪-বিট RISC-V সিস্টেম RV64I ব্যবহার করে। মূল পার্থক্যগুলো:

• Register ৬৪ বিটের। নাম আর ভূমিকা একই (x0–x31, a0–a7…)। add, sub, and এখন ৬৪-বিটে কাজ করে।
• নতুন load-store: ld/sd (৮ byte), আর lwu — এখন ৩২-বিট load-এর পরেও ৩২টি বাঁয়ের বিট ফাঁকা থাকে, তাই lw sign-extend করে আর lwu zero-extend.
• “w” পরিবার: addw, subw, addiw, sllw, srlw, sraw আর তাদের immediate রূপ — ৩২-বিটের হিসাব করে, তারপর ফলকে ৬৪ বিটে sign-extend করে। C-র int (৬৪-বিট সিস্টেমেও সাধারণত ৩২ বিট) এগুলো দিয়েই চলে। M extension-এও mulw, divw, remw ইত্যাদি যোগ হয়।
• Shift-এর পরিমাণ ৬ বিট (০–৬৩), আর বড় ধ্রুবক বানাতে বেশি instruction লাগতে পারে — যেকোনো ৬৪-বিট ধ্রুবকের জন্য compiler কখনো কখনো ছয়-আটটি instruction বানায়, বা মেমরির একটি ধ্রুবক-টেবিল থেকে ld করে।

৯ · C থেকে RV32I — a[i] += 5, আর ঘরে বসে চর্চার টুল

C-র একটি লাইন, a[i] += 5; (a একটি int array, যার শুরুর ঠিকানা a0-তে, আর i আছে a1-এ), RV32I-এ কী হয়? Load-store নিয়ম মানলে চারটি কাজ লাগবে: ঠিকানা হিসাব, মান আনা, যোগ, মান ফেরত রাখা। ঠিকানা হিসাবেই দুটি instruction, কারণ int ৪ byte — i-কে ৪ দিয়ে গুণ (২ ঘর বাঁয়ে shift) করে base-এর সাথে যোগ। ধরুন a = 0x100, i = 3, আর a[3] = 37. “পরে” চাপুন আর register-এর মান দেখুন:

1# a[i] += 5   (a0 = &a[0], a1 = i)2slli t0, a1, 2      # t0 = i * 43add  t0, a0, t0     # t0 = &a[i]4lw   t1, 0(t0)      # t1 = a[i]5addi t1, t1, 5      # t1 = a[i] + 56sw   t1, 0(t0)      # a[i] = t1

Compiler-ও প্রায় ঠিক এটাই বানায়। নিচে void f(int *a, int i) { a[i] += 5; }-এর জন্য RV32-লক্ষ্যের gcc-র -O2-এর মতো আউটপুট (হাতে সাজানো; register-এর নাম আর ক্রম সংস্করণভেদে একটু ভিন্ন হতে পারে):

# উদাহরণ — riscv64-unknown-elf-gcc -march=rv32i -mabi=ilp32 -O2 -S f.c এর মতো আউটপুট
f:
        slli    a1,a1,2
        add     a1,a0,a1
        lw      a5,0(a1)
        addi    a5,a5,5
        sw      a5,0(a1)
        ret

এখানে compiler t0-এর বদলে a1 আর a5 ব্যবহার করেছে — function-এর ভেতরে argument register-ও temporary-র মতো ব্যবহার করা যায়, কারণ calling convention-এ এগুলো caller-saved. পুরো C → assembly-র পথ, optimization আর x86-64 ও ARM-এর সাথে তুলনা পর্ব ৩১-এ (C থেকে assembly), আর C-এর দিক থেকে C প্রোগ্রামিং কোর্সের C আর assembly পর্বে।

ঘরে বসে চর্চা — simulator আর toolchain

এই পাতার simulator শেখার জন্য যথেষ্ট, কিন্তু পূর্ণ RISC-V assembly চালাতে কয়েকটি বিনামূল্যের টুল আছে (নাম আর সংস্করণ সময়ের সাথে বদলাতে পারে):

• RARS (RISC-V Assembler and Runtime Simulator) — Java-তে লেখা desktop simulator, MIPS-এর পরিচিত MARS থেকে এসেছে। Register আর মেমরি টেবিল দেখায়, ধাপে ধাপে চালানো যায়, ecall দিয়ে সংখ্যা ছাপা যায়।
• Venus — ব্রাউজারে চলে এমন RISC-V simulator; কিছু বিশ্ববিদ্যালয়ের কোর্সে ব্যবহার হয়। কিছু ইনস্টল করতে হয় না।
• Ripes — গ্রাফিক্যাল simulator, যা instruction-কে pipeline-এর ধাপে ধাপে চলতে দেখায় — পর্ব ৩২–৩৬ পড়ার সময় খুব কাজে লাগবে।
• আসল toolchain — একটি cross-compiler (আপনার x86 কম্পিউটারে চলে, কিন্তু RISC-V-এর কোড বানায়) আর QEMU emulator. Ubuntu-তে সাধারণত package থেকেই পাওয়া যায়:

# উদাহরণ — এই পাতার runner-এ চলে না; নিজের Linux-এ (Ubuntu/Debian ধরে নিয়ে, package-এর নাম ভিন্ন হতে পারে)
sudo apt install gcc-riscv64-linux-gnu qemu-user
riscv64-linux-gnu-gcc -O2 -S f.c -o f.s          # see the RV64 assembly
riscv64-linux-gnu-gcc -O2 -static hello.c -o hello
qemu-riscv64 ./hello                              # run a RISC-V binary on x86

# bare-metal toolchain (riscv64-unknown-elf-gcc) থাকলে ৩২-বিট কোডও দেখা যায়:
riscv64-unknown-elf-gcc -march=rv32i -mabi=ilp32 -O2 -S f.c   # f.s: assembly
riscv64-unknown-elf-gcc -march=rv32i -mabi=ilp32 -O2 -c f.c   # f.o: object file
riscv64-unknown-elf-objdump -d f.o                # machine code + disassembly

সবচেয়ে সহজ পথ অবশ্য ব্রাউজারের Compiler Explorer (godbolt.org): compiler তালিকা থেকে একটি RISC-V gcc বা clang বেছে -O2 দিলেই C-র পাশে assembly দেখা যায়। শেখার ভালো অভ্যাস: প্রথমে নিজে অনুমান করুন compiler কী বানাবে, তারপর মিলিয়ে দেখুন।

১০ · AI-এর যুগে RISC-V assembly

AI টুল RISC-V-এর সাধারণ কোড ভালোই লেখে, কিন্তু ঠিক এই পর্বের খুঁটিনাটিতে প্রায়ই ভুল করে — বিশেষ করে যেহেতু তার শেখার উপাদানে MIPS, ARM আর RISC-V-এর কোড মিশে আছে। প্রচলিত ভুলগুলো:

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

• প্রতিটি immediate −2048…2047-এর মধ্যে, আর shift-এর পরিমাণ ০–৩১
• lui-addi জোড়া নিজে জুড়ে দেখেছি: (hi << 12) + sign-extend(lo) = চাওয়া মান; নিচের ১২ বিট ≥ 0x800 হলে lui-তে +1 আছে
• register-এর নাম RISC-V-এর (a0–a7, t0–t6, s0–s11), MIPS বা ARM-এর নয়
• signed ডেটায় lb/lh, unsigned-এ lbu/lhu; আর store-এর operand-ক্রম sw rs2, off(rs1)
• কোডটি RARS, Venus বা Ripes-এ চালিয়েছি, বা cross-compiler দিয়ে assemble করে objdump -d দেখেছি
• নির্দিষ্ট chip বা extension নিয়ে দাবি (misaligned, Zba, fusion) সেই chip-এর নথিতে মিলিয়েছি