সরাসরি পর্বে যান
পর্ব ৭৩ · ৮৬-এর মধ্যে · মডিউল ১২

WebAssembly target — Haat থেকে browser-এ চলা code

The WebAssembly Target — Compiling Haat to Code That Runs in the Browser

Taught in Bangla, this lesson writes a compiler from Haat to a WebAssembly binary. It explains module sections, LEB128 encoding and structured control flow with block, loop and br_if instead of goto. It keeps Haat's semantics by checking division before i64.div_s can trap and keeping the call-depth limit and uninitialised-global errors, runs the module in the browser through imports and exports, tests it against the reference in the browser and Node 24, and compares with Clang's wasm32 output.

এই পর্বে যা শিখবেন

  • WebAssembly কেন একটি ভালো compiler target, আর এটি কোথায় সাধারণ CPU থেকে আলাদা
  • একটি .wasm ফাইলের গঠন: section, index, LEB128-এ সংখ্যা লেখা, হাতে আর কোডে
  • Haat-এর expression, statement, call আর global থেকে Wasm নির্দেশ তৈরি, Python-এ একটি সম্পূর্ণ compiler দিয়ে
  • Structured control flow: if আর while কীভাবে block/loop/br_if-এ নামে, আর অগঠিত CFG হলে কী করতে হয়
  • Trap বনাম ভাষার runtime error: শূন্য দিয়ে ভাগ, INT_MIN / -1 আর stack-এর সীমায় Haat-এর অর্থ রাখা
  • Browser আর Node-এ module চালানো, import/export আর BigInt, আর differential test দিয়ে সঠিকতার প্রমাণ

১ · WebAssembly — compiler-এর নতুন লক্ষ্য-যন্ত্র

পর্ব ০৪-এ হাতে লেখা ৪১ byte-এর একটি WebAssembly module দেখেছেন, যা শুধু qty * unit গুণ করত। পর্ব ৬১-এ একটি JavaScript ব্লক Haat-এর একটি গরম function-এর bytecode থেকে Wasm byte বানিয়েছিল, কিন্তু শুধু price-এর আকারের কোড নিত: একটি if, ধ্রুবক ভাজক, কোনো call নেই। এই পর্বে পুরো পথ: Haat-এর যেকোনো Int/Bool program, top-level function, if/else, while, call, recursion, global আর print সহ, একটি সত্যিকারের Wasm module-এ নামবে, আর browser সেটি চালাবে। এটি Haat-এর দ্বিতীয় back end; প্রথমটি RISC-V-এর, পর্ব ৭২-এ (Haat থেকে RISC-V assembly).

উপমা — রপ্তানির মানক কনটেইনার: চট্টগ্রাম বন্দর থেকে যে কনটেইনার যায়, তার মাপ, তালা আর কাগজের ফর্ম সারা পৃথিবীতে এক। কারখানা জানে না মাল কোন জাহাজে বা কোন দেশের ক্রেনে উঠবে; শুধু নিয়ম মেনে কনটেইনার ভরে, আর বন্দরের পরিদর্শক খোলার আগে কাগজ মিলিয়ে নেয়। Wasm সেই কনটেইনার। Haat-এর compiler কারখানা: নিয়ম মেনে byte ভরে। Browser-এর engine বন্দর: আগে যাচাই করে (কাগজ মেলানো), তারপর নিজের CPU-র জন্য machine code বানিয়ে চালায় (নিজের ক্রেনে তোলা)। কনটেইনারের বাইরে মাল যায় না: module শুধু সেই কাজগুলো করতে পারে যা host দরজা খুলে দেয়।

কেন এটি compiler-লেখকের কাছে আকর্ষণীয়? তিনটি কারণে। প্রথমত, এটি একটি stack machine, ঠিক Haat-এর VM-এর মতো (পর্ব ৫৯), তাই register allocation লাগে না: সেই কাজ engine নিজে করে। দ্বিতীয়ত, এটি যন্ত্র-নিরপেক্ষ: একই .wasm x86-64 ল্যাপটপে আর ARM ফোনে চলে। তৃতীয়ত, এটি নিরাপদ sandbox: module নিজের মেমরির বাইরে কিছু ছুঁতে পারে না, আর অনিরাপদ কোড চালানোর আগেই প্রত্যাখ্যাত হয়। ইতিহাসে এর আগে ছিল Mozilla-র asm.js (২০১৩, JavaScript-এর একটি কঠোর উপসেট) আর Google-এর (P)NaCl; চারটি বড় browser-এর দল মিলে ২০১৭ সালে Wasm-এর প্রথম সংস্করণ (MVP) চালু করে, যার নকশার বিবরণ Haas ও সহলেখকদের PLDI ২০১৭-এর প্রবন্ধে। W3C ২০১৯ সালে 1.0-কে Recommendation করে, আর ২০২৫ সালের সেপ্টেম্বরে Wasm 3.0 সম্পূর্ণ ঘোষিত হয় (garbage collection, ৬৪-বিট memory, exception handling, tail call সহ)।

বিষয়Haat VM (পর্ব ৫৮–৫৯)WebAssembly
মডেলstack machinestack machine, কিন্তু প্রতিটি মানের type জানা (i32 i64 f32 f64 …)
লাফJUMP, JUMP_IF_FALSE যেকোনো নির্দেশেশুধু গঠিত block/loop/if আর লেবেলের গভীরতায় br
চালানোর আগেকোনো যাচাই নেই; ভুল bytecode VM-কে বিভ্রান্ত করেপুরো module যাচাই (validation); ভুল type বা stack-এর গরমিল হলে চলবেই না
Local আর globalslot, cell, closureসংখ্যা-চিহ্নিত local আর global, closure নেই
চালায় কেPython-এ লেখা loopengine-এর compiler (machine code), কখনো কয়েক স্তরে

Haat-এর মান Wasm-এ কীভাবে বসবে, সেটি প্রথম সিদ্ধান্ত। Int ৬৪-বিট two's complement আর overflow-এ wrap করে (সিদ্ধান্ত ১৩); Wasm-এর i64.add, i64.sub, i64.mul ঠিক এভাবেই wrap করে, তাই Int → i64. Bool → i32 (0 বা 1), কারণ Wasm-এর তুলনা আর শর্ত i32-ই দেয় আর নেয়। Unit মানে কোনো ফল নেই। Str, closure আর function মান এই পর্বের বাইরে: এদের জন্য heap লাগে (পর্ব ৫৭, পর্ব ৭৫); শুধু print("লেখা") চলে, লেখাটি module-এর মেমরিতে রেখে।

২ · Module-এর গঠন আর LEB128

একটি .wasm ফাইল শুরু হয় ৮ byte দিয়ে: 00 61 73 6d (\0asm) আর version 01 00 00 00. তারপর কয়েকটি section, প্রতিটি একটি id byte, তার আকার, আর ভেতরের তথ্য। ক্রম নির্দিষ্ট: type (1), import (2), function (3), memory (5), global (6), export (7), code (10), data (11); id 0-এর custom section যেকোনো জায়গায় বসতে পারে আর engine সেটির অর্থ বোঝার চেষ্টা করে না। সব কিছু সংখ্যা দিয়ে চিহ্নিত: function-এর নম্বর আগে import-গুলোর (০ থেকে), তারপর module-এর নিজের function-এর।

ছবি ৭৩.১ — bazar.haat থেকে তৈরি ৪৬০ byte-এর module

বাঁয়ে কোন byte থেকে শুরু, মাঝে section আর id, ডানে আকার (id আর আকারের byte সহ)

bazar.wasm-এর section @0 শিরোনাম \0asm · version 1 8 @8 type · 1 ৭টি signature 36 @44 import · 2 print_i64, print_bool, … 64 @108 function · 3 ৩টি function → type 6 @114 global · 6 $depth, first, total, rounds 23 @137 export · 7 haat_main, haat_price, … 44 @181 code · 10 <main> — 172 byte price — 33 byte delivery — 19 byte 232 @413 custom · 0 haat.messages 47
ছবি ৭৩.১ — নিচের Python ব্লকের সত্যিকারের আউটপুট থেকে আঁকা। নীল অংশ “কী কী function আছে আর তাদের type”, হলুদ “কী বাইরে দেখা যায় আর কী মান বেঁচে থাকে”, সবুজ আসল নির্দেশ। ৮ + ৩৬ + ৬৪ + ৬ + ২৩ + ৪৪ + ২৩২ + ৪৭ = ৪৬০. Engine type আর function section দেখেই প্রতিটি function-এর signature জানে, তাই code section-এর প্রতিটি শরীর আলাদাভাবে, এমনকি সমান্তরালে, compile করা যায়।

সংখ্যা লেখার নিয়ম LEB128 (Little Endian Base 128): প্রতি byte-এ সংখ্যার ৭টি বিট, নিচের দিক আগে, আর byte-এর সবচেয়ে ওপরের বিট 1 মানে “আরও byte আছে”। ছোট সংখ্যা এক byte-এ ধরে, তাই module ছোট হয়। আকার আর index-এর জন্য unsigned রূপ; i32.const/i64.const-এর মানের জন্য signed রূপ, যেখানে শেষ byte-এর ৬ নম্বর বিট (0x40) চিহ্ন বলে, ঠিক two's complement-এর মতো।

1out = [0x42]   # i64.const2b, n = n & 0x7f, n >> 73শেষ নয়: out += [b ∣ 0x80]4শেষ: out += [b]5পড়া: Σ (b & 0x7f) × 128ᵏ
অবস্থা
n
b
byte
  1. Opcode. i64.const-এর opcode 0x42; তার পরেই মানটি signed LEB128-এ। 1000 বাইনারিতে 1111101000, ১০টি বিট, তাই এক byte-এ (৭ বিট) ধরবে না।
  2. নিচের ৭ বিট। 1000 & 0x7f = 1101000 = 0x68 (১০৪)। বাকি থাকল 1000 >> 7 = ৭।
  3. আরও আছে। বাকি ৭ শূন্য নয়, তাই এই byte-এর ওপরের বিট 1: 0x68 ∣ 0x80 = 0xe8.
  4. পরের ৭ বিট। 7 & 0x7f = 0x07, বাকি ০। এখন থামা যায় কি না দেখতে হবে চিহ্ন-বিট।
  5. শেষ byte. বাকি ০ আর 0x07-এর 0x40 বিট ০, অর্থাৎ পড়ার সময় ধনাত্মক ধরা হবে: থামা। ফল 42 e8 07, তিন byte; পর্ব ৬১-এর আউটপুটেও ঠিক এটাই ছিল।
  6. উল্টো পড়া। 0x68 + ৭ × ১২৮ = ১০৪ + ৮৯৬ = ১,০০০. সাবধান: 64-এর নিচের ৭ বিট 1000000, যার 0x40 বিট 1, তাই এক byte 40 লিখলে পড়া হবে −64; signed রূপে 64 = c0 00, দুই byte.

