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

Calling convention আর ABI — function call-এর চুক্তি

Calling Conventions and the ABI — The Contract Behind Every Function Call

Taught in Bangla, this lesson explains the ABI as the machine-level contract between separately compiled code. It covers RISC-V psABI register roles and how scalars, structs and results are passed, designs Haat's RV64 frame layout with prologue, epilogue and call sequence, and steps through a call from main to price. Real Clang 22 compiles one C function for three targets to compare System V and Windows x64, and it covers red zones, silent ABI breaks, name mangling, varargs, ABI stability and FFI.

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

  • 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 conventionargument আর ফলের register, কে কোন register বাঁচাবে, stack-এর alignmentএই পর্ব
Frame-এর গঠন আর stack-এর ব্যবহারframe pointer কোথায়, red zone আছে কি না, shadow spaceএই পর্ব
Symbol-এর নামC-তে price, C++-এ _Z5pricexxঅংশ ৮
Object file আর linking-এর formatELF, 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):

  1. ৮ byte পর্যন্ত scalar: পরের খালি a register-এ, না থাকলে stack-এ। ছোট integer (যেমন int) আগে নিজের চিহ্ন অনুযায়ী ৩২ বিটে, তারপর ৬৪ বিটে sign extension হয়ে যায়; তাই RV64-এ একটি unsigned int-ও register-এ sign-extended থাকে।
  2. ১৬ byte পর্যন্ত struct (যেমন দুটি long long): দুটি register-এ; শুধু একটি খালি থাকলে প্রথম অর্ধেক সেই register-এ আর বাকি অর্ধেক stack-এ।
  3. এর বড় struct: caller একটি কপি বানায় আর তার ঠিকানা পাঠায় (pass by reference).
  4. ফল: যেভাবে একই 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-কে ডাকতে পারে।

নিয়ম ৭১.১ — Haat-এর RV64 frame (Haat ABI v1)
  1. Argument ক্রমে a0–a7-এ; ৯ম থেকে caller-এর frame-এর তলায়, ঢোকার মুহূর্তের sp থেকে 0, 8, 16 … byte ওপরে। ফল a0-তে; Bool = 0/1, Unit = 0.
  2. Prologue-এর পরে s0 = ঢোকার মুহূর্তের sp (canonical frame address, CFA). ra থাকে s0−8-এ, caller-এর s0 থাকে s0−16-এ: psABI-র frame pointer অংশের frame record.
  3. অনুরোধ করা callee-saved register (s1…) তার ঠিক নিচে, তারপর প্রতিটি IR নামের (parameter, Haat variable, temp) একটি ৮ byte-এর stack slot, প্রথম লেখার ক্রমে: s0−24, s0−32 …। ৯ম আর পরের parameter-এর slot নেই: সেগুলো s0+0, s0+8 …-এ caller-এর রেখে যাওয়া ঘরেই।
  4. Frame-এর তলায়, sp+0 থেকে, এই function-এর কোনো call-এ ৮টির বেশি argument থাকলে সেগুলোর জায়গা (out_args). Body চলার সময় sp আর নড়ে না।
  5. মোট আকার ১৬-এর গুণিতকে বাড়ানো; ২,০৩২ byte-এর বেশি হলে Unsupported, যাতে addi আর sd-এর ১২ বিটের immediate-এ সব offset ধরে।
  6. 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

