এই পর্বে যা শিখবেন
- ABI আর API-র পার্থক্য, আর একটি ABI ঠিক কোন কোন জিনিস বেঁধে দেয়
- RISC-V psABI-র register-ভূমিকা, argument আর ফল পাঠানোর নিয়ম, struct আর আটটির বেশি argument
- System V x86-64 আর Windows x64-এর পার্থক্য, সত্যিকারের Clang-এর আউটপুটে: red zone, shadow space, struct
- Haat-এর নিজস্ব RV64 frame layout, prologue আর epilogue তৈরির কোড, আর একটি call-এর প্রতিটি নির্দেশে register ও stack
- ABI-ভঙ্গ কেন নিঃশব্দ থাকে, আর emulator, differential test ও অন্য ভাষার সঙ্গে ডাকাডাকি দিয়ে কীভাবে ধরা যায়
১ · ABI কী — যন্ত্রের স্তরের চুক্তি
পর্ব ৩০-এ দেখেছেন একটি call-এর পেছনে কী ঘটে: activation record, ফেরার ঠিকানা, frame pointer আর prologue ও epilogue. সেখানে প্রশ্নটি ছিল “একটি call কীভাবে কাজ করে”। এই পর্বের প্রশ্ন আরেক ধাপ ওপরে: দুটি অপরিচিত কোডের টুকরো কীভাবে একমত হয়? আপনার Haat compiler-এর লেখা price-কে যদি Clang-এর লেখা C কোড ডাকে, দুই পক্ষ একে অপরের কোড কখনো দেখেনি; তবু argument ঠিক জায়গায় পৌঁছাতে হবে।
উপমা — কুরিয়ারের পার্সেলের নিয়ম: ঢাকার একটি দোকান রাজশাহীতে পার্সেল পাঠায়। দোকানি আর প্রাপক কখনো দেখা করেননি, কিন্তু দুজনেই কুরিয়ারের নিয়ম মানেন: প্রাপকের ঠিকানা ওপরের বাঁ কোণে, ফোন নম্বর নিচে, ভঙ্গুর জিনিসে লাল স্টিকার, ওজন ১০ কেজির বেশি হলে আলাদা বাক্স। নিয়মটি কেউ একজন লিখে দিয়েছে, আর সবাই মানে বলেই অচেনা দুজনের লেনদেন চলে। ABI ঠিক এমন নিয়ম, শুধু পার্সেলের বদলে argument, আর কুরিয়ারের বদলে CPU-র register আর stack.
ABI (Application Binary Interface) হলো compile হয়ে যাওয়া কোডের মধ্যে যন্ত্রের স্তরের চুক্তি। এর পাশের শব্দ API উৎসের স্তরের চুক্তি: “price দুটি long long নেয় আর একটি ফেরত দেয়”। API একই রেখেও ABI বদলানো যায় (যেমন একটি struct-এ নতুন field যোগ করা: উৎস-কোড আগের মতোই compile হয়, কিন্তু পুরোনো binary ভুল offset পড়ে)। আবার একই API দুটি platform-এ দুটি ভিন্ন ABI পায়, যা অংশ ৫-এ সত্যিকারের Clang-এ দেখবেন। একটি ABI সাধারণত এই জিনিসগুলো বেঁধে দেয়:
| বিষয় | উদাহরণ | এই কোর্সে |
|---|---|---|
| Data type-এর আকার আর alignment (data model) | Linux-এ long ৮ byte (LP64), Windows-এ ৪ byte (LLP64) | পর্ব ২৫ |
| Calling convention | argument আর ফলের register, কে কোন register বাঁচাবে, stack-এর alignment | এই পর্ব |
| Frame-এর গঠন আর stack-এর ব্যবহার | frame pointer কোথায়, red zone আছে কি না, shadow space | এই পর্ব |
| Symbol-এর নাম | C-তে price, C++-এ _Z5pricexx | অংশ ৮ |
| Object file আর linking-এর format | ELF, PE/COFF, relocation-এর ধরন | পর্ব ৭৪ |
| Operating system-কে ডাকা | RISC-V Linux-এ ecall, system call-এর নম্বর a7-এ | OS পর্ব ০৮ |
নিয়মগুলো কে লেখে? প্রতিটি CPU পরিবারের জন্য একটি “processor-specific ABI” বা psABI: RISC-V-এর জন্য RISC-V International-এর RISC-V ELF psABI, Linux আর অন্য Unix-ধাঁচের x86-64-এর জন্য System V AMD64 psABI, আর Windows-এর জন্য Microsoft-এর x64 নথি। এই পর্বে RISC-V-এর প্রতিটি দাবি psABI-র v1.0 (২০২২ সালের নভেম্বরে প্রকাশিত) থেকে মিলিয়ে লেখা, আর frame pointer-এর অংশটি নতুন v2.0-rc0 খসড়া থেকে, কারণ সেই অংশ v1.0-এ নেই। Hardware-এর দিক থেকে jal, jalr আর register-এর পুরো ছবি Computer Architecture কোর্সের পর্ব ৩০-এ, আর C-র চোখে x86-64-এর frame C কোর্সের পর্ব ৪৬-এ; এখানে compiler-লেখকের চোখে দেখব।
২ · RISC-V psABI — register-এর ভূমিকা আর argument-এর পথ
RISC-V-এর ৩২টি integer register hardware-এর কাছে প্রায় সমান; x0 সবসময় শূন্য, আর jal ফেরার ঠিকানা সাধারণত x1-এ লেখে, এটুকুই। বাকি সব ভাগাভাগি psABI-র চুক্তি। মূল বিভাজনটি দুই ধরনের register-এ:
- Caller-saved (
t0–t6,a0–a7,ra): ডাকা function এগুলো যা খুশি করতে পারে। Call-এর পরেও কোনো মান লাগলে ডাকনেওয়ালা নিজে আগে কোথাও রেখে দেবে। - Callee-saved (
s0–s11,sp): ডাকা function এগুলো বদলাতে চাইলে আগে রেখে দেবে আর ফেরার আগে ফিরিয়ে দেবে। ডাকনেওয়ালার কাছে এগুলো call পেরিয়েও অপরিবর্তিত।
psABI v1.0-এর মূল বাক্যগুলো প্রায় হুবহু এরকম: “base integer calling convention-এ আটটি argument register আছে, a0–a7, যার প্রথম দুটি ফল ফেরত দিতেও ব্যবহৃত হয়”; “stack নিচের দিকে বাড়ে, আর function-এ ঢোকার মুহূর্তে stack pointer ১২৮ বিট (১৬ byte)-এর সীমায় সাজানো থাকবে”; “stack-এ পাঠানো প্রথম argument থাকে ঢোকার মুহূর্তের stack pointer-এর offset শূন্যে, পরেরগুলো ক্রমে ওপরের ঠিকানায়”; আর “কোনো function stack pointer-এর নিচের ঠিকানার data টিকে থাকবে বলে ধরে নেবে না”। শেষ বাক্যটির মানে RISC-V-এ কোনো red zone নেই। নিচের ব্লকে register-এর পুরো তালিকা, আর তিনটি function-এর উদাহরণে কে কোন register বাঁচাতে বাধ্য, তার হিসাব।
// RISC-V psABI v1.0-এর integer register: নাম, কাজ, আর call-এর পরে মান টেকে কি না
const REGS = [["x0", "zero", "সবসময় 0", "—"], ["x1", "ra", "ফেরার ঠিকানা", "না"],
["x2", "sp", "stack pointer", "হ্যাঁ"], ["x3", "gp", "global pointer", "—"], ["x4", "tp", "thread pointer", "—"],
["x5-7", "t0-t2", "temporary", "না"], ["x8", "s0/fp", "saved, frame pointer", "হ্যাঁ"], ["x9", "s1", "saved", "হ্যাঁ"],
["x10-11", "a0-a1", "argument, ফল", "না"], ["x12-17", "a2-a7", "argument", "না"],
["x18-27", "s2-s11", "saved", "হ্যাঁ"], ["x28-31", "t3-t6", "temporary", "না"]];
for (const [x, n, role, kept] of REGS) console.log(`${x.padEnd(7)}${n.padEnd(7)}${kept.padEnd(6)}${role}`);
const isCalleeSaved = r => r === "sp" || /^s([0-9]|1[01])$/.test(r);
// একটি function যে register লেখে আর call পেরিয়ে কোন মান কোথায় রাখে, তা থেকে দায়িত্বের হিসাব
function duties(name, writes, calls, keepAcross) {
const own = writes.filter(isCalleeSaved).filter(r => r !== "sp");
if (calls) own.unshift("ra"); // নিজে call করলে ra মুছে যাবে
const callerMust = keepAcross.filter(r => !isCalleeSaved(r));
console.log(`\n${name}: prologue-এ বাঁচাবে → ${own.join(" ") || "কিছু না"}`);
console.log(` call-এর আগে নিজে বাঁচাবে → ${callerMust.join(" ") || "কিছু না"}`);
}
duties("Clang-এর order (-O2)", ["s0", "s1", "s2", "a0", "a1", "a2", "a7", "t0", "t1"], true, ["s1", "s2"]);
duties("একই order, যদি qty-কে a0-তেই রাখত", ["s0", "a0", "a1", "t0"], true, ["a0", "a1"]);
duties("Haat-এর price, ন্যূনতম দায়িত্ব", ["s0", "a0", "t0", "t1"], false, []);
duties("leaf, frame ছাড়া (Clang -O2-এর price)", ["a0", "a1"], false, []);আসল আউটপুট (browser-এর JavaScript):
x0 zero — সবসময় 0
x1 ra না ফেরার ঠিকানা
x2 sp হ্যাঁ stack pointer
x3 gp — global pointer
x4 tp — thread pointer
x5-7 t0-t2 না temporary
x8 s0/fp হ্যাঁ saved, frame pointer
x9 s1 হ্যাঁ saved
x10-11 a0-a1 না argument, ফল
x12-17 a2-a7 না argument
x18-27 s2-s11 হ্যাঁ saved
x28-31 t3-t6 না temporary
Clang-এর order (-O2): prologue-এ বাঁচাবে → ra s0 s1 s2
call-এর আগে নিজে বাঁচাবে → কিছু না
একই order, যদি qty-কে a0-তেই রাখত: prologue-এ বাঁচাবে → ra s0
call-এর আগে নিজে বাঁচাবে → a0 a1
Haat-এর price, ন্যূনতম দায়িত্ব: prologue-এ বাঁচাবে → s0
call-এর আগে নিজে বাঁচাবে → কিছু না
leaf, frame ছাড়া (Clang -O2-এর price): prologue-এ বাঁচাবে → কিছু না
call-এর আগে নিজে বাঁচাবে → কিছু না
প্রথম সারণিটি psABI v1.0-এর “Integer register convention” টেবিলের সংক্ষেপ। gp আর tp-এর পাশে “—”, কারণ সাধারণ কোড এগুলো বদলায়ই না। তারপর চারটি হিসাব। Clang-এর order (অংশ ৫-এ পুরো listing) একটি call পেরিয়ে দুটি মান রাখতে চায়; সে মান দুটি s1 আর s2-এ রেখেছে, তাই prologue-এ ওই দুটি (আর ra, s0) বাঁচানোর দায় তার, কিন্তু call-এর আশেপাশে আর কিছু করতে হয় না। মান দুটি a0/a1-এ রাখলে উল্টো: prologue হালকা, কিন্তু প্রতিটি call-এর আগে নিজে কোথাও রাখতে হতো। কোন পথ সস্তা, তা নির্ভর করে কতগুলো call আর কতগুলো মান; এই হিসাব register allocator-এর (পর্ব ৭০, Register allocation). শেষ লাইনটি leaf function: কাউকে ডাকে না, কোনো s register ছোঁয় না, তাই তার কোনো দায়ই নেই।
Argument কোথায় যায় — scalar, struct আর ফল
psABI v1.0-এর নিয়ম, RV64-এর জন্য (XLEN = ৬৪ বিট, অর্থাৎ ৮ byte):
- ৮ byte পর্যন্ত scalar: পরের খালি
aregister-এ, না থাকলে stack-এ। ছোট integer (যেমনint) আগে নিজের চিহ্ন অনুযায়ী ৩২ বিটে, তারপর ৬৪ বিটে sign extension হয়ে যায়; তাই RV64-এ একটিunsigned int-ও register-এ sign-extended থাকে। - ১৬ byte পর্যন্ত struct (যেমন দুটি
long long): দুটি register-এ; শুধু একটি খালি থাকলে প্রথম অর্ধেক সেই register-এ আর বাকি অর্ধেক stack-এ। - এর বড় struct: caller একটি কপি বানায় আর তার ঠিকানা পাঠায় (pass by reference).
- ফল: যেভাবে একই type-এর প্রথম argument যেত, সেভাবেই:
a0, দরকারেa0+a1. বড় ফলের জন্য caller জায়গা নেয় আর তার ঠিকানা একটি গোপন প্রথম argument হিসেবে পাঠায়।
Haat-এর জন্য এর প্রায় সবই সরল হয়ে যায়: Haat IR v1-এ Int আর Bool দুটিই ৮ byte-এর একটি register-এ (Bool মানে 0 বা 1), Unit-এর ফল a0 = 0, আর struct নেই। String আর closure-এর ঠিকানা পরে আসবে (পর্ব ৭৫, Garbage collection-এর heap object); তখনও সেগুলো একটি pointer, অর্থাৎ ৮ byte-এর scalar.
৩ · Haat-এর frame layout — নিয়ম আর haat_abi.py
এবার Haat-এর নিজের চুক্তি। Haat-এর RISC-V back end (পর্ব ৭২, Haat থেকে RISC-V assembly) এই অংশের ফাইলটি হুবহু ব্যবহার করবে, তাই প্রতিটি সিদ্ধান্ত এখানে লেখা থাকছে। লক্ষ্য একটাই: সবচেয়ে সরল layout, যা psABI পুরো মানে, যাতে Haat-এর function C থেকে ডাকা যায় আর Haat-ও C-কে ডাকতে পারে।
- Argument ক্রমে
a0–a7-এ; ৯ম থেকে caller-এর frame-এর তলায়, ঢোকার মুহূর্তেরspথেকে0,8,16… byte ওপরে। ফলa0-তে; Bool = 0/1, Unit = 0. - Prologue-এর পরে
s0= ঢোকার মুহূর্তেরsp(canonical frame address, CFA).raথাকেs0−8-এ, caller-এরs0থাকেs0−16-এ: psABI-র frame pointer অংশের frame record. - অনুরোধ করা callee-saved register (
s1…) তার ঠিক নিচে, তারপর প্রতিটি IR নামের (parameter, Haat variable, temp) একটি ৮ byte-এর stack slot, প্রথম লেখার ক্রমে:s0−24,s0−32…। ৯ম আর পরের parameter-এর slot নেই: সেগুলোs0+0,s0+8…-এ caller-এর রেখে যাওয়া ঘরেই। - Frame-এর তলায়,
sp+0থেকে, এই function-এর কোনো call-এ ৮টির বেশি argument থাকলে সেগুলোর জায়গা (out_args). Body চলার সময়spআর নড়ে না। - মোট আকার ১৬-এর গুণিতকে বাড়ানো; ২,০৩২ byte-এর বেশি হলে
Unsupported, যাতেaddiআরsd-এর ১২ বিটের immediate-এ সব offset ধরে। - Symbol: Haat-এর
f→haat_f, top-level-এর<main>→haat_main, global@x→haat_g_x; তাই C-রmainবাprint_int-এর সঙ্গে নাম কখনো মেলে না।
খেয়াল করুন, Haat v1-এ সব মান থাকে stack slot-এ; register শুধু একটি নির্দেশের হিসাবের জন্য। তাই call পেরিয়ে বাঁচানোর কিছু নেই, শুধু ra আর s0. এটি Clang-এর -O0-এর মতো ধীর, কিন্তু সহজে প্রমাণ করা যায় সঠিক; register-এ রাখার কাজটি পর্ব ৭০-এর। তখন allocator যদি কোনো মান s1–s11-এ রাখে, frame_layout(fn, callee_saved=("s1", …)) সেগুলোর জন্য জায়গা নেয় আর prologue-epilogue বাঁচানো-ফেরানো লেখে। নিচের ছবিতে price(2, 520)-এর frame, সত্যিকারের ঠিকানাসহ (অংশ ৪-এর run থেকে)।
ছবি ৭১.১ — Haat-এর price-এর ৮০ byte-এর frame
বাঁয়ে s0-সাপেক্ষ offset, মাঝে ঘরের মান, ডানে sp-সাপেক্ষ offset
price(2, 520) চলার শেষ মুহূর্তের frame, Unicorn-এ চালানো সত্যিকারের ঠিকানায়। Frame record (লাল) psABI-র নিয়মে s0-এর ঠিক নিচে, তাই debugger বা profiler s0 থেকে ra আর আগের s0 পড়ে পুরো call-এর শিকল হাঁটতে পারে। ৮০ = ১৬ (frame record) + ৮ × ৮ (আটটি IR নাম), যা এমনিতেই ১৬-এর গুণিতক।নিয়মগুলো কোডে। প্রথম ভাগ layout-এর হিসাব; haat_ir.py পর্ব ৬২-এর (Intermediate representation) ফাইল, এই পাতায় হুবহু ব্যবহার করা হয়েছে, আর frame_layout শুধু তার IRFunction পড়ে।
# haat_abi.py — পর্ব ৭১: Haat-এর RV64 calling convention আর frame layout, RISC-V psABI মেনে।
# পর্ব ৭২ এই ফাইলটি হুবহু ব্যবহার করে। প্রতিটি IR নাম (parameter, variable, temp) একটি ৮ byte-এর stack slot পায়।
from dataclasses import dataclass
from haat_ir import *
XLEN, STACK_ALIGN, MAX_FRAME = 8, 16, 2032 # byte; 2032 = addi-র 12-bit সীমার মধ্যে ১৬-এর বড় গুণিতক
ARG_REGS = [f"a{i}" for i in range(8)] # প্রথম ৮টি argument; ফল a0-তে (Bool = 0/1, Unit = 0)
CALLEE_SAVED = [f"s{i}" for i in range(1, 12)] # s0 আলাদা: সেটি frame pointer
def symbol(name): # Haat-এর নাম -> assembly symbol; C-র main বা print_int-এর সঙ্গে সংঘাত নেই
return "haat_main" if name == "<main>" else "haat_" + name
def global_symbol(name): return "haat_g_" + name # top-level variable @x -> haat_g_x
@dataclass
class Frame:
name: str # Haat function-এর নাম
params: list # IR-এর parameter-নাম, ক্রমে
size: int # frame-এর মোট byte, ১৬-এর গুণিতক
saved: dict # register -> s0-সাপেক্ষ offset: ra -8, s0 -16, তারপর অনুরোধ করা s1 …
slots: dict # IR নাম -> s0-সাপেক্ষ offset; ৯ম parameter থেকে ধনাত্মক (caller-এর frame-এ)
out_args: int # frame-এর তলায়, sp+0 থেকে: ডাকের ৯ম, ১০ম … argument-এর জায়গা
def home(self, x): return f"{self.slots[x]}(s0)"
def frame_layout(fn, callee_saved=()): # fn: Haat IR-এর IRFunction (রৈখিক বা CFG রূপ)
code = [i for b in fn.blocks.values() for i in b] if fn.blocks else fn.code
names = list(fn.params)
for i in code: # প্রথম লেখার ক্রমে; @global-এর slot নেই
if i.dst and i.dst[0] != "@" and i.dst not in names: names.append(i.dst)
saved = {"ra": -8, "s0": -16}
for r in callee_saved: saved[r] = -8 * (len(saved) + 1)
slots, off = {}, -8 * len(saved)
for k, x in enumerate(names):
if 8 <= k < len(fn.params): slots[x] = 8 * (k - 8) # caller রেখে গেছে: 0(s0), 8(s0) …
else: off -= 8; slots[x] = off
out = 8 * max([len(i.args) - 8 for i in code if i.kind == "call"] + [0])
size = -off + out; size += -size % STACK_ALIGN
if size > MAX_FRAME: raise Unsupported(f"function '{fn.name}': frame of {size} bytes is too large")
return Frame(fn.name, list(fn.params), size, saved, slots, out)দ্বিতীয় ভাগ text বানায়: prologue, epilogue আর caller-এর দিকের call-এর ক্রম (calling sequence). পর্ব ৭২ এগুলোর লাইন ঠিক এভাবেই নিজের assembly-তে বসাবে।
def prologue(fr): # function-এর শুরুতে, label-সহ
F = fr.size
out = [f"{symbol(fr.name)}:", f" addi sp, sp, -{F}", f" sd ra, {F - 8}(sp)",
f" sd s0, {F - 16}(sp)", f" addi s0, sp, {F}"]
out += [f" sd {r}, {o}(s0)" for r, o in fr.saved.items() if r not in ("ra", "s0")]
return out + [f" sd {ARG_REGS[k]}, {fr.home(p)} # {p}" for k, p in enumerate(fr.params[:8])]
def epilogue(fr): # ফলের মান আগেই a0-তে রাখা হয়েছে
F = fr.size
out = [f" ld {r}, {o}(s0)" for r, o in fr.saved.items() if r not in ("ra", "s0")]
return out + [f" ld ra, {F - 8}(sp)", f" ld s0, {F - 16}(sp)", f" addi sp, sp, {F}", " ret"]
def call_seq(fr, ins): # caller-এর দিক: t = call f(a, b, …)
out = []
for k, a in enumerate(ins.args):
if k < 8: out.append(f" ld {ARG_REGS[k]}, {fr.home(a)}")
else: out += [f" ld t0, {fr.home(a)}", f" sd t0, {8 * (k - 8)}(sp)"]
return out + [f" call {symbol(ins.sym)}", f" sd a0, {fr.home(ins.dst)}"]এবার bazar.haat-এ চালিয়ে দেখুন। শেষ অংশে দশটি parameter-এর একটি function, যাতে নিয়ম ৭১.১-এর ধাপ ১ আর ৪ (stack-এ যাওয়া argument) দেখা যায়।
# Haat-এর frame: bazar.haat-এর তিনটি function, haat_abi.py দিয়ে
from haat_abi import *
mod = compile_ir(open("examples/bazar.haat", encoding="utf-8").read())
for fn in mod.funcs.values():
fr = frame_layout(fn)
print(f"{symbol(fn.name)}: {fr.size} byte · slot {len(fr.slots)}টি · out_args {fr.out_args}")
price = frame_layout(mod.funcs["price"])
print("\n".join(prologue(price)))
print(" # … body: প্রতিটি মান তার নিজের slot-এ …")
print("\n".join(epilogue(price)))
call = mod.funcs["<main>"].blocks["B0"][2] # t3 = call price(t1, t2)
print("#", call)
print("\n".join(call_seq(frame_layout(mod.funcs["<main>"]), call)))
# ১০টি parameter: ৯ম আর ১০ম আসে caller-এর frame থেকে
ps = ", ".join(f"{x}: Int" for x in "abcdefghij")
m = compile_ir(f"fn digits({ps}) -> Int {{ return a + j; }}\nprint(digits(1, 2, 3, 4, 5, 6, 7, 8, 9, 0));")
d, top = frame_layout(m.funcs["digits"]), frame_layout(m.funcs["<main>"])
print("digits:", d.size, "byte ·", {x: d.slots[x] for x in "ahij"}, "· <main>-এর out_args:", top.out_args)
print("\n".join(call_seq(top, m.funcs["<main>"].blocks["B0"][10])[-6:]))আসল আউটপুট (ব্রাউজারের Python):
haat_main: 160 byte · slot 17টি · out_args 0
haat_price: 80 byte · slot 8টি · out_args 0
haat_delivery: 64 byte · slot 5টি · out_args 0
haat_price:
addi sp, sp, -80
sd ra, 72(sp)
sd s0, 64(sp)
addi s0, sp, 80
sd a0, -24(s0) # qty
sd a1, -32(s0) # unit
# … body: প্রতিটি মান তার নিজের slot-এ …
ld ra, 72(sp)
ld s0, 64(sp)
addi sp, sp, 80
ret
# t3 = call price(t1, t2)
ld a0, -24(s0)
ld a1, -32(s0)
call haat_price
sd a0, -40(s0)
digits: 96 byte · {'a': -24, 'h': -80, 'i': 0, 'j': 8} · <main>-এর out_args: 16
ld t0, -88(s0)
sd t0, 0(sp)
ld t0, -96(s0)
sd t0, 8(sp)
call haat_digits
sd a0, -104(s0)
price-এর আটটি IR নাম (qty unit p t1 … t5) আর frame record মিলে ৮০ byte; <main>-এর ১৭টি নাম মিলে ১৫২, ১৬-এর গুণিতকে বাড়িয়ে ১৬০। Prologue-এর প্রথম চার লাইন সব function-এ একই ছাঁচের, শুধু সংখ্যা বদলায়; তারপর প্রতিটি register-argument তার slot-এ নামে। Epilogue-এ ld ra আর ld s0 হয় sp-সাপেক্ষ, কারণ body-তে sp নড়ে না, তাই প্রবেশের offset-ই ফেরার offset. Call-এর দিকে t1 আর t2 slot থেকে a0, a1-এ ওঠে, ফল a0 থেকে t3-এর slot-এ (-40(s0)) নামে। দশ parameter-এর digits-এ h পর্যন্ত slot নেগেটিভ, কিন্তু i আর j 0(s0) আর 8(s0)-এ: caller-এর frame-এর তলায়। আর caller <main> নিজের frame-এর নিচে ১৬ byte (out_args) রেখেছে, যেখানে ডাকের ঠিক আগে sd t0, 0(sp) আর sd t0, 8(sp).
৪ · একটি call, নির্দেশে নির্দেশে — main থেকে price
নিয়ম কাগজে এক জিনিস, চলন্ত যন্ত্রে আরেক। লেখকের lab-এ একটি ছোট পরীক্ষা-generator (শুধু এই পর্বের যাচাইয়ের জন্য; আসল back end পর্ব ৭২-এর) Haat IR থেকে এই frame মেনে RV64 assembly লিখেছে; সত্যিকারের Clang সেটি assemble আর link করেছে, আর emulator Unicorn সেটি চালিয়েছে। নিচের প্রতিটি সংখ্যা সেই run-এর register থেকে নেওয়া (call-depth গোনার কয়েকটি lab-নির্দেশ বাদ দিয়ে দেখানো)।
1ld a0, -24(s0) # main: t12ld a1, -32(s0) # t23call haat_price4addi sp, sp, -80 # price5sd ra, 72(sp)6sd s0, 64(sp)7addi s0, sp, 808sd a0, -24(s0) # qty9sd a1, -32(s0) # unit10… body: p, t1 … t5 …11ld a0, -80(s0) # t512ld ra, 72(sp); ld s0, 64(sp)13addi sp, sp, 80; ret14sd a0, -40(s0) # main: t3
| sp | |
| s0 | |
| ra | |
| a0 · a1 | |
| মেমরি |
- Argument register-এ।
main-এর slot থেকেt1= 2 আরt2= 520 উঠলa0আরa1-এ।sp=0x7FEFFF60, যা ১৬-এর গুণিতক (শেষ hex অঙ্ক 0), আর এটিইprice-এর CFA হবে।ra-তে এখনোmain-এর নিজের ফেরার ঠিকানা। - Call.
callএকটি pseudo-instruction (auipc+jalr): পরের নির্দেশের ঠিকানা0x10011DCগেলra-তে, লাফhaat_price-এ।main-এরraমুছে গেল; সেটিmainনিজের prologue-এ আগেই stack-এ রেখেছিল। - জায়গা নেওয়া।
addi sp, sp, -80:sp=0x7FEFFF10. ৮০ ১৬-এর গুণিতক, তাইpriceকাউকে ডাকলে সেই ডাকেওspসাজানো থাকত। - Frame record.
raগেলsp+72=0x7FEFFF58-এ,main-এরs0গেলsp+64=0x7FEFFF50-এ।s0callee-saved, তাইpriceসেটি বদলানোর আগে রাখতে বাধ্য। - নতুন frame pointer.
s0=sp + 80=0x7FEFFF60= CFA. এখনraঠিকs0−8-এ আর পুরোনোs0s0−16-এ, psABI-র frame pointer নিয়মের হুবহু। - Parameter slot-এ।
qty= 2 গেলs0−24=0x7FEFFF48-এ,unit= 520 গেল0x7FEFFF40-এ। এখন থেকে body শুধু slot পড়ে আর লেখে,a0/a1ছুঁয়ে দেখে না। - Body আর ফল।
p= 1040, তুলনা সত্য,t4= 104,t5= 936 গেলs0−80=0x7FEFFF10-এ (ঠিকsp+0).ld a0, -80(s0): ফল এখনa0-তে, চুক্তির ফেরত-register-এ। - Epilogue. উল্টো ক্রমে:
ra=0x10011DC,s0=0x7FF00000(main-এর),sp=0x7FEFFF60;retলাফ দিলra-তে। Callee-savedspআরs0ঠিক আগের মানে, যা Unicorn-এর পরীক্ষাও মিলিয়ে দেখেছে। mainআবার।sd a0, -40(s0): ফল 936 গেলmain-এরt3-এর slot-এ,0x7FF00000 − 40=0x7FEFFFD8.price-এর ৮০ byte-এ পুরোনো মান পড়ে থাকে; পরের call (delivery) সেগুলোর ওপর লিখবে।
এই frame কি সত্যিকারের compiler-এর মতো? যাচাইয়ের জন্য একই আকারের একটি C function, যা price-কে ডেকে ৬০ যোগ করে, Clang দিয়ে -O0-তে RISC-V-এ নামানো হলো (সত্যিকারের run, Zig 0.17.1-এর সঙ্গে আসা Clang 22.1.8; -fno-sanitize=undefined; directive আর মন্তব্য বাদ)। ডানে একই কাজের Haat function-এর জন্য haat_abi.py-র লেখা কোড:
~/abi $ python -m ziglang cc -target riscv64-linux-musl -O0 -S -g0 \
-fno-sanitize=undefined cart.c # cart(qty, unit) = price(qty, unit) + 60
cart: (Clang -O0) haat_cart: (Haat ABI v1)
addi sp, sp, -48 addi sp, sp, -64
sd ra, 40(sp) sd ra, 56(sp)
sd s0, 32(sp) sd s0, 48(sp)
addi s0, sp, 48 addi s0, sp, 64
sd a0, -24(s0) sd a0, -24(s0) # qty
sd a1, -32(s0) sd a1, -32(s0) # unit
ld a0, -24(s0) ld a0, -24(s0)
ld a1, -32(s0) ld a1, -32(s0)
call price call haat_price
sd a0, -40(s0) sd a0, -40(s0)
… …
ld ra, 40(sp) ld ra, 56(sp)
ld s0, 32(sp) ld s0, 48(sp)
addi sp, sp, 48 addi sp, sp, 64
ret ret
প্রায় লাইনে লাইনে এক: একই frame record, একই slot-এর offset, একই call-এর ক্রম। একমাত্র পার্থক্য আকারে, কারণ Haat IR 60 আর যোগফলের জন্য দুটি আলাদা temp রাখে (t1, t2), আর Clang addi a0, a0, 60 দিয়ে register-এই সেরে ফেলে। এটি কাকতালীয় নয়: Clang-এর -O0 নিজেও “প্রতিটি variable-এর একটি slot” নীতি মানে, আর দুটিই একই psABI মানে।
৫ · তিন platform, একটি C function — সত্যিকারের Clang
এবার ABI-র পার্থক্যগুলো এক জায়গায়। একটি C function, যা একটি ১৬ byte-এর struct নেয় আর দশ argument-এর একটি function ডাকে, তিনটি target-এ (সত্যিকারের run, Clang 22.1.8, -O2 -fno-sanitize=undefined; x86-এ Intel syntax; directive বাদ)। সব type long long, কারণ Windows-এ long মাত্র ৪ byte (LLP64); ABI-র তুলনায় এই ফাঁদটি আগে সরিয়ে রাখা ভালো।
struct item { long long qty; long long unit; };
long long sum10(long long a, …, long long j); /* দশটি long long */
long long order(struct item it) {
return sum10(1, 2, 3, 4, 5, 6, 7, 8, 9, 10) + it.qty * it.unit;
}
order:
addi sp, sp, -48
sd ra, 40(sp)
sd s0, 32(sp)
sd s1, 24(sp) # callee-saved: বাঁচাতে হবে
sd s2, 16(sp)
addi s0, sp, 48
mv s2, a1 # it.unit (struct-এর ২য় অর্ধেক)
mv s1, a0 # it.qty (১ম অর্ধেক)
li t0, 10
li t1, 9
li a0, 1 # a0 … a7 = 1 … 8
…
li a7, 8
sd t1, 0(sp) # ৯ম argument
sd t0, 8(sp) # ১০ম argument
call sum10
mul a1, s1, s2
add a0, a0, a1
ld ra, 40(sp)
ld s0, 32(sp)
ld s1, 24(sp)
ld s2, 16(sp)
addi sp, sp, 48
ret
order:
push rbp
mov rbp, rsp
push r14 # callee-saved
push rbx
mov rbx, rsi # it.unit
mov r14, rdi # it.qty
mov edi, 1 # rdi rsi rdx rcx r8 r9 = 1 … 6
mov esi, 2
mov edx, 3
mov ecx, 4
mov r8d, 5
mov r9d, 6
push 10 # ৭ম–১০ম: ডান থেকে push
push 9
push 8
push 7
call sum10@PLT
add rsp, 32 # caller নিজের argument সরায়
imul r14, rbx
add rax, r14
pop rbx
pop r14
pop rbp
ret
order:
push rbp
push rsi # Windows-এ rsi callee-saved
sub rsp, 88
lea rbp, [rsp + 80]
mov rsi, rcx # it-এর কপির ঠিকানা
mov qword ptr [rsp + 72], 10
mov qword ptr [rsp + 64], 9
mov qword ptr [rsp + 56], 8
mov qword ptr [rsp + 48], 7
mov qword ptr [rsp + 40], 6
mov qword ptr [rsp + 32], 5 # [rsp+0…31] = shadow space
mov ecx, 1 # rcx rdx r8 r9 = 1 … 4
mov edx, 2
mov r8d, 3
mov r9d, 4
call sum10
mov rcx, qword ptr [rsi + 8] # it.unit, মেমরি থেকে
imul rcx, qword ptr [rsi] # it.qty
add rax, rcx
add rsp, 88
pop rsi
pop rbp
ret
তিনটি পার্থক্য পড়ুন। (১) Struct: RISC-V আর System V দুটিতেই ১৬ byte-এর it এসেছে দুটি register-এ (a0/a1, rdi/rsi); Windows-এ শুধু ১, ২, ৪ বা ৮ byte-এর struct register-এ যায়, তাই it এসেছে একটি কপির ঠিকানা হয়ে rcx-এ, আর গুণের সময় মেমরি থেকে পড়া হয়েছে। (২) বেশি argument: RISC-V-এ ৮টি register, তাই শুধু ৯ আর ১০ stack-এ; System V-এ ৬টি, তাই ৭–১০ stack-এ; Windows-এ ৪টি, তাই ৫–১০ stack-এ, আর তাও ৩২ byte-এর shadow space-এর ওপরে। (৩) Callee-saved: qty আর unit-কে call পেরিয়ে রাখতে প্রত্যেকে নিজের ABI-র একটি callee-saved register বেছেছে: s1/s2, r14/rbx, আর Windows-এ rsi, যা System V-এ আবার caller-saved argument register! একই নামের register দুই চুক্তিতে দুই ভূমিকায়।
নিচের ব্লক এই নিয়মগুলোর একটি ছোট মডেল: শুধু ৮ byte-এর integer (I) আর দুটি long long-এর struct (S). এর উত্তর লেখকের lab-এ Clang-এর সত্যিকারের আউটপুটের সঙ্গে মেলানো হয়েছে (sum10, আর মাঝখানে struct-সহ g5 ও g7).
# একটি C ডাকের argument কোন ABI-তে কোথায় যায় — শুধু 8 byte-এর integer (I) আর 16 byte-এর struct (S, দুটি long long)
ABIS = {"RISC-V LP64": [f"a{i}" for i in range(8)],
"System V x86-64": ["rdi", "rsi", "rdx", "rcx", "r8", "r9"],
"Windows x64": ["rcx", "rdx", "r8", "r9"]}
def places(abi, args): # ফেরত: প্রতিটি argument-এর জায়গা, ডাকের মুহূর্তে sp থেকে
regs, r, out = ABIS[abi], 0, []
off = 32 if abi == "Windows x64" else 0 # Windows: প্রথম ৩২ byte shadow space
def stack(n):
nonlocal off; s = " + ".join(f"[sp+{off + 8 * i}]" for i in range(n)); off += 8 * n; return s
for k, a in enumerate(args):
if abi == "Windows x64": # অবস্থান-ভিত্তিক; 8 byte-এর বড় struct যায় pointer হয়ে
what = regs[k] if k < 4 else stack(1)
out.append(what if a == "I" else f"ptr→{what}")
elif a == "I" or abi == "RISC-V LP64":
n = 1 if a == "I" else 2 # RISC-V: শেষ register-এ আধা, বাকি আধা stack-এ
got = regs[r:r + n]; r += len(got)
out.append(" + ".join(got + ([stack(n - len(got))] if n > len(got) else [])))
else: # System V: struct-এর দুই অংশই register-এ ধরলে, নইলে পুরোটা stack-এ
if r + 2 <= len(regs): out.append(" + ".join(regs[r:r + 2])); r += 2
else: out.append(stack(2))
return out
calls = {"sum10(10 × I)": ["I"] * 10, "g5(5 × I, S, I)": ["I"] * 5 + ["S", "I"],
"g7(7 × I, S, I)": ["I"] * 7 + ["S", "I"]}
for name, args in calls.items():
print(name)
for abi in ABIS:
print(f" {abi:16}", " · ".join(places(abi, args)[4:])) # প্রথম ৪টি সবখানে register-এআসল আউটপুট (ব্রাউজারের Python):
sum10(10 × I)
RISC-V LP64 a4 · a5 · a6 · a7 · [sp+0] · [sp+8]
System V x86-64 r8 · r9 · [sp+0] · [sp+8] · [sp+16] · [sp+24]
Windows x64 [sp+32] · [sp+40] · [sp+48] · [sp+56] · [sp+64] · [sp+72]
g5(5 × I, S, I)
RISC-V LP64 a4 · a5 + a6 · a7
System V x86-64 r8 · [sp+0] + [sp+8] · r9
Windows x64 [sp+32] · ptr→[sp+40] · [sp+48]
g7(7 × I, S, I)
RISC-V LP64 a4 · a5 · a6 · a7 + [sp+0] · [sp+8]
System V x86-64 r8 · r9 · [sp+0] · [sp+8] + [sp+16] · [sp+24]
Windows x64 [sp+32] · [sp+40] · [sp+48] · ptr→[sp+56] · [sp+64]
প্রথম চারটি argument তিন ABI-তেই register-এ, তাই পঞ্চম থেকে দেখানো। g5-এ মজার জিনিস: System V-এ struct-এর জন্য দরকার দুটি register, কিন্তু খালি আছে শুধু r9, তাই পুরো struct stack-এ যায়, আর পরের 99 সেই খালি r9 পায়। Clang-এর আসল কোডেও তাই: mov r9d, 99. RISC-V একই অবস্থায় struct ভেঙে দেয়: g7-এ প্রথম অর্ধেক (11) a7-এ, দ্বিতীয় অর্ধেক (12) 0(sp)-এ, আর 99 8(sp)-এ; Clang-এর listing-এ ঠিক li a7, 11, sd t1, 0(sp) (t1 = 12), sd t0, 8(sp) (t0 = 99). Windows-এ argument-এর অবস্থান তার ক্রমিক নম্বরেই বাঁধা, আর struct সবসময় একটি ঠিকানা। এটি মডেল, পূর্ণ নিয়ম নয়: float, ছোট struct আর __int128-এর নিয়ম বাদ।
1SV: push rbp, r14, rbx2W: push rbp, rsi; sub rsp, 883SV: rsi → rbx, rdi → r144W: rcx → rsi5SV: edi…r9d = 1…66W: ecx…r9d = 1…47SV: push 10, 9, 8, 78W: [rsp+32…72] = 5…109call sum1010SV: add rsp, 32
| System V | |
| Windows |
- Callee-saved রাখা আর alignment.
order-এ ঢোকার মুহূর্তে দুই ABI-তেইrsp১৬-এর গুণিতক থেকে ৮ বেশি, কারণcall৮ byte-এর ফেরার ঠিকানা ঠেলে দিয়েছে। System V তিনটি push করে (৮ + ২৪ = ৩২), Windows দুটি push আর ৮৮ (৮ + ১৬ + ৮৮ = ১১২): দুটিতেই আবার ১৬-এর গুণিতক। - Struct. System V-এ
it-এর দুই অর্ধেকrdiআরrsi-এ এসেছিল, call-এর আগে callee-savedr14আরrbx-এ সরানো হলো। Windows-এrcx-এ এসেছে caller-এর বানানো কপির ঠিকানা; সেটিকে callee-savedrsi-তে রাখা হলো। - Register argument. System V-এ প্রথম ছয়টি:
rdi rsi rdx rcx r8 r9. Windows-এ প্রথম চারটি:rcx rdx r8 r9. ছোট ধ্রুবকের জন্য compiler ৩২ বিটের নাম (edi) লেখে; x86-64-এ ৩২ বিটের লেখা ওপরের ৩২ বিট শূন্য করে দেয়। - Stack argument. System V ডান থেকে বাঁয়ে push করে, তাই ডাকের মুহূর্তে
[rsp+0]= 7. Windows আগেই জায়গা নিয়ে রেখেছে;[rsp+0]থেকে[rsp+31]খালি shadow space, আর ৫ থেকে ১০ তার ওপরে। - Callee-র চোখে।
callআবার ৮ byte (ফেরার ঠিকানা) ঠেলে দেয়, তাইsum10-এর কাছে সব ৮ ওপরে: System V-এ ৭ম argument[rsp+8]-এ, Windows-এ ৫ম[rsp+40]-এ। Windows-এরsum10চাইলেrcx…r9shadow space-এ নামিয়ে রাখতে পারে, যেন সব argument মেমরিতে পাশাপাশি; varargs function-এর জন্য এটি খুব সুবিধার। - পরিষ্কার করা। System V-এর caller push করা ৩২ byte সঙ্গে সঙ্গে সরায়। Windows-এর caller-এর জায়গা prologue-এ একবারে নেওয়া, তাই ফেরার পরে কিছু করতে হয় না; frame ছাড়ার সময় একসাথে
add rsp, 88. দুই পথেই callee কখনো caller-এর argument সরায় না।
৬ · Caller-saved, callee-saved আর red zone — কে কখন বাঁচায়
Register-কে দুই দলে ভাগ করা একটি অর্থনৈতিক সিদ্ধান্ত। সব register caller-saved হলে প্রতিটি call-এর আগে-পরে caller-কে অনেক কিছু রাখতে-তুলতে হতো; সব callee-saved হলে প্রতিটি ছোট function-কে যা ছোঁয় সব রাখতে হতো। দুই দলে ভাগ করলে compiler বেছে নিতে পারে: অল্প সময় বাঁচা মান t আর a-তে, call পেরিয়ে বাঁচা মান s-এ। নিচে Clang-এর RISC-V order, লেখকের lab-এ Unicorn-এ সত্যি চালানো (C-তে লেখা sum10 আর it = {2, 520}; ছাপা ফল 1095).
1addi sp, sp, -482sd ra, 40(sp); sd s0, 32(sp)3sd s1, 24(sp); sd s2, 16(sp)4addi s0, sp, 485mv s2, a1 · mv s1, a06li a0 … a7 = 1 … 879 → 0(sp) · 10 → 8(sp)8call sum109mul a1, s1, s210add a0, a0, a111ld ra, s0, s1, s2 · ret
| a0 | |
| a1 | |
| s1 · s2 | |
| stack-এ |
- Callee হিসেবে নিজের দায়।
orderনিজে একটি callee: সেs1আরs2ব্যবহার করবে, তাই caller-এর মান দুটি আগে stack-এ রাখল;callকরবে, তাইra-ও।a0= 2 আরa1= 520 হলো struct-এর দুই অর্ধেক। - নিরাপদ ঘরে সরানো।
a0/a1এখনই নতুন argument-এ ভরবে, আর call-এর পরে তো কোনো নিশ্চয়তাই নেই। তাইqtyআরunitগেলs1,s2-এ। - নতুন argument.
a0…a7= 1 … 8, আর ৯, ১০ stack-এর তলায় (0(sp),8(sp)), প্রথম stack-argument offset শূন্যে, psABI অনুযায়ী। - Call-এর পরে।
a0= 55,sum10-এর ফল।a1-এ কী আছে, চুক্তি কিছুই বলে না (তাই “অজানা”)। কিন্তুs1= 2 আরs2= 520 অক্ষত:sum10সেগুলো ছুঁলে আগে রাখত আর ফিরিয়ে দিত। - গুণ।
a1= 2 × 520 = 1040. Call-এর পরেa1-কে নির্ভয়ে নতুন কাজে লাগানো যায়, কারণ এটি caller-saved. - ফল।
a0= 55 + 1040 = 1095, যা Unicorn-এর run-এprint_intসত্যিই ছেপেছে। - দায় ফেরত।
ra,s0,s1,s2stack থেকে আগের মানে ফিরল,sp৪৮ বাড়ল। Lab-এর পরীক্ষক ফেরার মুহূর্তেspআরs0–s11আগের মানের সঙ্গে মিলিয়ে দেখেছে: মিলেছে।
Red zone — stack pointer-এর নিচে লেখা যায় কি?
System V x86-64-এ উত্তর হ্যাঁ, ১২৮ byte পর্যন্ত। ওই অঞ্চলটিকে signal handler বা interrupt নষ্ট করবে না বলে ABI কথা দেয়, তাই একটি leaf function rsp না সরিয়েই সেখানে local রাখতে পারে। Windows x64 আর RISC-V-এ এমন কোনো অঞ্চল নেই। একই leaf function, -O0-তে (সত্যিকারের run, Clang 22.1.8, Intel syntax):
long long price(long long qty, long long unit) { long long p = qty * unit; return p; }
x86_64-linux-gnu (System V) x86_64-windows-gnu (Windows x64)
push rbp push rbp
mov rbp, rsp sub rsp, 24
mov [rbp - 8], rdi lea rbp, [rsp + 16]
mov [rbp - 16], rsi mov [rbp], rcx
mov rax, [rbp - 8] mov [rbp - 8], rdx
imul rax, [rbp - 16] mov rax, [rbp]
mov [rbp - 24], rax imul rax, [rbp - 8]
mov rax, [rbp - 24] mov [rbp - 16], rax
pop rbp mov rax, [rbp - 16]
ret add rsp, 24
pop rbp
ret
বাঁয়ে rbp = rsp, অথচ তিনটি মান লেখা হলো rbp−8 থেকে rbp−24-এ, অর্থাৎ rsp-এর নিচে: red zone-এর ব্যবহার, sub rsp ছাড়াই। ডানে Windows আগে sub rsp, 24 দিয়ে জায়গা নেয়। লাভ মাত্র দুটি নির্দেশ, কিন্তু ছোট function কোটি বার চললে সেটিও হিসাবের। একটি সতর্কতা: operating system-এর kernel-এর কোডে red zone চলে না, কারণ সেখানে interrupt একই stack ব্যবহার করে; Linux kernel তাই -mno-red-zone দিয়ে build হয়।
৭ · যাচাই — ABI-ভঙ্গ কেন নিঃশব্দ, আর কীভাবে ধরবেন
ABI-র ভুলের সবচেয়ে বিপজ্জনক দিক: প্রায়ই কিছুই ঘটে না। ভুল alignment-এ বেশিরভাগ নির্দেশ ঠিকই চলে; ভাঙে শুধু যখন কোনো C library-র কোড ধরে নেয় যে stack সাজানো। তাই লেখকের lab-এ (Windows, CPython 3.14.4) তিন স্তরের পরীক্ষা চালানো হয়েছে:
- Differential test: lab-এর পরীক্ষা-generator এই পর্বের frame দিয়ে Haat IR থেকে RV64 কোড লিখেছে, Clang 22.1.8 (
-target riscv64-linux-musl) assemble আর link করেছে, আর PyPI-রunicorn2.1.4 (Python binding BSD, ভেতরের engine QEMU-ভিত্তিক বলে GPLv2; শুধু lab-এ ব্যবহার) সেটি চালিয়েছে। পর্ব ৬২-এর ২০০টি এলোমেলো program-এর ২০০টিরই আউটপুট reference-এরpython -B haat.py run-এর সঙ্গে অক্ষরে অক্ষরে এক; এর ২৪টি শূন্য দিয়ে ভাগে থামে, আর সেখানেও runtime error-এর বার্তা আরline:colএক; reference-এর উদাহরণের মধ্যেbazar,mutualআরrecursion-ও এক। reference-এর বাকি ১১টি উদাহরণ বাদ: দুটিতে closure বা nested function (Haat IR v1-এর বাইরে), আর বাকিগুলোতে string বা ইচ্ছাকৃত static error (lab-generator string জানে না, আর static error-এর program চালানোর কিছু নেই)। - প্রতিটি call-এ ABI পরীক্ষা: emulator প্রতিটি function-এ ঢোকার মুহূর্তে
sp % 16 == 0দেখেছে, আর ফেরার মুহূর্তেspওs0–s11ঢোকার সময়ের মানের সঙ্গে মিলিয়েছে। এলোমেলো program-গুলোতে ১,৪৩১টি call,recursion.haat-এ ২২,১১৬টি; একটিতেও নিয়ম ভাঙেনি।frame_layout(fn, callee_saved=("s1", "s2"))দিয়ে, body-তেs1,s2-এ ইচ্ছা করে নতুন মান লিখে, ৬০টি program-এও একই ফল। - অন্য compiler-এর সঙ্গে FFI: Clang-এর C কোড Haat-এর দশ-parameter-এর
digits-কেhaat_digits(1, 2, …, 9, 0)নামে ডেকেছে, আর Haat-এর<main>C-তে লেখাhaat_digits-কে ডেকেছে। দুই দিকেই ছাপা হয়েছে1234567890: দশটি অঙ্কের ক্রম ঠিক থাকা মানে register-এর আটটি আর stack-এর দুটি argument দুই পক্ষ একই জায়গায় খুঁজেছে।
পরীক্ষক নিজে ভুল ধরতে পারে কি না, সেটিও দেখা দরকার। তাই দুটি ইচ্ছাকৃত ভুল: frame-এর আকার ১৬-এর বদলে ৮-এর গুণিতকে বাড়ালে bazar.haat তবুও 996, 5000, 3 ছেপেছে (নিঃশব্দ ভুল!), কিন্তু পরীক্ষক তিনটি call-এ “sp misaligned” ধরেছে। আর epilogue থেকে ld s0 মুছে দিলে প্রথম লাইনেই ভুল ফল 60, কারণ ফেরার পরে main ভুল s0 দিয়ে নিজের slot পড়ছে। নিচের ব্লক একই নিয়মগুলোর স্থির (static) রূপ চালায়: emulator ছাড়াই, প্রতিটি frame-এর আকার, slot-এর অমিল আর prologue-epilogue-এর প্রতিসাম্য।
# frame_layout-এর নিয়মগুলো যাচাই: উদাহরণ আর ২০০টি এলোমেলো program-এর প্রতিটি function-এ
from haat_abi import *
from haat_gen import gen_program
def check(fn):
fr, bad = frame_layout(fn), []
F, offs = fr.size, list(fr.saved.values()) + list(fr.slots.values())
if F % STACK_ALIGN or F > MAX_FRAME: bad.append("size")
if len(set(offs)) != len(offs) or any(o % 8 for o in offs): bad.append("overlap")
low = -F + fr.out_args # সবচেয়ে নিচের slot-ও out_args-এর ওপরে
if any(o < low for o in offs if o < 0): bad.append("below")
pro, epi = prologue(fr), epilogue(fr)
if {l.replace("sd", "ld") for l in pro if l.startswith(" sd") and "(sp)" in l} != {l for l in epi if "(sp)" in l and "ld" in l}:
bad.append("mirror")
return fr, bad
srcs = {n: open(f"examples/{n}.haat", encoding="utf-8").read() for n in
("bazar", "recursion", "mutual", "shadowing", "shortcircuit", "strings", "loops", "err_divzero", "counter", "nested")}
srcs.update({f"seed{s}": gen_program(s) for s in range(200)})
nf = skipped = 0; sizes, bad = [], []
for name, src in srcs.items():
try: mod = compile_ir(src)
except Unsupported as e: skipped += 1; print(f"{name}: বাদ — {e}"); continue
for fn in mod.funcs.values():
fr, b = check(fn); nf += 1; sizes.append(fr.size)
bad += [(name, fn.name, x) for x in b]
print(f"function: {nf} · বাদ program: {skipped} · নিয়ম-ভঙ্গ: {len(bad)}")
print(f"frame-এর আকার: ছোট {min(sizes)} · মাঝের {sorted(sizes)[len(sizes) // 2]} · বড় {max(sizes)} byte")
fr = frame_layout(compile_ir(srcs["recursion"]).funcs["fib"])
print("fib:", fr.size, "byte ·", fr.slots)আসল আউটপুট (ব্রাউজারের Python):
counter: বাদ — 4:16: closures and function values are not in Haat IR v1
nested: বাদ — 3:8: nested functions are not in Haat IR v1
function: 617 · বাদ program: 2 · নিয়ম-ভঙ্গ: 0
frame-এর আকার: ছোট 32 · মাঝের 240 · বড় 1744 byte
fib: 96 byte · {'n': -24, 't1': -32, 't2': -40, 't3': -48, 't4': -56, 't5': -64, 't6': -72, 't7': -80, 't8': -88, 't9': -96}
৬১৭টি function-এর কোনোটিতে নিয়ম ভাঙেনি। আকারের পরিসর মনে রাখার মতো: ছোট function ৩২ byte (frame record আর দুটি slot), কিন্তু সবচেয়ে বড়টি ১,৭৪৪ byte, কারণ প্রতিটি temp-এর আলাদা slot আর এলোমেলো program-এর <main>-এ অনেক temp. লেখকের lab-এ প্রথম ৩,০০০টি seed-এর ৯,০০১টি function-এর সবচেয়ে বড়টি ১,৯৮৪ byte, ২,০৩২-এর সীমার খুব কাছে; একটিও সীমা পেরোয়নি। এখানেই বোঝা যায় পর্ব ৭০-এর register allocation কেন দরকার: যে temp-গুলো কখনো একসাথে বাঁচে না, তারা একই register বা slot ভাগ করতে পারত। fib-এর frame দেখুন: n আর নয়টি temp, ৯৬ byte; recursion-এ ২০ গভীরতায় প্রায় দুই কিলোবাইট stack.
পরীক্ষা ও ইন্টারভিউতে: বিশ্ববিদ্যালয়, চাকরি বা ইন্টারভিউর পরীক্ষায় এই ধরনের প্রশ্ন প্রায়ই আসে:
- Caller-saved আর callee-saved-এর পার্থক্য? প্রথমটি ডাকা function নষ্ট করতে পারে, দরকার হলে caller রাখে; দ্বিতীয়টি ডাকা function ব্যবহার করলে নিজে রেখে ফিরিয়ে দেয়।
- RISC-V-এ ৯ম integer argument কোথায়? Callee-তে ঢোকার মুহূর্তে
0(sp)-তে; ১০মটি8(sp)-এ। - ABI আর API-র পার্থক্য? API উৎসের স্তরের চুক্তি (নাম, type), ABI binary-র স্তরের (register, layout, symbol). API না বদলেও ABI ভাঙতে পারে।
- Shadow space কী? Windows x64-এ প্রতিটি call-এর আগে caller-এর রাখা ৩২ byte, যেখানে callee চারটি register argument নামিয়ে রাখতে পারে।
- Stack কেন ১৬ byte-এ সাজানো? ABI-র নিয়ম; ১৬ byte-এর data (SIMD,
long double-এর মতো) সাজানো ঠিকানা চায়, আর প্রতিটি function ধরে নিতে পারে যে ঢোকার সময় stack সাজানো।
৮ · ABI-র বাকি অংশ — নাম, varargs, স্থিরতা আর অন্য ভাষা
Symbol-এর নাম আর name mangling
Linker শুধু নাম মেলায় (পর্ব ৭৪, Linking আর loading). C-তে নামই symbol: price. C++-এ একই নামের কয়েকটি overload আর namespace থাকে, তাই compiler নামের সঙ্গে type জুড়ে দেয়: name mangling. সত্যিকারের run (Clang 22.1.8, zig c++ -S -O2), একই ফাইল দুই target-এ:
namespace bazar { long long price(long long qty, long long unit); }
long long price(long long qty, long long unit);
long long price(long long qty);
extern "C" long long c_price(long long qty, long long unit);
x86_64-linux-gnu x86_64-windows-msvc
_ZN5bazar5priceExx ?price@bazar@@YA_J_J0@Z
_Z5pricexx ?price@@YA_J_J0@Z
_Z5pricex ?price@@YA_J_J@Z
c_price c_price
Linux-এ GCC আর Clang যে নিয়ম মানে, তার নাম Itanium C++ ABI (মূলত Intel Itanium-এর জন্য লেখা, পরে প্রায় সব Unix-ধাঁচের platform-এ গৃহীত): _Z, তারপর দৈর্ঘ্যসহ নাম, তারপর parameter-এর type-কোড (x = long long). Microsoft-এর নিয়ম সম্পূর্ণ আলাদা। extern "C" লিখলে mangling বন্ধ, নাম হুবহু থাকে; এজন্যই অন্য ভাষা থেকে C++ ডাকতে প্রায় সবসময় একটি extern "C" সেতু লাগে। Haat-এর haat_ উপসর্গও একই কাজের সরল রূপ: Haat-এর নাম এক জায়গায় আর C-র নাম আরেক জায়গায়।
Varargs
printf-এর মতো variadic function-এর জন্য ABI-গুলো আলাদা ছাড় রাখে, কারণ callee জানে না কয়টি আর কোন type-এর argument আসছে। RISC-V psABI v1.0-এ variadic argument সাধারণ নিয়মেই যায়, একটি ব্যতিক্রমে: ২×XLEN alignment-এর argument (RV64-এ যেমন ১৬ byte-এর __int128) একটি “সাজানো জোড়া”-য় যায়, যার প্রথম register জোড়-নম্বরের। Windows x64-এ varargs-এর float মান XMM register আর সাধারণ register দুটিতেই রাখতে হয়, আর shadow space-এর কারণে callee সব argument মেমরিতে পাশাপাশি পায়। ভুল prototype দিয়ে varargs ডাকা (যেমন printf-এ %d-এর জায়গায় long long) C-তে undefined behavior; ABI ঠিক কী করবে, তা নির্ভর করে platform-এর ওপর (C কোর্সের পর্ব ৪৮)।
ABI-র স্থিরতা আর ভাঙন
একটি shared library-র নতুন version পুরোনো program-এর সঙ্গে চলবে কি না, তা ঠিক করে ABI, API নয়। এই binary compatibility রাখা কঠিন: struct-এ field যোগ, একটি function-এ parameter যোগ, এমনকি inline function-এর দেহ বদলানোও পুরোনো binary ভাঙতে পারে। পরিচিত একটি উদাহরণ: C++11-এর নিয়ম মানতে GCC 5-এর সময় (২০১৫ সালের দিকে) libstdc++-কে std::string আর std::list-এর নতুন layout আনতে হয়, আর পুরোনো binary চালু রাখতে দুটি ABI পাশাপাশি রাখা হয় (“dual ABI”). Rust উল্টো পথ নিয়েছে: Rust-এর নিজের ABI স্থির নয়, compiler version বদলালে বদলাতে পারে; স্থির চুক্তি চাইলে extern "C" আর #[repr(C)] লিখতে হয় (পর্ব ৭৬)।
FFI — অন্য ভাষা থেকে ডাকা
Python-এর ctypes, Java-র JNI, Node-এর native addon: সবই শেষ পর্যন্ত platform-এর C ABI মেনে argument বসায়। Runtime-এ অজানা signature-এর function ডাকতে অনেক ভাষা libffi-এর মতো library ব্যবহার করে, যা প্রতিটি ABI-র নিয়ম (অংশ ৫-এর মডেলের পূর্ণ রূপ) জানে। Haat-ও তাই করবে: পর্ব ৭২-এ Haat-এর print শেষ পর্যন্ত একটি ছোট runtime function ডাকবে, আর সেই ডাক এই পর্বের নিয়মে চলবে। মনে রাখার মতো বিপদ: FFI-তে compiler দুই পাশের type মেলাতে পারে না। ctypes-এ argtypes ভুল দিলে Python কোনো error দেয় না; ভুল register-এ ভুল মান যায়, আর program হয়তো ভুল ফল নিয়ে চলতেই থাকে।
আরও গভীরে: Exception বা debugger-এর stack হাঁটা frame pointer-এর ওপর নির্ভর করে না: ELF-এ .eh_frame-এর DWARF CFI (call frame information) বলে দেয় প্রতিটি নির্দেশে CFA কোথায় আর কোন register কোথায় রাখা; Clang-এর আউটপুটের .cfi_* directive সেটিই লেখে, আর Windows-এ একই কাজ করে .pdata/.xdata (Clang-এর .seh_*)। Compiler-এর ভেতরে প্রতিটি target-এর calling convention আলাদা করে লেখা থাকে; LLVM-এ অনেক target-এর নিয়ম TableGen বর্ণনায়, যা থেকে C++ কোড তৈরি হয়। আর নিরাপত্তার জন্য নতুন hardware shadow stack যোগ করছে (x86-এ Intel CET, RISC-V-এ Zicfiss extension), যেখানে ফেরার ঠিকানার একটি আলাদা কপি থাকে; এতে ABI-তেও নতুন নিয়ম আসে।
৯ · AI-এর যুগে calling convention
AI assistant-কে “RISC-V-এ এই function-এর prologue লেখো” বললে উত্তর প্রায়ই দেখতে নির্ভুল। কিন্তু অংশ ৭ দেখিয়েছে, ABI-র ভুল নিঃশব্দ: ভুল alignment-এর কোডও সঠিক ফল ছাপতে পারে। তাই দেখতে ঠিক হওয়া কোনো প্রমাণ নয়।
| AI-এর ভুল | কীভাবে ধরবেন |
|---|---|
এক platform-এর নিয়ম সব platform-এ চালানো: Linux-এর rdi Windows-এ, বা long সবখানে ৮ byte | লক্ষ্য-target ঠিক করে Clang-এর -S আউটপুট পড়া; sizeof(long) দুই target-এ |
Frame-এর আকার ১৬-এর গুণিতক না রাখা, বা RISC-V-এ sp-এর নিচে লেখা (red zone ধরে নেওয়া) | Emulator-এ প্রতিটি call-এ sp % 16 আর sp-এর নিচে লেখা পরীক্ষা |
s register ব্যবহার করে epilogue-এ ফিরিয়ে না দেওয়া, বা ra না রেখে call করা | ফেরার মুহূর্তে sp, s0–s11 মেলানো; একটি non-leaf function থেকে দুবার call |
| Struct বা ৮টির বেশি argument ভুল জায়গায় রাখা | দশটি argument-এর অঙ্ক-ক্রমের পরীক্ষা (1234567890), দুই দিক থেকে C-র সঙ্গে |
| বানানো flag বা ভুল version-এর আউটপুট দেখানো | নিজের যন্ত্রে সেই compiler version চালিয়ে --version লিখে রাখা |
AI-কে কাজে লাগাতে ABI আর যাচাইয়ের পথ আগেই বলে দিন:
AI-এর উত্তর হাতে পেলে — যাচাইয়ের চেকলিস্ট
ভাবনার প্রশ্ন
প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন, তারপর “→ উত্তর” চাপুন।
প্র ০১একই x86-64 CPU-তে Linux আর Windows দুটি আলাদা calling convention কেন মানে, আর এই বিভাজনের দাম কে দেয়?
AMD যখন ২০০০ সালের দিকে ৬৪-বিট x86 (AMD64) ঘোষণা করে, তখন নির্দেশমালা এক হলেও software-এর চুক্তি লেখার কাজ ছিল প্রতিটি operating system-এর। Unix-ধাঁচের জগতে GCC, Linux আর অন্য প্রকল্পের লোকেরা AMD-এর সঙ্গে মিলে System V AMD64 psABI লেখেন; Microsoft নিজের x64 চুক্তি বানায়, যা ২০০৫ সালের দিকে Windows-এর ৬৪-বিট সংস্করণের সঙ্গে আসে। দুই দলের অগ্রাধিকার আলাদা ছিল। System V বেশি register (ছয়টি) দিয়ে argument পাঠায় আর leaf function-এর জন্য red zone রাখে; লক্ষ্য ছোট function দ্রুত করা। Microsoft প্রতিটি argument-এর অবস্থান তার ক্রমিক নম্বরে বাঁধে আর shadow space রাখে; এতে varargs আর prototype-ছাড়া function-এর জন্য সব argument মেমরিতে পাশাপাশি পাওয়া সহজ, আর Windows-এর exception-এর stack হাঁটার জন্য prologue-এর ছাঁচ কড়া।
কোনোটিকে “ভুল” বলা যায় না; দুটিই নিজের লক্ষ্যে যুক্তিসংগত। কিন্তু দাম আছে। প্রথমত, যে কোড দুই platform-এর জন্য compile হয়, তার assembly অংশ দুবার লিখতে হয়; JIT compiler (পর্ব ৬১) আর FFI library-কে দুটি নিয়মই জানতে হয়। দ্বিতীয়ত, Wine-এর মতো প্রকল্পে, যেখানে Linux-এ Windows-এর program চলে, দুই চুক্তির সীমানায় সেতু লাগে; GCC আর Clang এজন্য __attribute__((ms_abi)) আর sysv_abi রাখে, যাতে একই ফাইলে দুই চুক্তির function লেখা যায়। তৃতীয়ত, শিক্ষার্থী আর AI দুজনেই নিয়ম মিশিয়ে ফেলে: অংশ ৫-এ দেখেছেন rsi একটিতে argument register, অন্যটিতে callee-saved.
ARM64-এ ইতিহাস আরেক রকম: ARM নিজেই AAPCS64 চুক্তি লিখেছে, আর বেশিরভাগ platform তা মানে, যদিও Apple-এর platform কিছু খুঁটিনাটিতে আলাদা (যেমন varargs-এর ব্যবহার)। RISC-V শুরু থেকেই একটি psABI-তে সবাইকে আনার চেষ্টা করেছে, আর এই পর্বের Haat সেটিই মানে। শিক্ষাটি ভাষা-নকশার জন্যও সত্য: একবার একটি চুক্তি ছড়িয়ে পড়লে সেটি বদলানো প্রায় অসম্ভব, কারণ পুরোনো binary-গুলো চিরকাল সেই চুক্তির ওপর নির্ভর করে থাকে।
মূল উপলব্ধি: ABI প্রযুক্তি যতটা, ততটাই সামাজিক চুক্তি; কে কখন লিখেছিল আর কী অগ্রাধিকার ছিল, তা দশকের পর দশক টিকে থাকে, আর প্রতিটি compiler, JIT আর FFI-কে সব চুক্তির দাম দিতে হয়।
প্র ০২ABI স্থির রাখার প্রতিশ্রুতি একটি ভাষাকে কী দেয় আর কী কেড়ে নেয়? C, C++, Swift আর Rust-এর পথ তুলনা করুন।
C-র ABI প্রায় প্রতিটি platform-এ কয়েক দশক ধরে স্থির, আর এটিই C-কে সব ভাষার “সাধারণ ভাষা” বানিয়েছে: Python, Java, Rust, Go সবাই অন্য ভাষার সঙ্গে কথা বলে C-র ABI দিয়ে। এর কারণ C-র ভাষাটি ছোট: struct, pointer, function. ABI-তে বাঁধার মতো জিনিস কম। C++-এ জিনিস অনেক বেশি: class-এর layout, virtual function table, exception, template থেকে তৈরি কোড, standard library-র ভেতরের গঠন। এর প্রতিটি ABI-র অংশ হয়ে যায়। GCC 5-এর সময় (২০১৫ সালের দিকে) C++11-এর নিয়ম মানতে std::string-এর ভেতরের গঠন বদলাতে হয়েছিল (copy-on-write বাদ), আর পুরোনো binary চালু রাখতে libstdc++ দুটি ABI পাশাপাশি রাখে; বহু বছর ধরে library-লেখকদের দুই রূপের কথা মাথায় রাখতে হয়েছে।
Swift ২০১৯ সালে Swift 5-এ Apple-এর platform-এ ABI স্থিরতা ঘোষণা করে, যাতে operating system-এর সঙ্গে Swift-এর runtime রাখা যায় আর প্রতিটি app-কে নিজের কপি না বইতে হয়। এর জন্য Swift নতুন কৌশল আনে, যেমন “library evolution”, যেখানে একটি struct-এর আকার compile-এর সময় না জেনেও ব্যবহার করা যায়; দামটি কিছু ক্ষেত্রে কম গতি আর বেশি জটিলতা। Rust উল্টো সিদ্ধান্ত নিয়েছে: নিজের ABI স্থির নয়, compiler চাইলে struct-এর field-এর ক্রম বদলাতে পারে, যাতে padding কমে (পর্ব ২৫)। বিনিময়ে Rust-এর library সাধারণত উৎস থেকে compile হয়, আর অন্য ভাষার সঙ্গে কথা বলতে extern "C" আর #[repr(C)] দিয়ে C-র ABI ধার করে।
অর্থাৎ ABI স্থিরতা দেয় shared library-র স্বাধীন আপডেট, ছোট app আর অন্য ভাষার সঙ্গে সহজ মিলন; কেড়ে নেয় optimizer আর ভাষা-নকশাকারের স্বাধীনতা। Haat-এর জন্য সিদ্ধান্তটি সহজ: Haat ABI v1 ইচ্ছা করে C-র psABI-র ভেতরে থাকে আর symbol-এ haat_ উপসর্গ দেয়, যাতে C-র সঙ্গে মিলন বিনা খরচে হয়; Haat-এর ভেতরের জিনিস (closure, string-এর গঠন) ABI-র বাইরে, পরে বদলানো যাবে।
মূল উপলব্ধি: যা ABI-তে ঢোকে তা আর বদলানো যায় না; তাই ভালো নকশা চুক্তিকে ছোট রাখে আর ভাষার নিজস্ব জটিলতা চুক্তির বাইরে রাখে।
প্র ০৩Frame pointer রাখবেন, না বাদ দেবেন? একটি register-এর দাম বনাম debugger আর profiler-এর সুবিধা।
Frame pointer (RISC-V-এ s0, x86-64-এ rbp) রাখলে প্রতিটি frame-এর একটি স্থির বিন্দু থাকে, আর সেখান থেকে ফেরার ঠিকানা আর আগের frame pointer পড়ে পুরো call-এর শিকল হাঁটা যায়: ছবি ৭১.১-এর লাল দুটি ঘর একটি linked list-এর node. Sampling profiler প্রতি সেকেন্ডে হাজার বার program থামিয়ে “এখন কোন function, কে তাকে ডেকেছে” জানতে চায়; frame pointer থাকলে উত্তরটি কয়েকটি মেমরি পড়ার ব্যাপার। না থাকলে profiler-কে .eh_frame-এর DWARF তথ্য পড়ে হিসাব করতে হয়, যা ধীর আর জটিল, অথবা stack-এর একটি বড় অংশ কপি করে পরে বিশ্লেষণ করতে হয়।
দাম হলো একটি register আর প্রতিটি function-এ কয়েকটি নির্দেশ। ৩২-বিট x86-এ মাত্র আটটি সাধারণ register ছিল, তাই একটি হারানো সত্যিই ভারী ছিল, আর -fomit-frame-pointer বহু বছর optimization-এর স্বাভাবিক অংশ হয়ে যায়। x86-64 আর RISC-V-এ register অনেক, তাই হিসাব বদলেছে। কয়েকটি Linux distribution সাম্প্রতিক বছরে পুরো system আবার frame pointer দিয়ে build করার সিদ্ধান্ত নিয়েছে (Fedora 38 আর Ubuntu 24.04 এমন উদাহরণ হিসেবে উল্লেখিত হয়); তাদের যুক্তি ছিল যে সারা system-এর profiling-এর লাভ সামান্য গতি-ক্ষতির চেয়ে বেশি। গতির ক্ষতি কত, তা program-ভেদে আলাদা; কোনো সাধারণ সংখ্যা এখানে দাবি করছি না।
RISC-V psABI-র নতুন frame pointer অংশ এই বিতর্ককে নিয়মে এনেছে: frame pointer থাকলে সেটি s0-তে আর CFA-তে, ফেরার ঠিকানা fp−8-এ, আগের fp fp−16-এ; কিন্তু platform বেছে নিতে পারে frame record বাধ্যতামূলক কি না, leaf function ছাড় পাবে কি না। পর্ব ৩০-এ দেখেছেন Clang -O2-তে leaf price-এর frame পুরোপুরি বাদ দেয়। Haat ABI v1 প্রতিটি function-এ frame record রাখে, কারণ এখনো গতির চেয়ে স্পষ্টতা আর যাচাই বড়; পরে অপ্রয়োজনীয় হলে বাদ দেওয়া সহজ, কারণ নিয়মটি একটি ফাইলে।
মূল উপলব্ধি: Frame pointer-এর প্রশ্ন আসলে “কাকে দ্রুত করব” প্রশ্ন: program-কে, না program বোঝার tool-কে; register যত সস্তা হয়, পাল্লা তত tool-এর দিকে ঝোঁকে।
প্র ০৪Haat ABI v1 সব মান stack slot-এ রাখে, Clang-এর -O0-এর মতো। এটি কি শুধু অলসতা, নাকি সচেতন নকশা? এর সীমা কোথায়?
Compiler তৈরির একটি পুরোনো পরামর্শ: আগে সঠিক, পরে দ্রুত। “প্রতিটি নামের একটি slot” নীতিতে প্রতিটি IR নির্দেশের অনুবাদ স্থানীয়: operand slot থেকে register-এ তোলা, হিসাব করা, ফল slot-এ নামানো। কোনো register কখনো একটি নির্দেশের বাইরে মান ধরে রাখে না, তাই call পেরিয়ে কিছু বাঁচাতে হয় না, আর caller-saved/callee-saved-এর পুরো হিসাব দুটি register-এ (ra, s0) নেমে আসে। এর মানে পর্ব ৭২-এর back end ভুল করার জায়গা কম, আর ভুল হলে তা একটি নির্দেশের অনুবাদে সীমিত। Clang-এর -O0 একই কারণে প্রায় এভাবে চলে, সঙ্গে আরেকটি লাভ: debugger প্রতিটি variable-এর একটি স্থির ঠিকানা পায়। অংশ ৪-এ দেখেছেন, দুটির layout প্রায় লাইনে লাইনে মেলে।
সীমাও স্পষ্ট, আর সংখ্যায় মাপা। প্রথমত গতি: প্রতিটি যোগে দুটি load আর একটি store, যেখানে register-এ একটি নির্দেশই যথেষ্ট। দ্বিতীয়ত frame-এর আকার: প্রতিটি temp-এর আলাদা slot, তাই এলোমেলো program-এর কোনো <main>-এ ১,৯৮৪ byte, ২,০৩২-এর সীমার খুব কাছে। সীমা পেরোলে addi-এর ১২ বিটের immediate আর যথেষ্ট নয়; তখন হয় li দিয়ে বড় ধ্রুবক বানিয়ে ঠিকানা হিসাব করতে হবে, নয়তো slot কমাতে হবে। Haat v1 সৎভাবে Unsupported তোলে, চুপচাপ ভুল কোড লেখে না।
দুই সমস্যারই সমাধান পর্ব ৭০-এর register allocation: liveness দেখে যে temp-গুলো একসাথে বাঁচে না, তারা একই register বা slot ভাগ করবে। তখন call পেরিয়ে বাঁচা মান s1–s11-এ যাবে, আর ঠিক এজন্য frame_layout-এ callee_saved parameter রাখা হয়েছে; lab-এ এই পথও emulator-এ পরীক্ষিত। গুরুত্বপূর্ণ হলো, layout-এর চুক্তি (frame record, alignment, argument-এর জায়গা) বদলাবে না; শুধু ভেতরের slot কমবে। ABI আর optimization আলাদা স্তরে থাকায় একটি বদলালে অন্যটি ভাঙে না।
মূল উপলব্ধি: সরল layout দিয়ে শুরু করে তাকে পরীক্ষা দিয়ে বেঁধে ফেলা, তারপর optimization যোগ করা: এটিই compiler-এ ঝুঁকি কমানোর পথ, আর ABI-কে optimization থেকে আলাদা রাখলে সেই পথ খোলা থাকে।
প্র ০৫Python-এর ctypes runtime-এ এমন একটি C function ডাকে, যার signature compile-এর সময় কেউ জানত না। এটি কীভাবে সম্ভব, আর এর ঝুঁকি কী?
সাধারণ C-তে call-এর কোড compile-এর সময় লেখা হয়: compiler prototype দেখে জানে কোন argument কোন register-এ। কিন্তু ctypes চলার সময় শুধু একটি ঠিকানা আর আপনার দেওয়া argtypes/restype পায়। তখন কাউকে অংশ ৫-এর মডেলের পূর্ণ রূপটি চালাতে হয়: প্রতিটি argument-এর type দেখে ঠিক করা কোনটি কোন register-এ বা stack-এর কোন offset-এ, তারপর সেভাবে register ভরে লাফ দেওয়া। CPython-এর ctypes এই কাজ libffi নামের library-কে দেয়, যার ভেতরে প্রতিটি platform-এর ABI-র জন্য অল্প কিছু হাতে লেখা assembly আর নিয়মের কোড আছে। Java-র নতুন Foreign Function & Memory API, অনেক JavaScript runtime-এর FFI আর বিভিন্ন ভাষার binding-generator-ও একই ধরনের কাজ করে, কেউ libffi দিয়ে, কেউ নিজের কোড দিয়ে।
ঝুঁকিটি গভীর। Compiler দুই পাশের type মেলাতে পারে না, কারণ এক পাশ চলার সময় তৈরি। argtypes না দিলে ctypes নিজে আন্দাজ করে, আর একটি Python int-কে C-র int ধরে নেয়; C function যদি long long চায়, ওপরের বিটগুলোর মান ABI আর platform-এর ওপর নির্ভর করে। ভুল সংখ্যার argument দিলে callee stack থেকে অন্য কিছু পড়ে। Windows-এ long ৪ byte আর Linux-এ ৮, তাই একটি platform-এ ঠিক চলা কোড আরেকটিতে ভুল ফল দেয়। এর কোনোটিতেই সাধারণত error আসে না; অংশ ৭-এর alignment-ভুলের মতো program হয়তো চলতেই থাকে।
প্রতিরক্ষা তাই একই: header থেকে signature যন্ত্রে তৈরি করা (হাতে না লিখে), প্রতিটি platform-এ পরীক্ষা চালানো, আর ক্রম-নির্ভর মান দিয়ে test (অংশ ৭-এর 1234567890). পর্ব ৭২-এ Haat-এর runtime-এর print_int ডাকার সময়ও একই প্রশ্ন: Haat-এর দিক থেকে argument a0-তে, C-র দিকে long long; দুই পাশের type এক রাখার দায় compiler-লেখকের।
মূল উপলব্ধি: FFI হলো ABI-কে runtime-এ চালানো; সেখানে type-checker নেই, তাই সঠিকতার একমাত্র পাহারা হলো সঠিক signature আর প্রতিটি platform-এ চালিয়ে দেখা।
অনুশীলন
প্রথমে নিজে হিসাব করুন বা লিখুন, তারপর উত্তর খুলুন। প্রতিটি উত্তর সত্যিকারের run দিয়ে যাচাই করা।
-
নকশা ও বাস্তবায়ন — callee-saved register-সহ frame: পর্ব ৭০-এর allocator ঠিক করেছে,
price-এ দুটি মানs1আরs2-এ থাকবে।frame_layout(fn, callee_saved=("s1", "s2"))কী layout দেবে? হাতে হিসাব করুন: frame-এর আকার,s1,s2আরqty-এর offset, আর prologue-epilogue. তারপর বলুন, কেনs1ফেরানো হয়ld s0-এর আগে।Frame record ১৬, দুটি saved register ১৬, আটটি IR নাম ৬৪: মোট ৯৬, যা ১৬-এর গুণিতক।
s1→-24(s0),s2→-32(s0), তারপরqty→-40(s0),unit→-48…t5→-96.haat_abi.py-র সত্যিকারের আউটপুট:haat_price: addi sp, sp, -96 sd ra, 88(sp) sd s0, 80(sp) addi s0, sp, 96 sd s1, -24(s0) sd s2, -32(s0) sd a0, -40(s0) # qty sd a1, -48(s0) # unit … ld s1, -24(s0) ld s2, -32(s0) ld ra, 88(sp) ld s0, 80(sp) addi sp, sp, 96 rets1আরs2-এর ঘরs0-সাপেক্ষ লেখা;ld s0-এর পরেs0caller-এর মান পায়, তখন-24(s0)অন্য জায়গা দেখাবে। তাই আগেs1,s2, শেষেs0. লেখকের lab-এ এই layout দিয়ে (body-তেs1= 77,s2= 88 লিখে) ৬০টি এলোমেলো program Unicorn-এ চালানো হয়েছে: ৬০টিই reference-এর সমান, আর ফেরার মুহূর্তে callee-saved register-এর কোনো অমিল নেই। -
ভুল খুঁজুন — হাতে লেখা একটি prologue: কেউ একটি non-leaf Haat function-এর জন্য লিখেছেন:
addi sp, sp, -40·sd ra, 32(sp)·sd s0, 24(sp)·addi s0, sp, 40· … ·ld ra, 32(sp)·addi sp, sp, 40·ret. psABI-র কোন দুটি নিয়ম ভাঙা হয়েছে? প্রতিটির ফল কী হতে পারে, আর কোনটি পরীক্ষায় সহজে ধরা পড়ে?ভুল ১ — alignment: ৪০ ১৬-এর গুণিতক নয়। এই function যখন কাউকে ডাকবে, callee-তে ঢোকার মুহূর্তে
sp১৬ byte-এ সাজানো থাকবে না। ভুল ২ — callee-saved ফেরানো হয়নি: prologues0রাখে, কিন্তু epilogueld s0, 24(sp)ভুলে গেছে; caller ফিরে পায় এই function-এরs0.লেখকের lab-এ দুটি ভুলই ইচ্ছা করে ঢুকিয়ে bazar.haat চালানো হয়েছে। Alignment-এর ভুলে আউটপুট তবুও ঠিক (
996,5000,3), কারণ Haat-এর কোড নিজে alignment-এর ওপর নির্ভর করে না; ভুলটি নিঃশব্দ, আর ধরা পড়েছে শুধু emulator-এর “sp misaligned” পরীক্ষায়। বাস্তবে এটি ফাটে যখন একটি C library function (যেমন ১৬ byte-এর SIMD store ব্যবহার করাmemcpy) সাজানো stack ধরে নেয়।s0-এর ভুলে সঙ্গে সঙ্গে ভুল ফল: প্রথম লাইন60, কারণmainভুল frame pointer দিয়ে নিজের slot পড়ে। শিক্ষা: সঠিক আউটপুট দেখে ABI-র সঠিকতা প্রমাণ হয় না; প্রতিটি call-এ নিয়মটি আলাদা করে পরীক্ষা করতে হয়। -
হিসাব — একটি Haat function-এর frame: নিচের program-এ
fee-এর Haat IR লিখুন, তারপর নিয়ম ৭১.১ দিয়ে প্রতিটি নামের slot আর frame-এর আকার বের করুন। Program কী ছাপবে?fn delivery(total: Int) -> Int { if total >= 1000 { return 0; } else { return 60; } }fn fee(total: Int, express: Bool) -> Int { if express { return delivery(total) + 120; } return delivery(total); }print(fee(500, true)); print(fee(1500, false));Haat IR (পর্ব ৬২-এর
compile_ir-এর আসল আউটপুট):fn fee(total, express): B0: branch express B1 B2 B1: t1 = call delivery(total) t2 = const 120 t3 = t1 + t2 return t3 B2: t4 = call delivery(total) return t4নাম, প্রথম লেখার ক্রমে:
total−24,express−32,t1−40,t2−48,t3−56,t4−64. আকার ১৬ + ৬ × ৮ = ৬৪, এমনিতেই ১৬-এর গুণিতক; কোনো call-এ ৮টির বেশি argument নেই, তাই out_args ০।expressএকটি Bool, কিন্তু slot একই ৮ byte, মান 0 বা 1.haat_abi.py-ও ঠিক এই layout দিয়েছে। আউটপুট:180(৫০০ টাকার অর্ডারে ডেলিভারি ৬০, এক্সপ্রেস ১২০) আর0. Reference-এরrunআর lab-এর Unicorn run দুটিই তাই ছেপেছে, ৬টি call-এর প্রতিটিতে ABI-পরীক্ষা পরিষ্কার। -
আউটপুট অনুমান — সাত argument, তিন ABI:
long long f7(long long a, …, long long g)-কেf7(1, 2, 3, 4, 5, 6, 7)দিয়ে ডাকা হলো। RISC-V, System V আর Windows x64-এ প্রতিটি argument কোথায়, ডাকের মুহূর্তেspথেকে? আরg3(1, s, 99), যেখানেsদুটিlong long-এর struct?f7: RISC-V-এ সাতটিই
a0–a6-এ, stack ছোঁয় না। System V-এ ছয়টিrdi rsi rdx rcx r8 r9-এ, ৭ম[rsp+0]-এ। Windows-এ চারটিrcx rdx r8 r9-এ, ৫, ৬, ৭ যথাক্রমে[rsp+32],[rsp+40],[rsp+48]-এ। g3: RISC-V-এa0= 1,s=a1+a2, 99 =a3; System V-এrdi= 1,s=rsi+rdx, 99 =rcx; Windows-এrcx= 1,rdx=s-এর কপির ঠিকানা, 99 =r8.সত্যিকারের Clang 22.1.8 (
-O2) হুবহু এভাবেই লিখেছে। System V-এ একটি বাড়তি খুঁটিনাটি: একটি মাত্র stack-argument-এর জন্যওsub rsp, 16, কারণ call-এর আগেrsp-কে ১৬-এর গুণিতকে রাখতে হবে। Windows-এsub rsp, 64: shadow space ৩২, তিনটি argument ২৪, আর alignment-এর জন্য বাকিটা। RISC-V আর System V-এg3-এর ডাকটি tail call হয়ে গেছে (tail g3,jmp g3@PLT), কারণ ডাকের পরে আর কোনো কাজ নেই; Windows-এর আউটপুটে কিন্তু সাধারণcall, কারণs-এর কপিটি caller-এর নিজের frame-এ, আর frame ছেড়ে দিলে সেই ঠিকানা আর বৈধ থাকত না।
নিজেকে যাচাই করুন
ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।
ক্রমHaat ABI v1-এ একটি function-এর শুরু থেকে শেষ পর্যন্ত নির্দেশগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)
addi sp, sp, -F— frame-এর জায়গা নেওয়াsd ra, F-8(sp)আরsd s0, F-16(sp)— frame recordaddi s0, sp, F— নতুন frame pointer = CFAsd a0, -24(s0)… — register-argument slot-এ- Body; ফল
a0-তে ld ra,ld s0,addi sp, sp, F,ret
RISC-V psABI (RV64)-তে একটি function ১০টি long long argument নেয়। ঢোকার মুহূর্তে ১০ম argument কোথায়?
a9- ঢোকার মুহূর্তে
8(sp) -8(sp)s1
RISC-V-এ একটি function call-এর আগে t0-তে একটি মান রেখেছে যা call-এর পরে লাগবে। কে দায়ী সেটি বাঁচানোর জন্য?
- Callee, কারণ সে register বদলায়
- Hardware, call নির্দেশ নিজেই
- Caller নিজে
- Operating system
Windows x64-এ struct item { long long qty; long long unit; } (১৬ byte) মান হিসেবে প্রথম argument-এ পাঠালে কী যায়?
- Caller-এর বানানো কপির ঠিকানা,
rcx-এ rcxআরrdx-এ দুই অর্ধেক- পুরো ১৬ byte stack-এর shadow space-এ
xmm0-এ
Haat ABI v1-এ একটি function-এর ৭টি IR নাম আছে (parameter, variable আর temp মিলে), কোনো call-এ ৮টির বেশি argument নেই, আর callee-saved register অনুরোধ করা হয়নি। Frame-এর আকার কত byte?
- 56
- 72
- 64
- 80
System V x86-64-এ একটি leaf function rsp না কমিয়েই [rbp - 8]-এ (যেখানে rbp = rsp) একটি local রাখে। এটি বৈধ কেন?
- Shadow space-এর কারণে
- Red zone-এর কারণে
- কারণ stack ওপরের দিকে বাড়ে
- কারণ frame pointer আছে
একটি C++ library-র নতুন version-এ উৎস-কোডের কোনো function-এর নাম বা parameter বদলায়নি, কিন্তু একটি public class-এ নতুন data member যোগ হয়েছে। পুরোনো version-এর বিরুদ্ধে compile করা program নতুন library-র সঙ্গে চালালে কী ঝুঁকি?
- কোনো ঝুঁকি নেই, কারণ API একই
- Link-এর সময় অবশ্যই error আসবে
- ABI ভেঙেছে: পুরোনো binary ভুল আকার আর offset ব্যবহার করবে
- Calling convention-এর register বদলে যাবে
RISC-V psABI-র frame pointer নিয়মে, prologue-এর পরে fp (= s0) কোথায় দেখায়, আর ফেরার ঠিকানা কোথায় থাকে (RV64)?
fp= ঢোকার মুহূর্তেরsp; ফেরার ঠিকানাfp − 8-এfp= নতুনsp; ফেরার ঠিকানাfp + 8-এfp= ফেরার ঠিকানার ঘর; আগের fpfp + 8-এfp=ra
শব্দকোষ
লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:
মনে রাখুন
- ABI = binary-র চুক্তি: data-র আকার, calling convention, frame, symbol-এর নাম; API একই রেখেও ABI ভাঙা যায়।
- RISC-V psABI: argument
a0–a7, ফলa0/a1, callee-saveds0–s11আরsp, ঢোকার মুহূর্তেsp১৬-এ সাজানো, ৯ম argument0(sp)-এ, red zone নেই। - x86-64-এর দুই চুক্তি: System V-এ ৬টি register আর red zone; Windows-এ ৪টি, shadow space, আর ৮ byte-এর বড় struct ঠিকানা হয়ে।
- Haat ABI v1:
s0= CFA,ras0−8, পুরোনোs0s0−16, তারপর প্রতিটি IR নামের slot; আকার ১৬-এর গুণিতক, সর্বোচ্চ ২,০৩২; symbolhaat_দিয়ে। - ABI-ভঙ্গ নিঃশব্দ: সঠিক আউটপুট প্রমাণ নয়; প্রতিটি call-এ alignment আর callee-saved register পরীক্ষা, আর অন্য compiler-এর কোডের সঙ্গে দুই দিকের ডাক।
আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ
- পর্ব ৭২ · Haat থেকে RISC-V assembly — একটি সম্পূর্ণ back endপরবর্তী পর্বএই frame দিয়ে পুরো code generator.
- প্রোগ্রামিং ভাষা ও কম্পাইলার · কোর্স হোম৮৬টি পর্বপুরো কোর্সের মানচিত্র আর Haat প্রজেক্টের পথ।
- পর্ব ৩০ · Subprogram-এর বাস্তবায়নএই কোর্সেActivation record আর call stack-এর ভিত্তি।
- Procedure আর stackপাশের ট্র্যাকHardware-এর চোখে jal, jalr আর register-এর নিয়ম।
- C আর assemblyপাশের ট্র্যাকx86-64-এ C-র frame, prologue আর stack-এর নিরাপত্তা।
- C থেকে assemblyপাশের ট্র্যাকতিন ISA-তে compiler-এর আউটপুট পড়া।