নিচের ব্লকে একই দুটি ফাংশন, সঙ্গে উল্টো দিকের পাঠক, যাতে প্রতিটি সংখ্যা লিখে আবার পড়ে মিলিয়ে দেখা যায়। এগুলোই এই পর্বের compiler-এর (haat_wasm.py) uleb আর sleb, হুবহু।

# LEB128: Wasm-এর প্রতিটি সংখ্যা এভাবে লেখা — ছোট সংখ্যা ছোট জায়গায়
def uleb(n):                         # unsigned: section-এর আকার, index, গণনা
    out = []
    while True:
        b, n = n & 0x7f, n >> 7      # নিচের ৭ বিট আলাদা, বাকিটা ডানে সরে
        if n == 0: return out + [b]
        out.append(b | 0x80)         # ওপরের বিট 1 = “আরও byte আছে”

def sleb(n):                         # signed: i32.const / i64.const-এর মান
    out = []
    while True:
        b, n = n & 0x7f, n >> 7      # Python-এর >> চিহ্ন রাখে: -1 >> 7 == -1
        if (n == 0 and not b & 0x40) or (n == -1 and b & 0x40): return out + [b]
        out.append(b | 0x80)

def read_sleb(bs):                   # উল্টো পথ: byte থেকে সংখ্যা
    n = shift = 0
    for b in bs:
        n |= (b & 0x7f) << shift; shift += 7
        if not b & 0x80: break
    return n - (1 << shift) if b & 0x40 else n   # শেষ byte-এর 0x40 বিট = ঋণাত্মক

hexs = lambda bs: " ".join(f"{b:02x}" for b in bs)
for v in (1000, 5000, 63, 64, -1, -64, -65, -9223372036854775807 - 1):
    s = sleb(v)
    print(f"{v} → {hexs(s)}  ({len(s)} byte, ফেরত {'ঠিক' if read_sleb(s) == v else 'ভুল'})")
print("uleb(64) =", hexs(uleb(64)), "· sleb(64) =", hexs(sleb(64)), "· uleb(229) =", hexs(uleb(229)))

আসল আউটপুট (ব্রাউজারের Python):

1000 → e8 07  (2 byte, ফেরত ঠিক)
5000 → 88 27  (2 byte, ফেরত ঠিক)
63 → 3f  (1 byte, ফেরত ঠিক)
64 → c0 00  (2 byte, ফেরত ঠিক)
-1 → 7f  (1 byte, ফেরত ঠিক)
-64 → 40  (1 byte, ফেরত ঠিক)
-65 → bf 7f  (2 byte, ফেরত ঠিক)
-9223372036854775808 → 80 80 80 80 80 80 80 80 80 7f  (10 byte, ফেরত ঠিক)
uleb(64) = 40 · sleb(64) = c0 00 · uleb(229) = e5 01

1000 আর 5000 দুই byte-এ, যা bazar.haat-এর দুটি ধ্রুবক। 63 এক byte-এ, কিন্তু 64 দুই byte-এ, কারণ এক byte 40 signed পাঠকের কাছে −64. উল্টো দিকে −64 এক byte-এ (40) আর −65 দুই byte-এ। ৬৪-বিটের সবচেয়ে ছোট সংখ্যা ১০ byte নেয়: ৯ × ৭ = ৬৩ বিট যথেষ্ট নয়। শেষ লাইনে unsigned আর signed-এর পার্থক্য: unsigned-এ 64 = 40 (চিহ্নের প্রশ্ন নেই), আর ২২৯ = e5 01, যা bazar-এর code section-এর আকার, ছবি ৭৩.১-এর ২৩২ byte-এর মধ্যে id আর এই দুই byte বাদে।

৩ · Haat থেকে Wasm — অনুবাদের নিয়ম

এবার compiler. উৎস হিসেবে নেওয়া হয়েছে Haat-এর AST, পর্ব ৬২-এর IR নয়। কারণ: AST-তে if আর while এখনো গঠিত, আর Wasm-ও গঠিত control flow চায়; IR-এর CFG থেকে আবার গঠন খুঁজে বের করতে হতো (অংশ ৪-এর শেষে)। Parser হিসেবে পর্ব ৬২-এর haat_front.py হুবহু ব্যবহার হয়েছে (পাতার নিচে লুকানো সহায়ক ফাইল); এই পর্বের নিজের কোড haat_wasm.py, প্রায় ২৫০ লাইন, তাও পাতায় দেওয়া আছে। এর দুটি স্তর: FnGen প্রতিটি function-এর জন্য ("i64.const", 1000)-এর মতো নির্দেশের তালিকা বানায়, আর Module.binary() সেই তালিকাকে section-সহ byte-এ encode করে। নিয়মগুলো এক জায়গায়:

নিয়ম ৭৩.১ — Haat → Wasm (Int/Bool উপসেট)
  1. Int ধ্রুবক → i64.const n; true/false → i32.const 1/0. Parameter আর let/var → নতুন local (একই নামের ছায়া-variable আলাদা local পায়); top-level let/var → mutable Wasm global.
  2. a op b → a-র কোড, b-র কোড, তারপর একটি নির্দেশ (i64.add, i64.lt_s …; Bool-এর == = i32.eq). Stack machine-এ বাঁ থেকে ডানে মূল্যায়ন (সিদ্ধান্ত ১২) আপনাআপনি আসে। -a → i64.const 0; a; i64.sub; !a → a; i32.eqz.
  3. a && b → a; if (result i32) b else i32.const 0 end; a || b → a; if (result i32) i32.const 1 else b end: ডান দিক শুধু দরকার হলে চলে।
  4. f(x, y) → argument বাঁ থেকে ডানে, গভীরতার পরীক্ষা, তারপর call k. print(e) → e; call print_i64 বা print_bool (host-এর function).
  5. if/else → if … else … end; while c { B } → block loop c i32.eqz br_if 1 B br 0 end end; return e → e; return. ফল-ওয়ালা function-এর শেষে একটি unreachable.
  6. a / b আর a % b → ভাজক শূন্য কি না পরীক্ষা, আর /-এ b = -1 হলে 0 - a (অংশ ৫); ভাজক যদি শূন্য-নয় এমন একটি লেখা সংখ্যা হয়, পরীক্ষা লাগে না।

শেষ নিয়মের ছোট optimization-টি পর্ব ৬১-এর যুক্তিই: Haat-এ সংখ্যার লেখায় চিহ্ন থাকে না (- একটি আলাদা unary operator), তাই লেখা ভাজক কখনো −1 নয়, আর শূন্য না হলে কোনো পরীক্ষাই দরকার নেই। এটি অনুমান নয়, static প্রমাণ, তাই কোনো guard লাগে না। নিচের ব্লক bazar.haat compile করে, module-এর section পড়ে দেখায় আর price-এর নির্দেশগুলো wat() দিয়ে WAT-ধাঁচে ছাপে (WAT হলো Wasm-এর লেখ্য রূপ)।

# bazar.haat → .wasm: haat_wasm.py দিয়ে compile, তারপর section-এর তালিকা, price-এর WAT আর পুরো byte
import base64
from haat_wasm import Module, parse, wat
src = open("examples/bazar.haat", encoding="utf-8").read()
mod = Module(parse(src))
data = mod.binary()
NAMES = {0: "custom", 1: "type", 2: "import", 3: "function", 5: "memory",
         6: "global", 7: "export", 10: "code", 11: "data"}

def read_uleb(bs, i):                 # (মান, পরের অবস্থান)
    n = shift = 0
    while True:
        b = bs[i]; i += 1; n |= (b & 0x7f) << shift; shift += 7
        if b < 0x80: return n, i

print(f"মোট {len(data)} byte; প্রথম ৮টি: {data[:8].hex(' ')}")
i = 8
while i < len(data):
    sid = data[i]; size, j = read_uleb(data, i + 1)
    print(f"  section {sid:2} {NAMES[sid]:<8} {size:4} byte")
    i = j + size
print("global:", ", ".join(n for n, _ in mod.globals))
fn = mod.bodies[1]                    # 0 = <main>, 1 = price, 2 = delivery
print(f"price: {len(fn.code)}টি নির্দেশ, {len(fn.body_bytes())} byte\n{wat(fn.code)}")
b64 = base64.b64encode(data).decode()
print("base64:"); print("\n".join(b64[k:k + 60] for k in range(0, len(b64), 60)))

আসল আউটপুট (ব্রাউজারের Python):

মোট 460 byte; প্রথম ৮টি: 00 61 73 6d 01 00 00 00
  section  1 type       34 byte
  section  2 import     62 byte
  section  3 function    4 byte
  section  6 global     21 byte
  section  7 export     42 byte
  section 10 code      229 byte
  section  0 custom     45 byte
global: $depth, first, total, rounds
price: 18টি নির্দেশ, 33 byte
  local.get 0
  local.get 1
  i64.mul
  local.set 2
  local.get 2
  i64.const 1000
  i64.ge_s
  if
    local.get 2
    local.get 2
    i64.const 10
    i64.div_s
    i64.sub
    return
  end
  local.get 2
  return
  unreachable
base64:
AGFzbQEAAAABIgdgAX4AYAF/AGACf38AYAN/f38AYAAAYAJ+fgF+YAF+AX4C
PgQDZW52CXByaW50X2k2NAAAA2VudgpwcmludF9ib29sAAEDZW52CXByaW50
X3N0cgACA2VudgVlcnJvcgADAwQDBAUGBhUEfwFBAAt+AUIAC34BQgALfgFC
AAsHKgMJaGFhdF9tYWluAAQKaGFhdF9wcmljZQAFDWhhYXRfZGVsaXZlcnkA
BgrlAQOsAQBCAkKIBCMAQegHTwRAQQFBCkENEAMACyMAQQFqJAAQBSMAQQFr
JABCAkKIBCMAQegHTwRAQQFBCkEmEAMACyMAQQFqJAAQBSMAQQFrJAAjAEHo
B08EQEEBQQpBHRADAAsjAEEBaiQAEAYjAEEBayQAfCQBIwEQAEIAJAJCACQD
AkADQCMCQognU0UNASMCQuIJfCQCIwNCAXwkAwwACwsjAhAAIwNCAX0QAAsh
AQF+IAAgAX4hAiACQugHWQRAIAIgAkIKf30PCyACDwALEwAgAELoB1kEQEIA
DwVCPA8LAAsALQ1oYWF0Lm1lc3NhZ2VzZGl2aXNpb24gYnkgemVybwpzdGFj
ayBvdmVyZmxvdw==