Haat-এর price-এর stack frame main-এর frame s0 = CFA = 0x7FEFFF60 ra = 0x10011DC s0 = 0x7FF00000 qty = 2 unit = 520 p = 1040 t1 = 1000 t2 = 1 (true) t3 = 10 t4 = 104 t5 = 936 −8−16−24−32−40−48−56−64−72−80 +72+64+56+48+40+32+24+16+8+0 sp = s0 − 80 = 0x7FEFFF10 বড় ঠিকানা লাল: frame record · নীল: parameter সবুজ: variable আর temp
ছবি ৭১.১ — 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
Register আর মেমরি
sp
s0
ra
a0 · a1
মেমরি
  1. Argument register-এ। main-এর slot থেকে t1 = 2 আর t2 = 520 উঠল a0 আর a1-এ। sp = 0x7FEFFF60, যা ১৬-এর গুণিতক (শেষ hex অঙ্ক 0), আর এটিই price-এর CFA হবে। ra-তে এখনো main-এর নিজের ফেরার ঠিকানা।
  2. Call. call একটি pseudo-instruction (auipc + jalr): পরের নির্দেশের ঠিকানা 0x10011DC গেল ra-তে, লাফ haat_price-এ। main-এর ra মুছে গেল; সেটি main নিজের prologue-এ আগেই stack-এ রেখেছিল।
  3. জায়গা নেওয়া। addi sp, sp, -80: sp = 0x7FEFFF10. ৮০ ১৬-এর গুণিতক, তাই price কাউকে ডাকলে সেই ডাকেও sp সাজানো থাকত।
  4. Frame record. ra গেল sp+72 = 0x7FEFFF58-এ, main-এর s0 গেল sp+64 = 0x7FEFFF50-এ। s0 callee-saved, তাই price সেটি বদলানোর আগে রাখতে বাধ্য।
  5. নতুন frame pointer. s0 = sp + 80 = 0x7FEFFF60 = CFA. এখন ra ঠিক s0−8-এ আর পুরোনো s0 s0−16-এ, psABI-র frame pointer নিয়মের হুবহু।
  6. Parameter slot-এ। qty = 2 গেল s0−24 = 0x7FEFFF48-এ, unit = 520 গেল 0x7FEFFF40-এ। এখন থেকে body শুধু slot পড়ে আর লেখে, a0/a1 ছুঁয়ে দেখে না।
  7. Body আর ফল। p = 1040, তুলনা সত্য, t4 = 104, t5 = 936 গেল s0−80 = 0x7FEFFF10-এ (ঠিক sp+0). ld a0, -80(s0): ফল এখন a0-তে, চুক্তির ফেরত-register-এ।
  8. Epilogue. উল্টো ক্রমে: ra = 0x10011DC, s0 = 0x7FF00000 (main-এর), sp = 0x7FEFFF60; ret লাফ দিল ra-তে। Callee-saved sp আর s0 ঠিক আগের মানে, যা Unicorn-এর পরীক্ষাও মিলিয়ে দেখেছে।
  9. 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
  1. Callee-saved রাখা আর alignment. order-এ ঢোকার মুহূর্তে দুই ABI-তেই rsp ১৬-এর গুণিতক থেকে ৮ বেশি, কারণ call ৮ byte-এর ফেরার ঠিকানা ঠেলে দিয়েছে। System V তিনটি push করে (৮ + ২৪ = ৩২), Windows দুটি push আর ৮৮ (৮ + ১৬ + ৮৮ = ১১২): দুটিতেই আবার ১৬-এর গুণিতক।
  2. Struct. System V-এ it-এর দুই অর্ধেক rdi আর rsi-এ এসেছিল, call-এর আগে callee-saved r14 আর rbx-এ সরানো হলো। Windows-এ rcx-এ এসেছে caller-এর বানানো কপির ঠিকানা; সেটিকে callee-saved rsi-তে রাখা হলো।
  3. Register argument. System V-এ প্রথম ছয়টি: rdi rsi rdx rcx r8 r9. Windows-এ প্রথম চারটি: rcx rdx r8 r9. ছোট ধ্রুবকের জন্য compiler ৩২ বিটের নাম (edi) লেখে; x86-64-এ ৩২ বিটের লেখা ওপরের ৩২ বিট শূন্য করে দেয়।
  4. Stack argument. System V ডান থেকে বাঁয়ে push করে, তাই ডাকের মুহূর্তে [rsp+0] = 7. Windows আগেই জায়গা নিয়ে রেখেছে; [rsp+0] থেকে [rsp+31] খালি shadow space, আর ৫ থেকে ১০ তার ওপরে।
  5. Callee-র চোখে। call আবার ৮ byte (ফেরার ঠিকানা) ঠেলে দেয়, তাই sum10-এর কাছে সব ৮ ওপরে: System V-এ ৭ম argument [rsp+8]-এ, Windows-এ ৫ম [rsp+40]-এ। Windows-এর sum10 চাইলে rcx … r9 shadow space-এ নামিয়ে রাখতে পারে, যেন সব argument মেমরিতে পাশাপাশি; varargs function-এর জন্য এটি খুব সুবিধার।
  6. পরিষ্কার করা। 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
Register
a0
a1
s1 · s2
stack-এ
  1. Callee হিসেবে নিজের দায়। order নিজে একটি callee: সে s1 আর s2 ব্যবহার করবে, তাই caller-এর মান দুটি আগে stack-এ রাখল; call করবে, তাই ra-ও। a0 = 2 আর a1 = 520 হলো struct-এর দুই অর্ধেক।
  2. নিরাপদ ঘরে সরানো। a0/a1 এখনই নতুন argument-এ ভরবে, আর call-এর পরে তো কোনো নিশ্চয়তাই নেই। তাই qty আর unit গেল s1, s2-এ।
  3. নতুন argument. a0 … a7 = 1 … 8, আর ৯, ১০ stack-এর তলায় (0(sp), 8(sp)), প্রথম stack-argument offset শূন্যে, psABI অনুযায়ী।
  4. Call-এর পরে। a0 = 55, sum10-এর ফল। a1-এ কী আছে, চুক্তি কিছুই বলে না (তাই “অজানা”)। কিন্তু s1 = 2 আর s2 = 520 অক্ষত: sum10 সেগুলো ছুঁলে আগে রাখত আর ফিরিয়ে দিত।
  5. গুণ। a1 = 2 × 520 = 1040. Call-এর পরে a1-কে নির্ভয়ে নতুন কাজে লাগানো যায়, কারণ এটি caller-saved.
  6. ফল। a0 = 55 + 1040 = 1095, যা Unicorn-এর run-এ print_int সত্যিই ছেপেছে।
  7. দায় ফেরত। ra, s0, s1, s2 stack থেকে আগের মানে ফিরল, 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) তিন স্তরের পরীক্ষা চালানো হয়েছে:

  1. Differential test: lab-এর পরীক্ষা-generator এই পর্বের frame দিয়ে Haat IR থেকে RV64 কোড লিখেছে, Clang 22.1.8 (-target riscv64-linux-musl) assemble আর link করেছে, আর PyPI-র unicorn 2.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 চালানোর কিছু নেই)।
  2. প্রতিটি 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-এও একই ফল।
  3. অন্য 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 আর যাচাইয়ের পথ আগেই বলে দিন:

