এই পর্বে যা শিখবেন
- 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 machine | stack machine, কিন্তু প্রতিটি মানের type জানা (i32 i64 f32 f64 …) |
| লাফ | JUMP, JUMP_IF_FALSE যেকোনো নির্দেশে | শুধু গঠিত block/loop/if আর লেবেলের গভীরতায় br |
| চালানোর আগে | কোনো যাচাই নেই; ভুল bytecode VM-কে বিভ্রান্ত করে | পুরো module যাচাই (validation); ভুল type বা stack-এর গরমিল হলে চলবেই না |
| Local আর global | slot, cell, closure | সংখ্যা-চিহ্নিত local আর global, closure নেই |
| চালায় কে | Python-এ লেখা loop | engine-এর 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 সহ)
সংখ্যা লেখার নিয়ম 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 |
- Opcode.
i64.const-এর opcode0x42; তার পরেই মানটি signed LEB128-এ। 1000 বাইনারিতে1111101000, ১০টি বিট, তাই এক byte-এ (৭ বিট) ধরবে না। - নিচের ৭ বিট।
1000 & 0x7f=1101000=0x68(১০৪)। বাকি থাকল1000 >> 7= ৭। - আরও আছে। বাকি ৭ শূন্য নয়, তাই এই byte-এর ওপরের বিট 1:
0x68 ∣ 0x80=0xe8. - পরের ৭ বিট।
7 & 0x7f=0x07, বাকি ০। এখন থামা যায় কি না দেখতে হবে চিহ্ন-বিট। - শেষ byte. বাকি ০ আর
0x07-এর0x40বিট ০, অর্থাৎ পড়ার সময় ধনাত্মক ধরা হবে: থামা। ফল42 e8 07, তিন byte; পর্ব ৬১-এর আউটপুটেও ঠিক এটাই ছিল। - উল্টো পড়া।
0x68+ ৭ × ১২৮ = ১০৪ + ৮৯৬ = ১,০০০. সাবধান: 64-এর নিচের ৭ বিট1000000, যার0x40বিট 1, তাই এক byte40লিখলে পড়া হবে −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 করে। নিয়মগুলো এক জায়গায়:
- Int ধ্রুবক →
i64.const n;true/false→i32.const 1/0. Parameter আরlet/var→ নতুন local (একই নামের ছায়া-variable আলাদা local পায়); top-levellet/var→ mutable Wasm global. 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.a && b→a; if (result i32) b else i32.const 0 end;a || b→a; if (result i32) i32.const 1 else b end: ডান দিক শুধু দরকার হলে চলে।f(x, y)→ argument বাঁ থেকে ডানে, গভীরতার পরীক্ষা, তারপরcall k.print(e)→e; call print_i64বাprint_bool(host-এর function).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.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
| stack | |
| total | |
| rounds | |
| লেবেল |
- দুই দরজা।
blockআরloopঢোকার সময় কিছু চলে না, শুধু দুটি লেবেল তৈরি হয়। ভেতর থেকে গুনলেloop= 0,block= 1. Global ২ হলোtotal, ৩ হলোrounds. - শর্তের মান।
global.get 2আরi64.const 5000: stack-এ[0, 5000]. - শর্ত উল্টানো।
i64.lt_sদুটি নামিয়ে 1 রাখে (০ < ৫০০০), আরi32.eqzসেটিকে 0 করে। কেন উল্টাই? কারণbr_ifলাফ দেয় সত্য হলে, আর আমরা লাফ চাই শর্ত মিথ্যা হলে। - লাফ নেই।
br_if 10 নামায়, তাই পরের নির্দেশে যায়। Stack আবার খালি। - শরীর। দুটি assignment:
total= ১২৫০,rounds= ১. প্রতিটিglobal.get,i64.const,i64.add,global.set: চারটি নির্দেশ। - ফেরা।
br 0সবচেয়ে ভেতরের লেবেলে যায়; সেটিloop, যার লেবেল শুরুতে, তাই আবারglobal.get 2. প্রতি ঘোরা ১৪টি নির্দেশ। - চার ঘোরার পরে। ১২৫০ × ৪ = ৫০০০,
rounds= ৪. শর্তের জন্য stack-এ[5000, 5000]. - শর্ত মিথ্যা। ৫০০০ < ৫০০০ মিথ্যা:
i64.lt_s0 দেয়,i32.eqz1. - বেরোনো।
br_if 11 নামিয়ে লাফ দেয় লেবেল 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 % 0 | trap: RuntimeError: divide by zero (অবস্থান নেই) | line:col: runtime error: division by zero, / বা %-এর অবস্থানে (সিদ্ধান্ত ২৪, ২৬) |
INT_MIN / -1 | trap: RuntimeError: divide result unrepresentable | wrap: ফল INT_MIN (সিদ্ধান্ত ১৩) |
INT_MIN % -1 | 0, trap নেই | 0 (সিদ্ধান্ত ১৩) |
| ১,০০০-এর বেশি গভীর call | engine-এর নিজের সীমায় পৌঁছালে তবেই 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 …
| stack | |
| $x · $y | |
| host |
- দুই মান।
share(1000, 4)আগেই ২৫০ ছেপেছে; এখনshare(1000, 0): parameter ০ আর ১ stack-এ। ($x,$ylocal ২ আর ৩, Wasm-এ শুরুতে 0.) - সহায়ক local. ওপরের মান আগে নামে, তাই আগে
$y= ০, পরে$x= ১০০০. এখন দুটিকে যতবার খুশি পড়া যায়। - পরীক্ষা।
local.get 3; i64.eqz: ভাজক শূন্য, তাই 1 (i32). - শাখা।
if1 নামিয়ে ভেতরে ঢোকে। এই ভেতরের কোড সাধারণ ভাগে কখনো চলে না, শুধু কয়েকটি byte জায়গা নেয়। - কারণ আর অবস্থান। তিনটি
i32.const: বার্তার নম্বর ০ (division by zero), লাইন ৩, কলাম ১৮, অর্থাৎreturn total / people;-এর/, সিদ্ধান্ত ২৪-এর নিয়মে। - Host-কে জানানো।
call 3= import-এর চতুর্থটি,env.error. Hosthaat.messages-এর ০ নম্বর লাইন নিয়ে3:18: runtime error: division by zeroলিখে রাখে, তারপর ফেরে। - Trap.
unreachableনির্ধারিত trap: engine সব Wasm frame (share,<main>) ফেলে দিয়ে host-এর কাছেRuntimeError: unreachableছোড়ে। Node 24-এ সত্যিকারের run-এ ঠিক এই বার্তা এসেছে। - 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-কে কাজে লাগাতে উৎস-ভাষার অর্থ আর যাচাইয়ের পথ আগেই বলে দিন:
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 দিয়ে যাচাই করা।
-
নকশা ও বাস্তবায়ন — 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-এর পরে। -
ভুল খুঁজুন —
&&-এর একটি “ছোট” অনুবাদ: কেউ লিখেছেন,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 পড়া। -
হিসাব — 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 0040হলো খালি blocktype (“কোনো ফল নেই”)। মোট ৩১ byte; function-এর শেষে আরেকটি0b. চালালে3. -
আউটপুট অনুমান — 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-এ তার আউটপুট পর্যন্ত ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)
- Parser Haat-এর উৎস থেকে AST বানায়
- প্রতিটি function-এর জন্য Wasm নির্দেশের তালিকা তৈরি
- নির্দেশ আর section LEB128-সহ byte-এ encode
- Engine module যাচাই (validate) করে machine code বানায়
- Host-এর import (print, error) দিয়ে instantiate
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 লেখা হয় কীভাবে?
408000 40c0 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
শব্দকোষ
লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:
মনে রাখুন
- Wasm = নিরাপদ, typed stack machine: compiler byte লেখে, engine যাচাই করে machine code বানায়; register allocation engine-এর।
- Module:
\0asm+ version, তারপর type, import, function, (memory), global, export, code, (data), custom; সংখ্যা LEB128-এ, signed রূপে চিহ্ন-বিট0x40. - Control flow:
block-এর লেবেল শেষে,loop-এর শুরুতে;while=block loop … br_if 1 … br 0 end end;&&/||=if (result i32). - Trap ≠ ভাষার error:
i64.div_sশূন্য আরINT_MIN / -1-এ trap করে,i64.rem_sশুধু শূন্যে; Haat-এর বার্তা, wrap আর ১,০০০-call-এর সীমা compiler নিজে লেখে। - প্রমাণ চালিয়ে: browser-এ ২০০ আর Node 24-এ ৩,০০০ এলোমেলো program reference-এর সঙ্গে হুবহু; সীমার মানগুলো আলাদা করে।
আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ
- পর্ব ৭৪ · Linking আর loadingপরবর্তী পর্বObject file, symbol আর relocation.
- প্রোগ্রামিং ভাষা ও কম্পাইলার · কোর্স হোম৮৬টি পর্বপুরো কোর্সের মানচিত্র আর Haat প্রজেক্টের পথ।
- পর্ব ৬১ · JIT compilationএই কোর্সেএকটি গরম function থেকে Wasm, আর engine-এর স্তর।
- পর্ব ৫৯ · Stack-based virtual machineএই কোর্সেHaat-এর নিজের stack machine, Wasm-এর আত্মীয়।
- JavaScript কীভাবে চলেপাশের ট্র্যাকBrowser-এর engine, যে Wasm-ও চালায়।
- Instruction encodingপাশের ট্র্যাকCPU-র নির্দেশ byte-এ, LEB128-এর সঙ্গে তুলনা করার মতো।