৪৬০ byte, আর section-এর আকার ছবি ৭৩.১-এর সঙ্গে মেলে। চারটি global: $depth (call-এর গভীরতা গোনার i32, অংশ ৫) আর তিনটি top-level variable. price ১৮টি নির্দেশ, ৩৩ byte: local.get 0; local.get 1; i64.mul; local.set 2 = let p = qty * unit;, local ২ হলো p. তুলনার i64.ge_s একটি i32 রাখে, যা if খেয়ে ফেলে। ভাজক লেখা 10, তাই সরাসরি i64.div_s. দুটি return-এর পরে শেষের unreachable কখনো চলে না; validator-কে বলে “এখানে পৌঁছানো অসম্ভব”, নইলে ফল-ছাড়া শেষ দেখে সে module প্রত্যাখ্যান করত। নিচের base64 লেখাটি পুরো module; অংশ ৬-এর JavaScript ব্লক ঠিক এই লেখা নিয়ে চালাবে।

৪ · Structured control flow — block, loop আর br_if

CPU-তে লাফ মানে “এই ঠিকানায় যাও”, আর Haat VM-এর JUMP 22-ও তাই। Wasm-এ এমন কোনো নির্দেশ নেই। আছে তিনটি গঠন, প্রতিটি end-এ শেষ, আর প্রতিটি একটি লেবেল তৈরি করে। br k মানে “ভেতর থেকে গুনে k-তম লেবেলে যাও”: br 0 সবচেয়ে ভেতরের, br 1 তার বাইরেরটি। লেবেলের অর্থ নির্ভর করে গঠনের ওপর: block-এর লেবেল তার end-এর পরে (বেরিয়ে যাওয়া), আর loop-এর লেবেল তার শুরুতে (আবার ঘোরা)। এটি structured programming-এর নিয়ম, যন্ত্রের স্তরে বাধ্যতামূলক করা: একে বলে structured control flow. C বা Java-র labeled break-এর সঙ্গে মিল লক্ষ করুন (পর্ব ২৭)।

Haat-এর while-এর ছাঁচ তাই: বাইরে একটি block (বেরোনোর দরজা), ভেতরে একটি loop (ফেরার দরজা)। শর্ত মিথ্যা হলে br_if 1 বাইরের দরজা দিয়ে বেরোয়; শরীরের শেষে br 0 আবার শুরুতে ফেরে। নিচে bazar.haat-এর loop, browser-এর engine যা করে তা ধাপে ধাপে, প্রতিটি মান লেখকের lab-এ একটি ছোট Wasm-ব্যাখ্যাকারী দিয়ে এই নির্দেশগুলোর ওপর চালিয়ে মেলানো।

1block ;; লেবেল 12  loop ;; লেবেল 03    global.get 2 ;; total4    i64.const 50005    i64.lt_s6    i32.eqz7    br_if 18    … total += 12509    … rounds += 110    br 011  end12end
Engine-এর অবস্থা
stack
total
rounds
লেবেল
  1. দুই দরজা। block আর loop ঢোকার সময় কিছু চলে না, শুধু দুটি লেবেল তৈরি হয়। ভেতর থেকে গুনলে loop = 0, block = 1. Global ২ হলো total, ৩ হলো rounds.
  2. শর্তের মান। global.get 2 আর i64.const 5000: stack-এ [0, 5000].
  3. শর্ত উল্টানো। i64.lt_s দুটি নামিয়ে 1 রাখে (০ < ৫০০০), আর i32.eqz সেটিকে 0 করে। কেন উল্টাই? কারণ br_if লাফ দেয় সত্য হলে, আর আমরা লাফ চাই শর্ত মিথ্যা হলে।
  4. লাফ নেই। br_if 1 0 নামায়, তাই পরের নির্দেশে যায়। Stack আবার খালি।
  5. শরীর। দুটি assignment: total = ১২৫০, rounds = ১. প্রতিটি global.get, i64.const, i64.add, global.set: চারটি নির্দেশ।
  6. ফেরা। br 0 সবচেয়ে ভেতরের লেবেলে যায়; সেটি loop, যার লেবেল শুরুতে, তাই আবার global.get 2. প্রতি ঘোরা ১৪টি নির্দেশ।
  7. চার ঘোরার পরে। ১২৫০ × ৪ = ৫০০০, rounds = ৪. শর্তের জন্য stack-এ [5000, 5000].
  8. শর্ত মিথ্যা। ৫০০০ < ৫০০০ মিথ্যা: i64.lt_s 0 দেয়, i32.eqz 1.
  9. বেরোনো। br_if 1 1 নামিয়ে লাফ দেয় লেবেল 1-এ, অর্থাৎ block-এর end-এর পরে, যেখানে print(total)-এর global.get 2; call 0. পুরো loop-এ চলেছে ২ + ৪ × ১৪ + ৫ = ৬৩টি নির্দেশ।

এই ছাঁচের একটি গভীর লাভ আছে। প্রতিটি গঠনের শুরু আর শেষে stack-এর type নির্দিষ্ট, আর প্রতিটি লাফের লক্ষ্য একটি পরিচিত লেবেল; তাই engine একবার ওপর থেকে নিচে পড়েই পুরো function-এর stack-এর type যাচাই করতে পারে, যা validation-এর মূল কাজ। পর্ব ৫৯-এর VM-এ ভুল JUMP stack-এর গভীরতা গোলমাল করলে কেউ ধরত না; Wasm-এ এমন module চালানোর আগেই বাতিল। নিয়মটি Haat-এর পর্ব ৩৮-এর soundness-এর মতো: যাচাই পেরোলে চলার সময় type-এর ভুল হবে না।

যদি উৎস একটি এলোমেলো CFG হয়?

Haat-এর AST গঠিত, তাই আমাদের কাজ সহজ। কিন্তু C-র goto, বা optimization-এর পরের control flow graph (পর্ব ৬২, ৬৩) থেকে কোড লিখতে হলে গঠন আবার খুঁজে বের করতে হয়। Emscripten-এর জন্য Alon Zakai ২০১১ সালের দিকে Relooper অ্যালগরিদম বর্ণনা করেন, যা CFG থেকে loop আর block বের করে; LLVM-এর WebAssembly back end নিজস্ব একটি pass (CFGStackify) দিয়ে block আর loop বসায়, আর Norman Ramsey-র “Beyond Relooper” (ICFP ২০২২) dominator tree (পর্ব ৬৩) থেকে একই কাজের একটি পরিষ্কার পুনরাবৃত্ত রূপ দেয়। বাধা হলো irreducible control flow: যে loop-এ দুটি আলাদা দিক থেকে ঢোকা যায়। তখন কোড কপি করে (node splitting) বা একটি “কোথায় যাব” variable আর br_table-এর dispatch loop দিয়ে সমাধান করতে হয়; LLVM-এর Wasm back end-এ এর জন্য আলাদা একটি pass আছে বলে জানা যায়।

৫ · অর্থ রক্ষা — ভাগ, trap আর Haat-এর runtime error

একটি back end-এর সবচেয়ে বিপজ্জনক ভুল হলো লক্ষ্য-যন্ত্রের অর্থকে ভাষার অর্থ ধরে নেওয়া। WebAssembly-র specification (webassembly.github.io-র WebAssembly 3.0, “Numerics” অংশ, এই পর্ব লেখার সময় পড়া) বলে: idiv_s-এর ফল অসংজ্ঞায়িত যদি ভাজক 0 হয়, অথবা ভাগফল 2N−1 হয় (যেমন (−263) / (−1) = 263, যা ৬৪-বিট signed-এ ধরে না)। irem_s-এর একমাত্র অসংজ্ঞায়িত ক্ষেত্র ভাজক 0; INT_MIN % -1 = 0, নির্ধারিত। Wasm-এ অসংজ্ঞায়িত ফল মানে trap: কাজ সঙ্গে সঙ্গে থামে আর host-এর কাছে একটি error যায় (JavaScript-এ WebAssembly.RuntimeError). C-র undefined behavior-এর মতো “যা খুশি” নয়; trap নির্ধারিত আর নিরাপদ।

ক্ষেত্রWasm নির্দেশ একা (Node 24-এ সত্যিকারের run)Haat-এর নিয়ম (reference-এর runtime.py)
7 / 0, 7 % 0trap: RuntimeError: divide by zero (অবস্থান নেই)line:col: runtime error: division by zero, / বা %-এর অবস্থানে (সিদ্ধান্ত ২৪, ২৬)
INT_MIN / -1trap: RuntimeError: divide result unrepresentablewrap: ফল INT_MIN (সিদ্ধান্ত ১৩)
INT_MIN % -10, trap নেই0 (সিদ্ধান্ত ১৩)
১,০০০-এর বেশি গভীর callengine-এর নিজের সীমায় পৌঁছালে তবেই trap; সীমা engine-ভেদে আলাদাstack overflow, ঠিক ১,০০০-এ, callee-র অবস্থানে (সিদ্ধান্ত ২৬)

তাই compiler নিজে তিনটি পাহারা লেখে। ভাগ: দুটি মান দুটি সহায়ক local-এ ($x, $y) নামিয়ে আগে $y শূন্য কি না দেখা; শূন্য হলে host-এর error function-কে কারণ আর অবস্থান দিয়ে ডাকা, তারপর unreachable. /-এর বেলায় $y = -1 হলে ভাগই নয়, 0 - $x: যেকোনো x-এর জন্য x / -1 = -x, আর i64.sub wrap করে, তাই INT_MIN থেকে INT_MIN-ই আসে। %-এ শুধু শূন্যের পরীক্ষা, কারণ i64.rem_s নিজেই Haat-এর মতো। গভীরতা: global $depth; প্রতিটি call-এর argument হিসাব হয়ে যাওয়ার পরে $depth ≥ 1000 হলে stack overflow, নইলে ১ বাড়িয়ে call আর ফিরে ১ কমানো, ঠিক reference-এর interp.py-র ক্রমে। শুরু-না-হওয়া global: কোনো function যদি একটি top-level variable ছোঁয়, সেটির জন্য একটি i32 পতাকা-global; let চলার পরে পতাকা 1. Function-এর ভেতরে পড়া বা লেখার আগে পতাকা 0 হলে 'k' is not initialized yet (সিদ্ধান্ত ১৮)।

বার্তার লেখা module-এর ভেতরেই থাকে, haat.messages নামের একটি custom section-এ: division by zero, stack overflow, তারপর প্রয়োজনমতো 'k' is not initialized yet. Wasm শুধু ক্রমিক নম্বর (০, ১, ২ …), লাইন আর কলাম পাঠায়; host সেই section পড়ে পুরো বার্তা বানায়। নিচে err_divzero.haat-এর share(1000, 0), ধাপে ধাপে।