আমি একটি ছোট শিক্ষামূলক ভাষার (Haat) RISC-V RV64 back end লিখছি, Linux-এর RISC-V psABI মেনে (lp64). ১. নিচের Python ফাংশনের জন্য একটি frame layout দাও: ra আর পুরোনো s0 frame pointer-এর ঠিক নিচে, প্রতিটি local-এর ৮ byte-এর slot, মোট আকার ১৬-এর গুণিতক। প্রতিটি নিয়ম psABI-র কোন অংশ থেকে, তা বলো; নিশ্চিত না হলে অনুমান কোরো না। ২. আটটির বেশি argument হলে caller কোথায় রাখবে আর callee কোথায় পাবে, offset-সহ দেখাও। ৩. আমার prologue/epilogue যাচাইয়ের জন্য একটি পরীক্ষা লেখো: emulator-এ প্রতিটি call-এ sp % 16 == 0 আর ফেরার সময় sp ও s0–s11 অপরিবর্তিত কি না। ৪. Windows x64 বা System V-এর নিয়ম মেশাবে না; অন্য platform-এর কথা বললে আলাদা করে নাম বলো।

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 দিয়ে যাচাই করা।

  1. নকশা ও বাস্তবায়ন — 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
      ret

    s1 আর s2-এর ঘর s0-সাপেক্ষ লেখা; ld s0-এর পরে s0 caller-এর মান পায়, তখন -24(s0) অন্য জায়গা দেখাবে। তাই আগে s1, s2, শেষে s0. লেখকের lab-এ এই layout দিয়ে (body-তে s1 = 77, s2 = 88 লিখে) ৬০টি এলোমেলো program Unicorn-এ চালানো হয়েছে: ৬০টিই reference-এর সমান, আর ফেরার মুহূর্তে callee-saved register-এর কোনো অমিল নেই।

  2. ভুল খুঁজুন — হাতে লেখা একটি 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 ফেরানো হয়নি: prologue s0 রাখে, কিন্তু epilogue ld 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-এ নিয়মটি আলাদা করে পরীক্ষা করতে হয়।

  3. হিসাব — একটি 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-পরীক্ষা পরিষ্কার।

  4. আউটপুট অনুমান — সাত 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-এর শুরু থেকে শেষ পর্যন্ত নির্দেশগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. addi sp, sp, -F — frame-এর জায়গা নেওয়া
  2. sd ra, F-8(sp) আর sd s0, F-16(sp) — frame record
  3. addi s0, sp, F — নতুন frame pointer = CFA
  4. sd a0, -24(s0) … — register-argument slot-এ
  5. Body; ফল a0-তে
  6. 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 = ফেরার ঠিকানার ঘর; আগের fp fp + 8-এ
  • fp = ra

শব্দকোষ

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

মনে রাখুন

  1. ABI = binary-র চুক্তি: data-র আকার, calling convention, frame, symbol-এর নাম; API একই রেখেও ABI ভাঙা যায়।
  2. RISC-V psABI: argument a0–a7, ফল a0/a1, callee-saved s0–s11 আর sp, ঢোকার মুহূর্তে sp ১৬-এ সাজানো, ৯ম argument 0(sp)-এ, red zone নেই।
  3. x86-64-এর দুই চুক্তি: System V-এ ৬টি register আর red zone; Windows-এ ৪টি, shadow space, আর ৮ byte-এর বড় struct ঠিকানা হয়ে।
  4. Haat ABI v1: s0 = CFA, ra s0−8, পুরোনো s0 s0−16, তারপর প্রতিটি IR নামের slot; আকার ১৬-এর গুণিতক, সর্বোচ্চ ২,০৩২; symbol haat_ দিয়ে।
  5. ABI-ভঙ্গ নিঃশব্দ: সঠিক আউটপুট প্রমাণ নয়; প্রতিটি call-এ alignment আর callee-saved register পরীক্ষা, আর অন্য compiler-এর কোডের সঙ্গে দুই দিকের ডাক।

পরের পর্বে: পর্ব ৭২ (Haat থেকে RISC-V assembly — একটি সম্পূর্ণ back end). এই পর্বের frame_layout, prologue, epilogue আর call_seq দিয়ে Haat IR-এর প্রতিটি নির্দেশ RV64 assembly-তে, শূন্য দিয়ে ভাগের পরীক্ষা আর print-এর runtime-সহ; তারপর সত্যিকারের Clang-এ assemble করে চালিয়ে reference-এর সঙ্গে মেলানো।

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

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