1local.get 0 ;; total2local.get 1 ;; people3local.set 3 ;; $y4local.set 2 ;; $x5local.get 36i64.eqz7if8  i32.const 0 ;; বার্তা9  i32.const 3 ;; line10  i32.const 18 ;; col11  call 3 ;; env.error12  unreachable13end … i64.div_s …
Engine আর host
stack
$x · $y
host
  1. দুই মান। share(1000, 4) আগেই ২৫০ ছেপেছে; এখন share(1000, 0): parameter ০ আর ১ stack-এ। ($x, $y local ২ আর ৩, Wasm-এ শুরুতে 0.)
  2. সহায়ক local. ওপরের মান আগে নামে, তাই আগে $y = ০, পরে $x = ১০০০. এখন দুটিকে যতবার খুশি পড়া যায়।
  3. পরীক্ষা। local.get 3; i64.eqz: ভাজক শূন্য, তাই 1 (i32).
  4. শাখা। if 1 নামিয়ে ভেতরে ঢোকে। এই ভেতরের কোড সাধারণ ভাগে কখনো চলে না, শুধু কয়েকটি byte জায়গা নেয়।
  5. কারণ আর অবস্থান। তিনটি i32.const: বার্তার নম্বর ০ (division by zero), লাইন ৩, কলাম ১৮, অর্থাৎ return total / people;-এর /, সিদ্ধান্ত ২৪-এর নিয়মে।
  6. Host-কে জানানো। call 3 = import-এর চতুর্থটি, env.error. Host haat.messages-এর ০ নম্বর লাইন নিয়ে 3:18: runtime error: division by zero লিখে রাখে, তারপর ফেরে।
  7. Trap. unreachable নির্ধারিত trap: engine সব Wasm frame (share, <main>) ফেলে দিয়ে host-এর কাছে RuntimeError: unreachable ছোড়ে। Node 24-এ সত্যিকারের run-এ ঠিক এই বার্তা এসেছে।
  8. Haat-এর বার্তা। Host error ধরে, আর লিখে রাখা বার্তাটি ছাপে। আউটপুট reference-এর সমান: 250, তারপর 3:18: runtime error: division by zero. পাহারা ছাড়া (শুধু i64.div_s) একই program দিত RuntimeError: divide by zero, কোনো লাইন-কলাম ছাড়া।

দাম কত? share-এর শরীর পাহারাসহ ২৭টি নির্দেশ, পাহারা ছাড়া হতো ৫টি (local.get 0; local.get 1; i64.div_s; return; unreachable). সাধারণ পথে বাড়তি কাজ হলো দুটি local-এ রাখা, একটি তুলনা আর দুটি শর্তযুক্ত শাখা, যা engine-এর compiler সস্তা তুলনা আর প্রায় সবসময় সঠিক অনুমান করা শাখায় নামায়। Haat-এর মতো ভাষার জন্য এটি ন্যায্য দাম: ভাষার নিয়মই বলে ভাগ কখনো “যা খুশি” হবে না। C-তে নিয়ম উল্টো, আর অংশ ৮-এ দেখবেন Clang সেই সুযোগ কীভাবে নেয়।

৬ · Browser-এ চালানো — import, export আর host

Wasm module নিজে কিছু ছাপতে পারে না, ঘড়ি দেখতে পারে না, ফাইল খুলতে পারে না: সেসব host-এর ক্ষমতা। Module যা চায় তা import করে (এখানে env নামের থেকে চারটি function), আর যা দিতে চায় তা export করে (haat_main আর প্রতিটি Haat function, পর্ব ৭১-এর symbol-নামের নিয়মে haat_ উপসর্গসহ)। Browser-এর বাইরে একই কাজের মানক রূপ WASI, যেখানে host ফাইল আর ঘড়ির মতো সেবা দেয়। Haat-এর Int ৬৪-বিট, আর JavaScript-এর সাধারণ number ২৫৩-এর ওপরে নির্ভুল নয়; তাই JavaScript API-তে প্রতিটি i64 আসে-যায় BigInt হয়ে (2n, 520n). লেখকের Node 24-এ haat_price(2, 520) ডাকলে সত্যিই এসেছে TypeError: Cannot convert 2 to a BigInt.

নিচের JavaScript ব্লকে অংশ ৩-এর Python ব্লকের ছাপা base64 হুবহু বসানো। ব্লকটি আগে byte পড়ে section-এর মানচিত্র ছাপে (একটি ছোট module explorer), তারপর browser-এর API দিয়ে import আর export-এর নাম দেখায়, host-এর চারটি function দিয়ে module চালায়, আর শেষে export করা haat_price-কে সরাসরি ডাকে।

// bazar.wasm: ওপরের Python ব্লকের ছাপা base64, হুবহু। section পড়া, তারপর browser-এর engine-এ চালানো
const B64 = `AGFzbQEAAAABIgdgAX4AYAF/AGACf38AYAN/f38AYAAAYAJ+fgF+YAF+AX4C
PgQDZW52CXByaW50X2k2NAAAA2VudgpwcmludF9ib29sAAEDZW52CXByaW50
X3N0cgACA2VudgVlcnJvcgADAwQDBAUGBhUEfwFBAAt+AUIAC34BQgALfgFC
AAsHKgMJaGFhdF9tYWluAAQKaGFhdF9wcmljZQAFDWhhYXRfZGVsaXZlcnkA
BgrlAQOsAQBCAkKIBCMAQegHTwRAQQFBCkENEAMACyMAQQFqJAAQBSMAQQFr
JABCAkKIBCMAQegHTwRAQQFBCkEmEAMACyMAQQFqJAAQBSMAQQFrJAAjAEHo
B08EQEEBQQpBHRADAAsjAEEBaiQAEAYjAEEBayQAfCQBIwEQAEIAJAJCACQD
AkADQCMCQognU0UNASMCQuIJfCQCIwNCAXwkAwwACwsjAhAAIwNCAX0QAAsh
AQF+IAAgAX4hAiACQugHWQRAIAIgAkIKf30PCyACDwALEwAgAELoB1kEQEIA
DwVCPA8LAAsALQ1oYWF0Lm1lc3NhZ2VzZGl2aXNpb24gYnkgemVybwpzdGFj
ayBvdmVyZmxvdw==`;
const bytes = Uint8Array.from(atob(B64.replace(/\s/g, "")), (c) => c.charCodeAt(0));
const uleb = (i) => { let n = 0, s = 0, b; do { b = bytes[i++]; n |= (b & 0x7f) << s; s += 7; } while (b & 0x80); return [n, i]; };
const NAME = { 0: "custom", 1: "type", 2: "import", 3: "function", 6: "global", 7: "export", 10: "code" };
for (let i = 8; i < bytes.length; ) {            // section-এর মানচিত্র: id, আকার, কোন byte থেকে
  const id = bytes[i], [size, start] = uleb(i + 1);
  console.log(`@${String(i).padStart(3)}  ${NAME[id].padEnd(8)} ${String(size).padStart(3)} byte`);
  i = start + size;
}
console.log("valid:", WebAssembly.validate(bytes)); const mod = new WebAssembly.Module(bytes);
console.log("import:", WebAssembly.Module.imports(mod).map((x) => x.name).join(", "));
console.log("export:", WebAssembly.Module.exports(mod).map((x) => x.name).join(", "));
const msgs = new TextDecoder().decode(WebAssembly.Module.customSections(mod, "haat.messages")[0]).split("\n");
let error = null;
const env = {                                    // host: Haat-এর print আর runtime error
  print_i64: (v) => console.log(String(v)),     // i64 JavaScript-এ আসে BigInt হয়ে
  print_bool: (b) => console.log(b ? "true" : "false"),
  print_str: () => {},                           // bazar-এ লাগে না
  error: (k, line, col) => { error = `${line}:${col}: runtime error: ${msgs[k]}`; },
};
WebAssembly.instantiate(mod, { env }).then((inst) => {
  try { inst.exports.haat_main(); } catch (e) { console.log(error ?? String(e)); }
  console.log("haat_price(2n, 520n) = " + inst.exports.haat_price(2n, 520n));
});

আসল আউটপুট (ব্রাউজারের JavaScript):

@  8  type      34 byte
@ 44  import    62 byte
@108  function   4 byte
@114  global    21 byte
@137  export    42 byte
@181  code     229 byte
@413  custom    45 byte
valid: true
import: print_i64, print_bool, print_str, error
export: haat_main, haat_price, haat_delivery
996
5000
3
haat_price(2n, 520n) = 936

Section-এর শুরু (@8, @44 …) ছবি ৭৩.১-এর বাঁ দিকের সংখ্যা। WebAssembly.validate পুরো module-কে নিয়মের সঙ্গে মিলিয়ে true দিয়েছে; একটি byte ভুল হলে এখানে false আসত, আর new WebAssembly.Module একটি CompileError ছুড়ত। তারপর তিনটি লাইন 996, 5000, 3: bazar.haat-এর আউটপুট, reference-এর python -B haat.py run-এর সঙ্গে হুবহু, এবার browser-এর নিজের Wasm compiler-এ তৈরি machine code থেকে। শেষ লাইনে JavaScript সরাসরি Haat-এর একটি function ডেকেছে: export-এর সুবাদে Haat-এর price এখন একটি সাধারণ JavaScript function-এর মতোই ব্যবহারযোগ্য।

print_str এখানে খালি, কারণ bazar-এ লেখা ছাপা নেই। যে program print("…") করে, সেখানে compiler লেখাটি একটি data section-এ রাখে আর একটি linear memory (৬৪ KiB-এর একটি page) export করে; print_str(ঠিকানা, দৈর্ঘ্য) পেয়ে host সেই মেমরি থেকে UTF-8 byte পড়ে। এই মেমরিই Wasm-এর সব heap-এর ভিত্তি: C-র malloc, Rust-এর Vec সবই সেখানে। Haat-এর Str আর closure পুরোপুরি আনতে হলে এই মেমরিতে একটি allocator আর পর্ব ৭৫-এর মতো garbage collector লাগবে, অথবা Wasm 3.0-এর GC সুবিধা, যেখানে struct আর array-এর জায়গা engine-এর নিজের collector সামলায়।

একটি খুঁটিনাটি: browser-এ module চালানো দুই ধাপে। WebAssembly.compile (বা new WebAssembly.Module) byte যাচাই করে machine code বানায়; এটি host-নিরপেক্ষ, তাই একই compile-করা module বারবার ব্যবহার করা যায়। WebAssembly.instantiate তারপর import জোড়া দেয়, global আর memory তৈরি করে, আর একটি চলমান instance দেয়। Import-এর নাম বা type না মিললে এই দ্বিতীয় ধাপে LinkError আসে, যা পর্ব ৭৪-এর linker-এর “undefined symbol”-এর আত্মীয়। নেটওয়ার্ক থেকে আসা বড় module-এর জন্য WebAssembly.instantiateStreaming byte নামতে নামতেই compile শুরু করে; section-এর নির্দিষ্ট ক্রম (আগে type আর function, পরে code) ঠিক এটিই সম্ভব করে।

৭ · যাচাই — browser আর Node 24-এ differential test

একটি compiler কয়েকটি উদাহরণে ঠিক চললেই সঠিক নয়। পরীক্ষার নিয়ম পর্ব ৬২ থেকে একই: reference-এর run হলো মানদণ্ড, আর haat_gen.py (পর্ব ৬২-এর, হুবহু) seed থেকে এলোমেলো কিন্তু সঠিক program বানায়: global, ১–৩টি function, if/else, সীমিত while, &&/||, wrap হওয়া বড় সংখ্যা আর কখনো শূন্য দিয়ে ভাগ। প্রথম ২০০টি seed-এর reference-আউটপুটের digest পাতায় দেওয়া আছে। নিচের ব্লক এটিই differential testing, কিন্তু এবার প্রতিটি program সত্যিই browser-এর WebAssembly engine-এ চলে: Python byte বানায়, Pyodide সেগুলো JavaScript-এর WebAssembly.compile-কে দেয়, আর host-এর function Python-এ লেখা।

# browser-এর সত্যিকারের Wasm engine-এ চালিয়ে reference-এর সঙ্গে মেলানো (Pyodide থেকে JavaScript-এর WebAssembly)
import hashlib, js
from pyodide.ffi import to_js, create_proxy
from haat_wasm import compile_haat, Unsupported
from haat_gen import gen_program

async def run_wasm(data):             # Python-এর byte → WebAssembly.Module → চালানো → ছাপা লাইন
    mod = await js.WebAssembly.compile(to_js(data))
    msgs = bytes(js.Uint8Array.new(js.WebAssembly.Module.customSections(mod, "haat.messages")[0]).to_py()).decode().split("\n")
    lines, mem = [], []
    fns = [create_proxy(f) for f in (lambda v: lines.append(str(v)), lambda b: lines.append("true" if b else "false"),
           lambda p, n: lines.extend(bytes(js.Uint8Array.new(mem[0].buffer, p, n).to_py()).decode().split("\n")),
           lambda k, l, c: lines.append(f"{l}:{c}: runtime error: {msgs[k]}"))]
    env = to_js({"env": dict(zip(("print_i64", "print_bool", "print_str", "error"), fns))}, dict_converter=js.Object.fromEntries)
    inst = await js.WebAssembly.instantiate(mod, env)
    mem.append(getattr(inst.exports, "memory", None))
    try: inst.exports.haat_main()
    except Exception as e:            # trap: Haat-এর error import আগেই বার্তা লিখেছে, নইলে engine-এর বার্তা
        if not lines or "runtime error" not in lines[-1]: lines.append(str(e).split("\n")[0])
    for f in fns: f.destroy()
    return lines
same, ok = 0, 0
for name in ("bazar", "recursion", "mutual", "err_divzero", "loops", "counter"):
    src = open(f"examples/{name}.haat", encoding="utf-8").read()
    want = open(f"examples/{name}.out", encoding="utf-8").read().split("\n")[:-1]
    try: same += await run_wasm(compile_haat(src)) == want
    except Unsupported as e: print(f"{name}: বাদ — {e}")
print(f"উদাহরণ: {same}টি reference-এর .out-এর সঙ্গে হুবহু")
ref = open("random_ref.txt", encoding="utf-8").read().split()
digest = lambda ls: hashlib.sha256("\n".join(ls).encode()).hexdigest()[:10]
for s in range(len(ref)): ok += digest(await run_wasm(compile_haat(gen_program(s)))) == ref[s]
print(f"এলোমেলো program: {ok}/{len(ref)} হুবহু")
edge = "let m = -9223372036854775807 - 1;\nprint(m / -1);\nprint(m % -1);\nvar z = 0;\nprint(7 / z);\n"
print("Haat-এর নিয়মে:", await run_wasm(compile_haat(edge)))
print("শুধু i64.div_s:", await run_wasm(compile_haat(edge, safe_div=False)))

আসল আউটপুট (ব্রাউজারের Python):

loops: বাদ — values of type Str are not supported
counter: বাদ — 2:4: function values are not supported
উদাহরণ: 4টি reference-এর .out-এর সঙ্গে হুবহু
এলোমেলো program: 200/200 হুবহু
Haat-এর নিয়মে: ['-9223372036854775808', '0', '5:9: runtime error: division by zero']
শুধু i64.div_s: ['RuntimeError: divide result unrepresentable']

দুটি উদাহরণ সৎভাবে বাদ: loops.haat-এ একটি function Str ফেরত দেয়, আর counter.haat closure ব্যবহার করে। বাকি চারটি (bazar, recursion-এর fact(21)-এর wrap সহ, mutual-এর পরস্পর-recursion, err_divzero-এর error) reference-এর .out-এর সঙ্গে হুবহু, আর ২০০টি এলোমেলো program-ও। শেষ দুই লাইন অংশ ৫-এর টেবিলটি browser-এ প্রমাণ করে: Haat-এর নিয়মে INT_MIN / -1 = INT_MIN, INT_MIN % -1 = 0, আর শূন্য দিয়ে ভাগে অবস্থানসহ বার্তা; শুধু i64.div_s দিলে প্রথম লাইনেই engine-এর trap, কিছুই ছাপা হয় না।

লেখকের lab-এ একই compiler-এর আউটপুট Node 24.15.0-এ (V8 13.6) চালানো হয়েছে, একটি ছোট run_wasm.mjs দিয়ে, আর reference সরাসরি চালিয়ে মেলানো হয়েছে (সত্যিকারের run): seed ০–২,৯৯৯-এর ৩,০০০টি program-এর ৩,০০০টিই হুবহু, যার ৩২৫টি runtime error-এ থামে; module-এর আকার ২৭০ থেকে ৩,০৪১ byte. Reference-এর ১৩টি উদাহরণের ৪টি চলেছে আর মিলেছে, ৩টি ইচ্ছাকৃত static error-এর ফাইল, ৬টি Unsupported (closure বা Str-এর হিসাব)। আলাদা সীমার পরীক্ষাগুলোও মিলেছে: ৯৯৯ গভীর recursion চলে আর ১,০০০-এ 3:12: runtime error: stack overflow; hoisted function আগে ডাকলে 4:28: runtime error: 'k' is not initialized yet; -(INT_MIN) = INT_MIN.

পরীক্ষা ও ইন্টারভিউতে: বিশ্ববিদ্যালয়, চাকরি বা ইন্টারভিউর পরীক্ষায় এই ধরনের প্রশ্ন সাধারণ:

  • WebAssembly কি “browser-এর assembly”? না, এটি একটি যন্ত্র-নিরপেক্ষ, typed stack machine-এর binary format; engine চালানোর আগে যাচাই করে নিজের CPU-র machine code বানায়।
  • Wasm-এ while কীভাবে লেখা হয়? block-এর ভেতরে loop; শর্ত মিথ্যা হলে br_if 1 (বাইরে), শরীরের শেষে br 0 (আবার শুরু)।
  • i64.const 1000-এর byte কী? 42 e8 07: opcode, তারপর signed LEB128.
  • Wasm-এ শূন্য দিয়ে ভাগে কী হয়, আর C বা Haat-এ? Wasm-এ trap; C-তে undefined behavior; Haat-এ অবস্থানসহ runtime error, তাই compiler নিজে পরীক্ষা লেখে।
  • Back end-এর সঠিকতা কীভাবে দেখাবেন? Reference interpreter-এর সঙ্গে এলোমেলো program-এ differential test, আর সীমার মান আলাদা করে।

৮ · Clang-এর Wasm-এর সঙ্গে তুলনা

সত্যিকারের compiler একই কাজ কীভাবে করে? price-এর C রূপ, সঙ্গে একটি পরিবর্তনশীল ভাজকের share, Zig 0.17.1-এর সঙ্গে আসা Clang 22.1.8 দিয়ে wasm32-এ নামানো হলো (সত্যিকারের run; Clang-এর Wasm assembly-র লেখ্য রূপ, .functype ছাড়া বাকি directive আর মন্তব্য বাদ)।

~/wasm $ python -m ziglang cc -target wasm32-freestanding -O2 -S -g0 \
          -fno-sanitize=undefined price.c -o price_O2.s
long long price(long long qty, long long unit) {
    long long p = qty * unit;
    if (p >= 1000) return p - p / 10;
    return p;
}
long long share(long long total, long long people) { return total / people; }

price:
  .functype price (i64, i64) -> (i64)
  block
  local.get 1
  local.get 0
  i64.mul
  local.tee 0
  i64.const 1000
  i64.lt_s
  br_if 0
  local.get 0
  local.get 0
  i64.const 10
  i64.div_u
  i64.sub
  local.set 0
  end_block
  local.get 0
  end_function
share:
  .functype share (i64, i64) -> (i64)
  local.get 0
  local.get 1
  i64.div_s
  end_function

চারটি জিনিস লক্ষ করার মতো। প্রথমত, Clang if লেখেনি, লিখেছে block … br_if 0 … end_block: “শর্ত মিথ্যা হলে block থেকে বেরিয়ে যাও”, আমাদের while-এর বেরোনোর দরজার মতোই। দ্বিতীয়ত, local.tee 0 মান local-এ রাখে আবার stack-এও রাখে, একটি local.get বাঁচায়; আর আলাদা p না রেখে parameter qty-এর local-টিই আবার ব্যবহার করেছে। তৃতীয়ত, i64.div_u: Clang জানে এই শাখায় p ≥ 1000, অর্থাৎ ধনাত্মক, তাই unsigned ভাগ ব্যবহার করেছে, যা চিহ্ন সামলানোর ঝামেলা ছাড়া একই ফল দেয়। চতুর্থত আর সবচেয়ে গুরুত্বপূর্ণ, share-এ শুধু i64.div_s, কোনো পরীক্ষা নেই। C-তে শূন্য দিয়ে ভাগ আর LLONG_MIN / -1 undefined behavior, তাই Clang কিছু পাহারা দিতে বাধ্য নয়। লিঙ্ক করে (-nostdlib -Wl,--no-entry -Wl,--export=price -Wl,--export=share, debug তথ্য ছাড়া) ১০৮ byte-এর module পাওয়া গেছে, আর Node 24-এ price(2n, 520n) = 936n, share(1000n, 0n) → RuntimeError: divide by zero, share(-2n ** 63n, -1n) → RuntimeError: divide result unrepresentable. C-র undefined behavior Wasm-এ নিরাপদ trap হয়ে গেছে, কিন্তু ভাষার কোনো নির্দিষ্ট বার্তা নেই।

আকারে: Clang-এর price-এর শরীর ৩০ byte, আমাদের ৩৩ byte. আমাদের দুটি return আর শেষের unreachable বাড়তি, আর Clang local.tee দিয়ে একটি local.get বাঁচায়; বিনিময়ে সে block, end_block আর শেষে local.set/local.get লেখে। পুরো module-এ তুলনা অন্যায্য, কারণ Haat-এর <main>-এর ১৭২ byte-এর বেশিরভাগই call-এর গভীরতা-পাহারা (প্রতিটি call-এ ৩২ byte, তিনটি call-এ ৯৬): ভাষার নিয়ম রক্ষার দাম, যা C দেয় না। Clang-এর module-এ আরও আছে একটি ১ MiB-এর (১৬ page) memory আর __stack_pointer global: C-র address নেওয়া যায় এমন local-এর জন্য একটি “ছায়া stack”, কারণ Wasm-এর নিজের call stack-এ ঠিকানা নেওয়া যায় না।

আরও গভীরে: Engine-এর ভেতরে Wasm আবার compile হয়। V8-এ প্রথমে একটি দ্রুত baseline compiler (Liftoff) প্রায় এক পাসে কোড বানায়, আর গরম function পরে optimizing compiler-এ ওঠে, পর্ব ৬১-এর tiered compilation-এর মতো; Firefox-এর SpiderMonkey-তেও baseline আর optimizing দুই স্তর। Register allocation (পর্ব ৭০) তাই আমাদের কাজ নয়, engine-এর। Wasm 3.0-এ return_call দিয়ে নিশ্চিত tail call (পর্ব ৩২), Wasm-এর ভেতরেই exception (পর্ব ২৮), আর GC-ওয়ালা struct/array এসেছে; Kotlin আর Dart-এর মতো GC-নির্ভর ভাষার Wasm back end এই সুবিধা ব্যবহার করে বলে জানা যায়। Haat-এর closure-এর জন্য সেটিই সবচেয়ে সহজ পথ হবে।

৯ · AI-এর যুগে Wasm back end

AI assistant-কে “এই ভাষার জন্য WebAssembly compiler লেখো” বললে প্রায়ই পরিচ্ছন্ন কোড আসে, যা bazar-এর মতো সহজ program-এ ঠিক চলে। ভুল লুকিয়ে থাকে কোণে: ভাগের নিয়মে, লেবেলের গভীরতায়, signed আর unsigned LEB128-এ। Wasm-এর validator অনেক গঠনগত ভুল ধরে, কিন্তু অর্থের ভুল ধরে না: i64.div_s দিয়ে লেখা Haat-এর ভাগ বৈধ module, শুধু ভুল ভাষা।

AI-এর ভুলকীভাবে ধরবেন
উৎস-ভাষার ভাগকে সরাসরি i64.div_s-এ নামানো; “Wasm শূন্য দিয়ে ভাগে 0 দেয়” বা “INT_MIN / -1-এ wrap করে” বলে দাবিspecification-এর Numerics অংশ পড়া; Node বা browser-এ 0 আর -1 ভাজক দিয়ে সত্যিকারের run
&&-কে select বা i32.and দিয়ে লেখা, যাতে ডান দিক সবসময় চলেডান দিকে ভাগ বা print-ওয়ালা পরীক্ষা; reference-এর সঙ্গে differential test
br-এর গভীরতা ভুল গোনা (if-ও একটি লেবেল, তা ভুলে যাওয়া), loop-এর লেবেলকে শেষ ধরাValidator (WebAssembly.validate) আর loop-এর ঘোরা-গোনা পরীক্ষা
ধ্রুবকে unsigned LEB128, বা signed-এ চিহ্ন-বিট ভুলে যাওয়া (64 → 40)লিখে আবার পড়ার পরীক্ষা: −65, 63, 64, INT_MIN
JavaScript থেকে i64-এ number পাঠানো, বা বানানো API (“WebAssembly.run”)MDN আর specification-এর JS API; চালিয়ে দেখা

AI-কে কাজে লাগাতে উৎস-ভাষার অর্থ আর যাচাইয়ের পথ আগেই বলে দিন:

আমি Python-এ একটি ছোট শিক্ষামূলক ভাষার (Haat) WebAssembly back end লিখছি; Int = i64 (wrap করে), Bool = i32. ১. Haat-এর / আর % C-র মতো (শূন্যের দিকে কাটে), শূন্য দিয়ে ভাগে আমার নিজের runtime error চাই অবস্থানসহ, আর INT_MIN / -1 = INT_MIN. i64.div_s আর i64.rem_s কোন কোন ক্ষেত্রে trap করে, WebAssembly specification-এর কোন অংশ থেকে, তা উদ্ধৃতিসহ বলো; নিশ্চিত না হলে বলো। ২. এই নিয়ম রাখতে কোন Wasm নির্দেশ লাগবে, WAT-এ দেখাও। ৩. while আর && কীভাবে block/loop/br_if আর if (result i32)-এ নামবে দেখাও, প্রতিটি br-এর গভীরতা গুনে। ৪. আমার কোড যাচাইয়ের জন্য Node-এ চালানোর একটি পরীক্ষা লেখো, যা reference interpreter-এর আউটপুটের সঙ্গে এলোমেলো program মেলায়, আর 0, -1, INT_MIN দিয়ে আলাদা পরীক্ষা করে।

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

ভাবনার প্রশ্ন

প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন, তারপর “→ উত্তর” চাপুন।

প্র ০১Wasm-এর নকশাকারেরা ইচ্ছা করে goto বাদ দিলেন। এই সিদ্ধান্তের লাভ কী, আর compiler-লেখকদের কী দাম দিতে হলো?

Wasm-এর লক্ষ্য ছিল ওয়েব থেকে আসা অচেনা কোড দ্রুত আর নিরাপদে চালানো। এর জন্য দুটি জিনিস দরকার: চালানোর আগে সস্তা যাচাই, আর দ্রুত compile. Structured control flow দুটিই দেয়। প্রতিটি block, loop আর if-এর শুরু ও শেষে stack-এর type লেখা থাকে, আর প্রতিটি লাফ একটি ঘেরা লেবেলে যায়; তাই validator ওপর থেকে নিচে একবার পড়েই প্রতিটি নির্দেশের আগে stack-এ কী type আছে তা জানে। এলোমেলো লাফ থাকলে একই নির্দেশে কয়েকটি পথে পৌঁছানো যেত, আর প্রতিটি পথের stack মেলাতে JVM-এর পুরোনো verifier-এর মতো dataflow-ধাঁচের fixpoint (পর্ব ৬৪) লাগত; Java পরে এই কাজ সহজ করতে StackMapTable যোগ করে, যাতে compiler আগেই প্রতিটি লাফের লক্ষ্যে stack-এর type লিখে দেয়। Wasm সেই পথে না গিয়ে গঠনই বাধ্য করেছে।

দ্বিতীয় লাভ engine-এর compiler-এর। Baseline compiler এক পাসে কোড লিখতে পারে, কারণ প্রতিটি লাফের লক্ষ্য গঠনের মধ্যে আগেই জানা; loop কোথায় শুরু, তা loop নির্দেশই বলে দেয়, আলাদা করে খুঁজতে হয় না। তৃতীয় লাভ নিরাপত্তা: কোড কখনো একটি নির্দেশের মাঝখানে লাফ দিতে পারে না, তাই কিছু ধরনের আক্রমণ (যেমন return-oriented programming-এর মতো, যা বিদ্যমান কোডের টুকরো জোড়া দেয়) Wasm-এর ভেতরে অনেক কঠিন।

দাম দিয়েছে compiler-লেখকেরা। C আর C++-এ goto আর switch-এর fall-through আছে, আর optimization-এর পরের CFG প্রায়ই কোনো সুন্দর গঠন মানে না। Emscripten-এর Relooper আর LLVM-এর CFGStackify এই কারণেই এসেছে, আর irreducible loop-এর জন্য কোড কপি বা dispatch loop লাগে, যা কোড বড় বা ধীর করতে পারে। গবেষণায় এ নিয়ে বিতর্কও হয়েছে, আর Ramsey-র ২০২২ সালের প্রবন্ধ দেখিয়েছে dominator tree থেকে কাজটি পরিষ্কার পুনরাবৃত্তিতে করা যায়। Haat-এর মতো গঠিত ভাষার জন্য দামটি প্রায় শূন্য: AST-এর while সরাসরি block/loop.

মূল উপলব্ধি: লক্ষ্য-ভাষার একটি সীমাবদ্ধতা যাচাইকারী আর engine-এর কাজ সহজ করে, আর সেই জটিলতা সরে যায় compiler-এর ঘাড়ে; ভালো নকশা ঠিক করে কে দামটি দেবে।

প্র ০২C-তে শূন্য দিয়ে ভাগ undefined behavior, Wasm-এ trap, Haat-এ অবস্থানসহ runtime error. একই গাণিতিক ঘটনার তিনটি ভিন্ন অর্থ কেন, আর back end-এর দায় কী?

C-র মান ১৯৮০-এর দশকে লেখা হয় এমন সময়ে, যখন বিভিন্ন CPU শূন্য দিয়ে ভাগে আলাদা আচরণ করত: x86-এর idiv একটি hardware exception দেয়, আবার অনেক RISC যন্ত্রে ভাগের নির্দেশ trap ছাড়াই একটি মান দেয় (RISC-V-এর div শূন্য দিয়ে ভাগে −1 দেয়, পর্ব ৬৯-এর আলোচ্য)। C কোনো একটির পক্ষ নেয়নি; বলেছে “undefined”, যাতে প্রতিটি যন্ত্রে সবচেয়ে সস্তা নির্দেশ ব্যবহার করা যায়। এর একটি পরিণতি অংশ ৮-এ দেখেছেন: Clang share-এ কোনো পরীক্ষা লেখেনি। আরেকটি পরিণতি সূক্ষ্ম: optimizer ধরে নিতে পারে ভাজক কখনো শূন্য নয়, আর সেই অনুমানে আশপাশের কোড বদলাতে পারে।

Wasm-এর নকশাকারদের একটি নির্দিষ্ট আচরণ দরকার ছিল, কারণ একই module সব যন্ত্রে একই ফল দেবে, এটাই প্রতিশ্রুতি। তাঁরা trap বেছেছেন: যে যন্ত্রে hardware নিজেই ধরে, সেখানে প্রায় বিনা খরচে; যেখানে ধরে না, সেখানে engine একটি পরীক্ষা যোগ করে। INT_MIN / -1-ও trap, কারণ গাণিতিক ফল ধরে না, আর x86-ও এখানে exception দেয়। অথচ INT_MIN % -1 = 0, কারণ সেখানে গাণিতিক ফল সুন্দরভাবে ধরে।

Haat-এর নিয়ম ভাষা-ব্যবহারকারীর চোখে লেখা: বাজারঘরের হিসাবে ভাগে ভুল হলে কোন লাইনে, তা জানতে হবে। আর ওভারফ্লো সবসময় wrap, তাই INT_MIN / -1-ও wrap. Back end-এর দায় তাই পরিষ্কার: লক্ষ্য-যন্ত্র যেখানে ভাষার নিয়ম থেকে আলাদা, সেখানে পার্থক্য পূরণের কোড লেখা। Wasm-এ সেটি একটি শূন্য-পরীক্ষা আর একটি −১-পরীক্ষা; RISC-V-এ শূন্য-পরীক্ষা লাগে কিন্তু −১-এর বিশেষ ব্যবস্থা লাগে না, কারণ সেখানে hardware নিজেই wrap করা ফল দেয়। একই ভাষা, দুই back end, দুই রকম পাহারা।

মূল উপলব্ধি: প্রতিটি back end-এর শুরুতে একটি টেবিল দরকার, “ভাষা কী চায় বনাম লক্ষ্য কী দেয়”, প্রতিটি কোণের মানের জন্য; পার্থক্যের প্রতিটি ঘর একটি পাহারা বা একটি সচেতন সিদ্ধান্ত।

প্র ০৩Haat-এর ১,০০০-call-এর সীমা Wasm-এ একটি global counter দিয়ে রাখা হলো। Engine নিজেই তো stack-এর সীমায় trap করে। তাহলে counter-টি কেন, আর এর দাম কী?

Engine-এর stack-এর সীমা Wasm-এর specification ঠিক করে না: সেটি engine, operating system আর এমনকি প্রতিটি frame কত বড় তার ওপর নির্ভর করে। V8, SpiderMonkey আর Wasmtime আলাদা গভীরতায় থামবে, আর একই engine-এও optimization-এর স্তর বদলালে frame-এর আকার বদলায়। Haat-এর reference ঠিক ১,০০০-এ থামে, আর বার্তা দেয় callee-র অবস্থানসহ (সিদ্ধান্ত ২৬)। Back end-এর প্রতিশ্রুতি “reference-এর মতো আউটপুট”, তাই একই সীমা অবশ্যই একই জায়গায়। Engine-এর trap হলে বার্তাও হতো engine-এর (RangeError: Maximum call stack size exceeded-এর মতো কিছু), Haat-এর নয়।

দাম: প্রতিটি call-এ একটি global পড়া, তুলনা, একটি শাখা, তারপর যোগ, লেখা, আর ফেরার পরে বিয়োগ, লেখা; bazar-এর <main>-এর ১৭২ byte-এর বড় অংশ এটাই। গতির দিক থেকে engine এগুলো সস্তা নির্দেশে নামায়, কিন্তু খুব ছোট function-এ আপেক্ষিক খরচ চোখে পড়ার মতো হতে পারে (কোনো সময়ের সংখ্যা এখানে দাবি করছি না)। একটি সূক্ষ্ম বিষয়: পরীক্ষাটি argument হিসাবের পরে বসানো, কারণ reference-এর interp.py আগে argument মূল্যায়ন করে, তারপর গভীরতা দেখে। f(g(x))-এ গভীরতা ৯৯৯-এ থাকলে g-এর call আগে হবে আর সফল হবে; পরীক্ষা আগে বসালে ভুল জায়গায় error আসত।

বাস্তবের ভাষাগুলো সাধারণত এমন কৃত্রিম সীমা রাখে না; Python-এর sys.setrecursionlimit একটি ব্যতিক্রম, আর CPython-ও এটি interpreter-এর ভেতরে গোনে। একটি বিকল্প নকশা হতো ভাষার specification-এ লেখা: “গভীরতার সীমা বাস্তবায়ন-নির্ভর”, তখন Wasm back end engine-এর trap ধরে একটি সাধারণ stack overflow বার্তা দিতে পারত, অবস্থান ছাড়া। Haat v1 সেই স্বাধীনতা দেয় না, তাই counter.

মূল উপলব্ধি: ভাষার specification যত নির্দিষ্ট, প্রতিটি back end-এর কাজ তত বেশি; আর “এক রকম ফল” যাচাই করতে চাইলে সীমার মতো কোণের আচরণও নির্দিষ্ট হতে হয়।

প্র ০৪JVM bytecode, CPython bytecode আর WebAssembly — তিনটিই stack machine. তবু Wasm কেন C, C++ আর Rust-এর লক্ষ্য হতে পারল, যেখানে বাকি দুটি পারেনি?

JVM-এর bytecode (পর্ব ৬০) object, class আর garbage collection-এর ধারণার ওপর গড়া: new, getfield, invokevirtual. Java-র মতো ভাষার জন্য এটি দারুণ, কিন্তু C-র একটি pointer, যা মেমরির যেকোনো byte দেখাতে পারে, এখানে স্বাভাবিকভাবে বসে না। CPython-এর bytecode আরও উচ্চস্তরের: প্রতিটি নির্দেশ Python object নিয়ে কাজ করে, আর এর format version-ভেদে বদলায়, তাই এটি কোনো স্থির লক্ষ্যই নয়। Wasm উল্টো দিক থেকে এসেছে: এর মডেল একটি সাধারণ CPU-র কাছাকাছি, শুধু নিরাপদ। i32/i64/f32/f64, একটি byte-ঠিকানাযুক্ত linear memory, আর ফাংশন। C-র pointer হয়ে যায় সেই মেমরির একটি সংখ্যা-ঠিকানা, malloc সেই মেমরির ওপর একটি সাধারণ allocator.

নিরাপত্তা আসে সীমানা থেকে, ভাষার type থেকে নয়। Module নিজের মেমরির বাইরে পড়তে পারলে sandbox ভাঙত, তাই প্রতিটি load আর store-এর ঠিকানা মেমরির আকারের সঙ্গে মেলানো হয় (৬৪-বিট যন্ত্রে engine-গুলো প্রায়ই বড় virtual memory সংরক্ষণ করে এই পরীক্ষা hardware-এর পাহারায় সারে)। মেমরির ভেতরে C program নিজের ডেটা নষ্ট করতে পারে, যেমন buffer overflow; কিন্তু host-এর বা অন্য module-এর কিছু ছুঁতে পারে না। Call stack আর ফেরার ঠিকানা linear memory-র বাইরে, engine-এর নিজের হাতে, তাই ফেরার ঠিকানা মুছে লাফ দেওয়ার পুরোনো আক্রমণ এখানে কাজ করে না।

তৃতীয় কারণ ঐতিহাসিক: asm.js দেখিয়েছিল, C থেকে আসা কোড ওয়েবে প্রায় native গতিতে চলতে পারে, আর সব বড় browser-এর দল একসঙ্গে একটি মানক বানাতে রাজি ছিল। ফলে Wasm একই সঙ্গে নিচু-স্তরের (C-র জন্য), নিরাপদ (ওয়েবের জন্য) আর মানক (সবার জন্য)। পরে Wasm 3.0-এর GC এসে JVM-ধাঁচের ভাষাগুলোর জন্যও দরজা খুলেছে, অর্থাৎ দুই জগতের মাঝখানে দাঁড়িয়েছে।

মূল উপলব্ধি: একটি virtual machine কোন ভাষার লক্ষ্য হতে পারবে, তা ঠিক করে তার মেমরি-মডেল; Wasm-এর linear memory C-কে জায়গা দিয়েছে, আর সীমানা-পরীক্ষা জায়গাটিকে নিরাপদ রেখেছে।

প্র ০৫এই পর্বের compiler AST থেকে Wasm লেখে, IR থেকে নয়। বড় compiler কেন উল্টো পথে যায়, আর Haat যদি পর্ব ৬৫–৬৭-এর optimization চায়, কী বদলাতে হবে?

AST থেকে সরাসরি কোড লেখা সবচেয়ে ছোট পথ, আর Wasm-এর বেলায় বিশেষভাবে স্বাভাবিক, কারণ দুই দিকই গঠিত আর দুই দিকই stack-ভিত্তিক: একটি expression tree-কে post-order-এ হাঁটলেই stack machine-এর কোড। পর্ব ৫৮-এর bytecode compiler-ও ঠিক এভাবে কাজ করে। সীমা হলো optimization. Constant folding, common subexpression elimination, loop-invariant code motion আর inlining চলে IR-এ, কারণ সেখানে প্রতিটি হিসাবের নাম আছে, আর CFG ও SSA-তে dataflow analysis (পর্ব ৬৩–৬৪) করা যায়। AST-তে একই কাজ করতে গেলে প্রতিটি optimization-কে গাছের সব আকার জানতে হয়।

বাস্তবের compiler, যেমন Clang, তাই এভাবে চলে: উৎস → AST → LLVM IR (পর্ব ৬৮) → optimization → Wasm back end. LLVM-এর Wasm back end IR-এর CFG থেকে CFGStackify দিয়ে block/loop বসায়, আর আরেকটি pass register-এর মতো ভার্চুয়াল মানগুলোকে stack-এ সাজায়, যাতে যতটা সম্ভব local.get/local.set এড়ানো যায় (অংশ ৮-এর local.tee তারই চিহ্ন)। Binaryen-এর মতো tool আবার Wasm-এর ওপরেই optimization চালায়।

Haat-এর জন্য পথটি তাই: পর্ব ৬২-এর IR থেকে Wasm লেখা, যাতে পর্ব ৬৫–৬৭-এর optimization-এর ফল কাজে লাগে। দুটি নতুন কাজ আসবে। প্রথম, CFG থেকে গঠন ফিরিয়ে আনা: Haat-এর IR গঠিত উৎস থেকে আসে বলে reducible, তাই dominator tree-ভিত্তিক পদ্ধতিই যথেষ্ট। দ্বিতীয়, IR-এর প্রতিটি নাম (t1, t2…) একটি Wasm local হবে, ঠিক পর্ব ৭১-এর “প্রতিটি নামের একটি slot”-এর মতো; engine-এর register allocator পরে সেগুলো register-এ বসাবে। যাচাইয়ের পথ বদলাবে না: একই এলোমেলো program, একই reference.

মূল উপলব্ধি: AST থেকে সরাসরি কোড লেখা শেখার আর প্রথম সংস্করণের জন্য সেরা; optimization যখন জরুরি হয়, তখন একটি IR মাঝখানে বসে, আর back end-এর প্রথম কাজ হয় IR-এর গঠন লক্ষ্যের গঠনে ফেরানো।

অনুশীলন

প্রথমে নিজে হিসাব করুন বা লিখুন, তারপর উত্তর খুলুন। প্রতিটি উত্তর সত্যিকারের run দিয়ে যাচাই করা।

  1. নকশা ও বাস্তবায়ন — function-এর নাম trap-এর বার্তায়: err_divzero.haat চালালে browser-এর console-এ trap-এর stack trace-এ শুধু wasm-function[5] দেখায়। Wasm-এর “name” custom section যোগ করে Module-এ একটি ফাংশন লিখুন, যাতে সেখানে share আর <main> দেখায়। Section-এর গঠন: নাম "name", তারপর subsection id ১ (function-এর নাম), তার আকার, আর (function-এর নম্বর, নাম)-এর একটি vector.
    def name_section(mod):
        names = [(4, "<main>")] + [(i, n) for n, i in mod.index.items()]
        sub = vec([uleb(i) + name(n) for i, n in names])
        return section(0, name("name") + [1] + uleb(len(sub)) + sub)
    
    data = mod.binary() + bytes(name_section(mod))   # custom section শেষে বসানো চলে

    Import-এর নাম বাদ দেওয়া চলে; প্রতিটি নামই ঐচ্ছিক। লেখকের lab-এ err_divzero.haat-এর module ৩৭০ থেকে ৩৯৫ byte হয়েছে, আর Node 24-এর সত্যিকারের trap-এর stack trace বদলেছে: আগে at wasm://wasm/…:wasm-function[5]:0x116, পরে at share (wasm://wasm/…:wasm-function[5]:0x116) আর at <main> (…:wasm-function[4]:0xeb). নামগুলো আচরণ বদলায় না (তাই custom section), শুধু debugging-এ সাহায্য করে; এমনকি 0x116 ঠিকানাও এক, কারণ নতুন section যোগ হয়েছে code section-এর পরে।

  2. ভুল খুঁজুন — &&-এর একটি “ছোট” অনুবাদ: কেউ লিখেছেন, if খরুচে, তাই a && b → b; i32.const 0; a; select (select তিনটি মান নামায় আর শেষেরটি সত্য হলে প্রথমটি, নইলে দ্বিতীয়টি রাখে)। Bool-এর জন্য এটি তো সঠিক সত্যসারণি দেয়। নিচের program-এ কী ভুল হবে?
    var z = 0;
    if z != 0 && 100 / z > 5 { print(1); } else { print(2); }
    print(3);

    সত্যসারণি ঠিক, কিন্তু মূল্যায়ন ভুল: select-এর আগে তিনটি মানই হিসাব হয়, তাই 100 / z সবসময় চলে, এমনকি z != 0 মিথ্যা হলেও। Haat-এর && short-circuit (spec v1-এর Semantics), তাই সঠিক আউটপুট 2, 3. লেখকের lab-এ এই ভুল অনুবাদ দিয়ে compile করে Node 24-এ চালাতে এসেছে শুধু 2:18: runtime error: division by zero; সঠিক compiler আর reference দিয়েছে 2, 3. ডান দিকে কোনো call থাকলে (যেমন print-করা function) ভুলটি অতিরিক্ত আউটপুট হিসেবেও দেখা দিত। select শুধু তখনই নিরাপদ, যখন দুই দিকই পার্শ্বপ্রতিক্রিয়াহীন আর trap করতে পারে না, যেমন দুটি local পড়া।

  3. হিসাব — byte-এ byte: (ক) i64.const -1000-এর পুরো byte লিখুন। (খ) নিচের top-level কোডের <main>-এর Wasm নির্দেশ আর তাদের byte লিখুন (global ০ = $depth, global ১ = i; print_i64 = function ০):
    var i = 0; while i < 3 { i = i + 1; } print(i);

    (ক) −১০০০ = −৮ × ১২৮ + ২৪. প্রথম ৭ বিট ২৪ = 0x18, বাকি −৮; −৮ শূন্য বা −১ নয়, তাই 0x18 ∣ 0x80 = 0x98. তারপর −৮-এর নিচের ৭ বিট 1111000 = 0x78, বাকি −১, আর 0x78-এর 0x40 বিট 1 (চিহ্ন মেলে), তাই থামা: 42 98 78. পরীক্ষা: ২৪ + (১২০ − ১২৮) × ১২৮ = ২৪ − ১০২৪ = −১০০০.

    (খ) haat_wasm.py-র সত্যিকারের আউটপুট:

    i64.const 0       42 00
    global.set 1      24 01
    block             02 40
      loop            03 40
        global.get 1  23 01
        i64.const 3   42 03
        i64.lt_s      53
        i32.eqz       45
        br_if 1       0d 01
        global.get 1  23 01
        i64.const 1   42 01
        i64.add       7c
        global.set 1  24 01
        br 0          0c 00
      end             0b
    end               0b
    global.get 1      23 01
    call 0            10 00

    40 হলো খালি blocktype (“কোনো ফল নেই”)। মোট ৩১ byte; function-এর শেষে আরেকটি 0b. চালালে 3.

  4. আউটপুট অনুমান — Haat-এর নিয়ম বনাম শুধু Wasm: নিচের program এই পর্বের compiler-এ কী ছাপবে? আর ভাগের পাহারা ছাড়া (শুধু i64.div_s/i64.rem_s) কী ছাপত?
    fn half(n: Int) -> Int { return n / 2; }
    let m = -9223372036854775807 - 1;
    print(m / -1 == m); print(-7 % 3); print(half(-7)); print(m % -1);
    var z = 0; print(5 / z); print(1); (প্রতিটি print আলাদা লাইনে, var z লাইন ৭-এ, print(5 / z); লাইন ৮-এ)

    Haat-এর নিয়মে: true (wrap করে INT_MIN), -1 (ভাগশেষ ভাজ্যের চিহ্ন নেয়), -3 (শূন্যের দিকে কাটে; ২ লেখা ভাজক, তাই সরাসরি i64.div_s), 0, তারপর 8:9: runtime error: division by zero, আর শেষের print(1) চলে না। Reference আর Node 24-এর run দুটিই ঠিক এই পাঁচ লাইন দিয়েছে। পাহারা ছাড়া প্রথম print-এই m / -1-এ trap: RuntimeError: divide result unrepresentable, কিছুই ছাপা হয় না; lab-এর সত্যিকারের run-এও তাই। লক্ষ করুন, m % -1 পাহারা ছাড়াও 0 দিত, কারণ i64.rem_s-এর একমাত্র trap শূন্য ভাজক।

নিজেকে যাচাই করুন

ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।

ক্রমHaat-এর একটি program থেকে browser-এ তার আউটপুট পর্যন্ত ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. Parser Haat-এর উৎস থেকে AST বানায়
  2. প্রতিটি function-এর জন্য Wasm নির্দেশের তালিকা তৈরি
  3. নির্দেশ আর section LEB128-সহ byte-এ encode
  4. Engine module যাচাই (validate) করে machine code বানায়
  5. Host-এর import (print, error) দিয়ে instantiate
  6. haat_main ডাকা; host আউটপুট ছাপে বা trap ধরে

WebAssembly-তে i64.div_s দিয়ে −9223372036854775808 / −1 হিসাব করলে কী হয়?

  • ফল −9223372036854775808 (wrap)
  • Undefined behavior, যেকোনো কিছু হতে পারে
  • Trap
  • 0

নিচের Wasm-এ br_if 1 লাফ দিলে নিয়ন্ত্রণ কোথায় যায়?
block · loop · … · br_if 1 · … · br 0 · end · end · global.get 2

  • loop-এর শুরুতে
  • বাইরের end-এর পরে, global.get 2-তে
  • ভেতরের end-এর ঠিক পরে
  • Function থেকে বেরিয়ে যায়

Signed LEB128-এ 64 লেখা হয় কীভাবে?

  • 40
  • 80
  • 00 40
  • c0 00

একটি Haat function fn price(qty: Int, unit: Int) -> Int Wasm-এ haat_price নামে export করা। JavaScript থেকে instance.exports.haat_price(2, 520) ডাকলে কী হয়?

  • TypeError: number থেকে BigInt-এ রূপান্তর হয় না
  • ফল 936 (number)
  • ফল 936n
  • RuntimeError (trap)

WebAssembly-র engine একটি function-এর stack-এর type একবার ওপর থেকে নিচে পড়েই যাচাই করতে পারে। এর প্রধান কারণ কী?

  • Wasm একটি stack machine
  • সব সংখ্যা LEB128-এ লেখা
  • Structured control flow: গঠনের type জানা আর লাফ শুধু ঘেরা লেবেলে
  • Custom section-এ type লেখা থাকে

Clang 22 -O2-তে C-র long long share(long long a, long long b) { return a / b; }-কে wasm32-এ নামালে শরীরে কী থাকে, আর share(1000, 0) চালালে কী হয়?

  • একটি শূন্য-পরীক্ষা, আর C-র নিজের error বার্তা
  • শুধু i64.div_s; চালালে Wasm-এর trap
  • শুধু i64.div_s; ফল 0
  • i64.div_u; ফল 0

শব্দকোষ

লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:

মনে রাখুন

  1. Wasm = নিরাপদ, typed stack machine: compiler byte লেখে, engine যাচাই করে machine code বানায়; register allocation engine-এর।
  2. Module: \0asm + version, তারপর type, import, function, (memory), global, export, code, (data), custom; সংখ্যা LEB128-এ, signed রূপে চিহ্ন-বিট 0x40.
  3. Control flow: block-এর লেবেল শেষে, loop-এর শুরুতে; while = block loop … br_if 1 … br 0 end end; &&/|| = if (result i32).
  4. Trap ≠ ভাষার error: i64.div_s শূন্য আর INT_MIN / -1-এ trap করে, i64.rem_s শুধু শূন্যে; Haat-এর বার্তা, wrap আর ১,০০০-call-এর সীমা compiler নিজে লেখে।
  5. প্রমাণ চালিয়ে: browser-এ ২০০ আর Node 24-এ ৩,০০০ এলোমেলো program reference-এর সঙ্গে হুবহু; সীমার মানগুলো আলাদা করে।

পরের পর্বে: পর্ব ৭৪ (Linking আর loading — object file, symbol আর relocation). RISC-V আর x86-64-এর object file-এর section, symbol আর relocation, linker কীভাবে আলাদা ফাইল জোড়া দেয়, আর program চালু হওয়ার আগে loader কী করে।

আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ

এই পর্বটি শেয়ার করুন:
এই পর্বে ভুল পেয়েছেন? জানান