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

Linking আর loading — object file, symbol আর relocation

Linking and Loading — Object Files, Symbols and Relocations

Taught in Bangla, this lesson opens ELF object files to read sections, symbols and relocations, and computes x86-64 PC-relative and RISC-V hi20/lo12 relocations by hand, matching the bytes of a really linked file. It builds a mini linker for symbol resolution and archives, explains shared libraries, PIC, GOT and PLT, follows a program from execve through _start to main, compares Windows PE/COFF, and shows link-time optimization inlining across files in a real Clang run.

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

  • ELF object file-এর section, symbol (global, local, weak, undefined) আর relocation entry পড়া, নিজের লেখা ছোট reader দিয়ে
  • Relocation-এর সূত্র, RISC-V-এর CALL_PLT, HI20, LO12 আর x86-64-এর PC32, PLT32 হাতে হিসাব করা, আর linked file দিয়ে মেলানো
  • Static linker-এর algorithm: section জোড়া, symbol resolution, archive থেকে member টানা, weak আর multiple definition
  • Shared library-র জন্য compiler কী আলাদা লেখে: PIC, GOT, PLT, copy relocation; আর BIND_NOW বনাম lazy binding
  • Loader আর program-এর শুরু (execve → _start → main), PE/COFF-এর সংক্ষিপ্ত তুলনা, আর LTO

১ · Linker কেন লাগে — আলাদা compile, একসঙ্গে চলা

বাজারঘরের একটি বড় অর্ডারের কথা ভাবুন। চাল আসে এক গুদাম থেকে, তেল আরেক গুদাম থেকে, মসলা তৃতীয় গুদাম থেকে। প্রতিটি গুদাম নিজের পার্সেল বাঁধে, কিন্তু কোন ভ্যানে কোন তাকে বসবে তা জানে না। তাই পার্সেলের গায়ে একটি চিরকুট লাগায়: “এখানে ডেলিভারি নম্বর বসবে”. শেষে বিতরণ কেন্দ্রের কর্মী সব পার্সেল এক ভ্যানে সাজান, প্রত্যেকের জায়গা ঠিক করেন, আর চিরকুট দেখে দেখে নম্বর লেখেন। Compiler-এর জগতে গুদাম হলো প্রতিটি source ফাইলের compile, পার্সেল হলো object file, চিরকুট হলো relocation, আর বিতরণ কেন্দ্রের কর্মী হলো linker.

কেন এমন ভাগ? বড় program-এ হাজার হাজার ফাইল। একটি ফাইল বদলালে সব আবার compile করা অপচয়, তাই প্রতিটি ফাইল আলাদা compile হয়: separate compilation. কিন্তু আলাদা compile মানে compiler main.c দেখার সময় জানে না price কোথায় থাকবে, এমনকি সেটি আদৌ আছে কি না। পর্ব ০৫-এ compiler-এর ধাপগুলোর শেষে assembler, linker আর loader-এর নাম দেখেছিলেন, আর C-তে চার ধাপের কারখানা দেখেছেন C প্রোগ্রামিং কোর্সের পর্ব ০৩-এ। Operating system-এর দিক থেকে compile → link → load, PLT/GOT আর ASLR-এর গল্প আছে Operating Systems কোর্সের পর্ব ৩০-এ। এই পর্ব compiler লেখকের চোখে দেখে: object file-এ ঠিক কোন bytes থাকে, linker কোন সূত্রে সেগুলো বদলায়, আর একটি ভাষার back end (Haat-এর পর্ব ৭২) linker-এর কাছ থেকে কী আশা করে।

সংজ্ঞা ৭৪.১ — linker-এর তিন প্রশ্ন

একটি static linker কয়েকটি object file আর library নিয়ে একটি executable বানাতে তিনটি প্রশ্নের উত্তর দেয়। (১) কে? প্রতিটি undefined নামের সংজ্ঞা কোন ফাইলে (symbol resolution). (২) কোথায়? প্রতিটি section চূড়ান্ত executable-এ কোন ঠিকানায় বসবে (layout). (৩) কী লিখব? প্রতিটি relocation entry-তে কোন সংখ্যা কোন bit-এ বসবে (relocation). Loader পরে চতুর্থ প্রশ্নের উত্তর দেয়: কীভাবে চালাব? ফাইলের কোন অংশ মেমরির কোথায়, আর প্রথম নির্দেশ কোনটি।

এই পর্বের উদাহরণ বাজারঘরের চেনা হিসাব: bazar.haat-এর দুই function price আর delivery C-তে shop.c ফাইলে, আর top-level অংশ main.c-তে। Haat-এর reference implementation-এর কোনো native back end নেই (সেটি stack bytecode-এ থামে), তাই এখানে C ফাইল ব্যবহার করা হয়েছে; Haat-এর জন্য এর মানে কী, তা অংশ ৭-এ। দুটি ফাইল:

// shop.c — bazar.haat-এর দুই function, C-তে
long step = 1250;                   // .data, global

long price(long qty, long unit) {
    long p = qty * unit;
    if (p >= 1000) return p - p / 10;
    return p;
}

long delivery(long total) {
    if (total >= 1000) return 0; else return 60;
}
// main.c — bazar.haat-এর top-level অংশ, C-তে
#include <stdio.h>
long price(long qty, long unit);    // shop.c-তে সংজ্ঞা
long delivery(long total);          // shop.c-তে সংজ্ঞা
extern long step;                   // shop.c-তে সংজ্ঞা
static long rounds;                 // শুধু এই ফাইলের, .bss

int main(void) {
    long first = price(2, 520) + delivery(price(2, 520));
    printf("%ld\n", first);
    long total = 0;
    while (total < 5000) { total = total + step; rounds = rounds + 1; }
    printf("%ld\n", total);
    printf("%ld\n", rounds - 1);
    return 0;
}

লেখকের lab-এ PyPI-র ziglang 0.17.1-এর ভেতরের Clang 22.1.8 (MIT লাইসেন্স) দিয়ে প্রতিটি ফাইল আলাদা compile হয়েছে, RISC-V (riscv64-linux-musl) আর x86-64 (x86_64-linux-musl, x86_64-linux-gnu) দুই target-এ, -O1 -g0 -fno-sanitize=undefined -c দিয়ে। Object আর executable পড়া হয়েছে PyPI-র pyelftools 0.33 দিয়ে (public domain), যা ELF ফাইল পড়ার একটি pure Python library. Linux executable এই Windows যন্ত্রে চলে না, তাই চালানোর প্রমাণ এসেছে দুই জায়গা থেকে: একই দুই ফাইল Windows target-এ link করে চালানো (অংশ ৭), আর Wandbox-এর Linux-এ GCC 13.3 দিয়ে (অংশ ৪)। সব জায়গায় আউটপুট reference-এর haat.py run bazar.haat-এর মতো: 996, 5000, 3.

২ · Object file-এর ভেতরে — section, symbol আর relocation-এর তালিকা

Linux-এ object file, executable আর shared library তিনটিই একই ফাইল-ফরম্যাটে: ELF (Executable and Linkable Format). ফাইলের শুরুতে ৬৪ byte-এর একটি header (64-bit ফাইলে), যার প্রথম চার byte 0x7f 'E' 'L' 'F'; সেখানে লেখা ফাইলটি কোন ধরনের (relocatable object, executable, shared object), কোন যন্ত্রের, আর section-এর তালিকা ফাইলের কোথায়। Object file ভাগ হয় section-এ। প্রতিটি section একটি নামওয়ালা টুকরো, একই ধরনের জিনিসের:

Sectionভেতরে কীmain.o-তে (RISC-V)
.textmachine code (text)158 bytes: পুরো main
.dataশুরুর মানসহ global/static (data)নেই; shop.o-তে 8 bytes: step
.bssশূন্য-শুরুর global/static; ফাইলে জায়গা নেয় না (bss)8 bytes: rounds
.rodata…শুধু-পড়ার ধ্রুবক, string.rodata.str1.1, 5 bytes: "%ld\n"
.symtab, .strtabsymbol-এর তালিকা আর তাদের নামনিচের reader-এ
.rela.text.text-এর relocation entry17টি

একটি symbol হলো একটি নাম আর তার তথ্য: কোন section-এ, কত offset-এ, কত বড়, আর তার binding. Binding তিন রকম। Global: সব ফাইল দেখতে পায় (main, price, step; C-তে external linkage). Local: শুধু এই ফাইলের (static long rounds; linker নাম মেলাতে এটি ব্যবহার করে না)। Weak: “একটি সংজ্ঞা আছে, কিন্তু অন্য কোথাও strong সংজ্ঞা থাকলে সেটিই জিতবে” (weak symbol, অংশ ৪)। আর যে নামের section নম্বর UNDEF, সেটি undefined: “আমার দরকার, অন্য কারও কাছে আছে”. Module আর namespace-এর ভাষা-স্তরের গল্প পর্ব ১৮-এ; object file-এর স্তরে সব শেষে এই সমতল নামের তালিকা।

নিজে দেখুন। নিচের ব্লকে লেখকের lab-এর সত্যিকারের main.o (RISC-V, Clang 22; ছোট রাখতে unwind table আর .comment ছাড়া compile করা, .text আর relocation হুবহু একই) zlib দিয়ে চেপে base64-এ রাখা আছে। কোড কোনো library ছাড়া, শুধু struct দিয়ে ELF header, section header, symbol table আর relocation পড়ে:

# সত্যিকারের main.o (Clang 22, RISC-V): ELF-এর header, section, symbol আর relocation নিজে পড়া
import base64, zlib, struct
OBJ = """
eNqtlM1rE0EUwN8k2ZjUr2gR/CiosUYQujRB0yIosRAVCdKDXgSJk92NXc0mYXcSUi+u2hbvoejJgzc9KtL/wYM3r1JawR68iGe1O7uz3ckk
Yy8+MvPe/Hbem/eGN3lSrlyLIQShIPgF0SqSjBJoqkq+VYIxSAE6lPyR3cp9u7kOmXS5r7inXnrfvrsA75YG16H+oKzCjBdmXFF22NMyJWtJ
gHhRgfjHJCzX+ysrs+9XFWXz85c/M2mAM9NvYS0B0F9KQG459Hx+MQ2/j0RrVN64P6e/0WOmgp+5Zxv6WJD3YVbHuDf2cXVlJfw8x/dzvMj0
cW/EOX6J6RMCv8LFOcDxG1ycgxyvcDzB8XkuPr//Nsf5/XVJnIdMTwi8KanLltTVk9TlSvJ5Idl/9QE9xHS0LqB71Cej2N3iBbPQzletQnu6
iqlVL7QLVZ1OGmWPTc2xfcOyOo08NTC2WoHRsB3NtzQcKN1TIBPk5/nzr8hTO18HZa9Po5tgz8LvL8RVnGL6mD/Hh+JM+HNiiJ/05+F8gigI
RvOEhA+fm/VzjeK8ZvocfeMjYkxJeFHCL0s4qMToEVBto4FDs6VjglWH2Hk1D2rNcTxGO0HFhNhmrUMMjzRbxFCv37oz5RCsPQLVWbQIrnl6
wXMMrECDhc2mqsFkD9QKhWC3Ok3dgUmd/egGaNumZoBuNMyuYS/SZZPUwSFGG/6HIDaSAi8J9x1KTFjvYV1REvgW069QtA9xfXZ0oA8BCoL/
V6Ff+Xx5fZrFFDtnU+hrkKxzge/QZbqs0AXJ+aHMjnx1Xv0x+X2D8L8a+4e/yxzS7C2L9zc/8rV6ebMnVtvl/LsS/0/Mf24X/22+DJ/n
"""
b = zlib.decompress(base64.b64decode(OBJ))
assert b[:4] == bytes([0x7f]) + b"ELF"             # magic: 0x7f, তারপর E L F
typ, mach = struct.unpack_from("<HH", b, 16); shoff, = struct.unpack_from("<Q", b, 40)
shnum, shstr = struct.unpack_from("<HH", b, 60)       # section-এর সংখ্যা, নামের section
print(f"{len(b)} bytes · e_type={typ} (1 = relocatable) · e_machine={mach} (243 = RISC-V)")
sh = [struct.unpack_from("<IIQQQQIIQQ", b, shoff + 64 * i) for i in range(shnum)]
cstr = lambda off: b[off:b.index(0, off)].decode()
nm = [cstr(sh[shstr][4] + s[0]) for s in sh]          # প্রতিটি section-এর নাম
for i, s in enumerate(sh[1:], 1):
    if s[1] in (1, 2, 4, 8) and s[5]: print(f"  [{i}] {nm[i]:15} size {s[5]}")
st = nm.index(".symtab"); strt = sh[sh[st][6]][4]
syms = [struct.unpack_from("<IBBHQQ", b, sh[st][4] + 24 * k) for k in range(sh[st][5] // 24)]
sname = lambda k: cstr(strt + syms[k][0]) if syms[k][0] else nm[syms[k][3]]  # নাম না থাকলে section-এর নাম
print("symbol:"); RT = {19: "CALL_PLT", 26: "HI20", 27: "LO12_I", 28: "LO12_S"}
for k, (n, info, _, shndx, val, size) in enumerate(syms):
    if info >> 4 == 1:                                 # শুধু GLOBAL
        print(f"  {sname(k):9}", "UNDEF" if shndx == 0 else f"{nm[shndx]}+{val} ({size} bytes)")
rs = nm.index(".rela.text"); print("relocation (প্রথম ৮টি):")
for k in range(8):
    off, info, add = struct.unpack_from("<QQq", b, sh[rs][4] + 24 * k)
    print(f"  .text+{off:#04x}  R_RISCV_{RT[info & 0xffffffff]:9} {sname(info >> 32)}{add:+d}")

আসল আউটপুট (browser-এর CPython, Pyodide):

1936 bytes · e_type=1 (1 = relocatable) · e_machine=243 (243 = RISC-V)
  [1] .text           size 158
  [2] .rela.text      size 408
  [3] .rodata.str1.1  size 5
  [4] .bss            size 8
  [7] .symtab         size 384
symbol:
  main      .text+0 (158 bytes)
  price     UNDEF
  delivery  UNDEF
  printf    UNDEF
  step      UNDEF
relocation (প্রথম ৮টি):
  .text+0x12  R_RISCV_CALL_PLT  price+0
  .text+0x22  R_RISCV_CALL_PLT  price+0
  .text+0x2a  R_RISCV_CALL_PLT  delivery+0
  .text+0x36  R_RISCV_HI20      .L.str+0
  .text+0x3a  R_RISCV_LO12_I    .L.str+0
  .text+0x3e  R_RISCV_CALL_PLT  printf+0
  .text+0x48  R_RISCV_HI20      step+0
  .text+0x4c  R_RISCV_HI20      rounds+0

e_type=1 মানে relocatable: চালানো যায় না, link-এর জন্য তৈরি। main সংজ্ঞায়িত (.text-এর শুরুতে, 158 bytes); price, delivery, step আর printf UNDEF. rounds তালিকায় নেই, কারণ কোড শুধু GLOBAL ছাপে; সেটি LOCAL. Relocation-এর তালিকায় প্রতিটি লাইন একটি চিরকুট: “.text-এর 0x12 byte-এ price-এর জন্য CALL_PLT ধরনের ঠিকানা বসাতে হবে”. .L.str নামের local symbol হলো "%ld\n" string-এর লেবেল; নামটি Clang নিজে বানায়। Section-এর আকার pyelftools-এর পড়ার সঙ্গে মেলে (.text 158, .rela.text 408 = 17 × 24).

Relocation entry-র গঠন ছোট: relocation entry = (offset, type, symbol, addend). ELF64-এ প্রতিটি 24 bytes: r_offset (৮ byte), r_info (৮ byte, ওপরের ৩২ bit-এ symbol-এর নম্বর, নিচের ৩২ bit-এ type), আর r_addend (৮ byte, চিহ্নসহ)। Type বলে কোন সূত্রে হিসাব হবে আর ফল instruction-এর কোন bit-এ বসবে; এটি প্রতিটি যন্ত্রের নিজস্ব। RISC-V-এর সংখ্যাগুলো (19 = R_RISCV_CALL_PLT, 26 = HI20, 27 = LO12_I, 28 = LO12_S) RISC-V psABI দলিলের তালিকা থেকে; pyelftools 0.33 এগুলোর নাম চেনে না, তাই কোডে নিজের ছোট তালিকা।

ছবি ৭৪.১ — দুটি object file থেকে একটি executable

ওপরে object file-এর section (ফাইলের ভেতরের ভাগ), নিচে executable-এর segment (মেমরিতে বসানোর ভাগ); ঠিকানা সত্যিকারের bazar.rv থেকে

Two object files and the C startup and library combined by the linker into the executable bazar.rv with three loadable segments main.o .text 158 · .bss 8 .rela.text: 17 entry U price delivery step… shop.o .text 78 · .data 8 price · delivery · step crt1.o + libc (.a) linker: মেলানো, বসানো bazar.rv (ET_EXEC) R 0x1000000 .rodata · .eh_frame R X 0x1002ba8 .text _start 0x1002ba8 main 0x1002c00 price 0x1002c9e delivery 0x1002cd0 … R W 0x1008d88 step 0x1008d88 .data rounds 0x1008e88 .bss
ছবি ৭৪.১ — Linker একই ধরনের section পাশাপাশি বসায়: সব .text এক জায়গায়, সব .data আরেক জায়গায়। main-এর ঠিক পরে price (0x1002c00 + 158 = 0x1002c9e), কারণ command line-এ main.o আগে আর shop.o পরে। তারপর কাছাকাছি অনুমতির section মিলে একটি segment (PT_LOAD): loader section দেখে না, segment দেখে।

৩ · Relocation — ফাঁকা ঠিকানা পূরণের হিসাব

Relocation মানে: ঠিকানা জানা গেলে কোডের ভেতরের সংখ্যাগুলো ঠিক করে লেখা। সব সূত্র তিনটি অক্ষর দিয়ে লেখা হয়, যেগুলো ELF আর psABI দলিলের নিজস্ব চিহ্ন: S = symbol-এর চূড়ান্ত ঠিকানা, A = addend (entry-তে লেখা একটি বাড়তি সংখ্যা), P = যে জায়গায় লেখা হচ্ছে, তার নিজের ঠিকানা। পরম ঠিকানা লাগলে S + A; নির্দেশ থেকে দূরত্ব লাগলে (PC-relative) S + A − P.

x86-64: চার byte-এর দূরত্ব

x86-64-এ call নির্দেশ হলো e8 আর তার পরে চার byte-এর চিহ্নসহ দূরত্ব (rel32), যা মাপা হয় পরের নির্দেশ থেকে। main.o-তে (x86-64 musl) price-এর প্রথম call-এর bytes e8 00 00 00 00, আর relocation R_X86_64_PLT32 price − 4 at offset 0x11. Addend −4 কেন? P হলো চার byte-এর ক্ষেত্রটির শুরু (0x11), কিন্তু CPU দূরত্ব মাপে ক্ষেত্রের শেষ থেকে (P + 4). তাই S − (P + 4) = S + (−4) − P. Link-এর পরে main = 0x10027c0, তাই P = 0x10027d1; price = 0x1002900. ফল 0x1002900 − 4 − 0x10027d1 = 299, আর linked file-এ সত্যিই e8 2b 01 00 00 (0x12b = 299). Static link-এ PLT32-ও সরাসরি function-এ যায়; PLT লাগে শুধু তখন, যখন লক্ষ্য একটি shared library-তে (অংশ ৫)।

RISC-V: ঠিকানা দুই নির্দেশে ভাগ

RISC-V-এর প্রতিটি নির্দেশ ৩২ bit, আর একটি নির্দেশে ৩২ bit-এর ঠিকানা আঁটে না। তাই ঠিকানা দুই ভাগে যায়: lui (বা PC-relative হলে auipc) ওপরের ২০ bit বসায়, আর পরের addi, ld, sd বা jalr নিচের ১২ bit যোগ করে। নিচের ১২ bit চিহ্নসহ (−2048 থেকে 2047), যা encoding-এর বিস্তারিত Computer Architecture কোর্সের পর্ব ২৭-এ। এই চিহ্নের জন্যই ভাগ করার সময় একটি সংশোধন লাগে। main.o-র while loop-এ step পড়ার দুই নির্দেশ আর তাদের দুই relocation, link-এর আগে আর পরে:

1+0x48  lui a0, 02+0x50  ld  a2, 0(a0)3HI20 step · LO12_I step4S = &step5ভুল: S>>12, S&0xfff6hi = (S + 0x800) >> 127lo = S − hi × 40968যাচাই: hi × 4096 + lo
হিসাব আর bytes
S
hi20
lo12
+0x48
+0x50
  1. Link-এর আগে। lui a0, 0 আর ld a2, 0(a0): দুটিতেই ঠিকানার জায়গা শূন্য। Relocation দুটি বলে, 0x48-এর নির্দেশে step-এর ওপরের ভাগ, 0x50-এর নির্দেশে নিচের ভাগ বসবে।
  2. S জানা গেল। Linker shop.o-র .data-কে executable-এর .data-র শুরুতে বসিয়েছে, তাই step = 0x1008d88. এবার শুধু ভাগ করা বাকি।
  3. সরল ভাগ, আর তার ভুল। ওপরের ২০ bit 0x1008, নিচের ১২ bit 0xd88 = 3464. কিন্তু ১২ bit-এর ক্ষেত্র চিহ্নসহ: 0xd88-এর সবচেয়ে বড় bit 1, তাই CPU পড়ে −632. ঠিকানা হতো 0x1008000 − 632 = 0x1007d88, আসলের চেয়ে ৪০৯৬ কম।
  4. সংশোধন: 0x800 যোগ। hi = (0x1008d88 + 0x800) >> 12 = 0x1009. নিচের ভাগ ঋণাত্মক হবে জেনে ওপরের ভাগ একটি বাড়ানো হলো। lui a0, 0x1009-এর bytes 37 95 00 01.
  5. নিচের ভাগ। lo = 0x1008d88 − 0x1009000 = −632, যা ১২ bit-এ 0xd88. ld-এর imm ক্ষেত্রে (bit 31–20) বসে: 03 36 85 d8, অর্থাৎ ld a2, -632(a0).
  6. যাচাই। 0x1009000 − 632 = 0x1008d88. লেখকের lab-এ pyelftools দিয়ে পড়া linked bazar.rv-এর ওই দুই জায়গায় ঠিক এই bytes. একই হিসাবে rounds (0x1008e88) পায় hi20 = 0x1009, lo12 = −376.

Function call-এ একই ভাগ, তবে PC-relative: R_RISCV_CALL_PLT একটি auipc ra, hi আর jalr ra, lo(ra)-এর জোড়ায় বসে, আর মান S − P. main-এর প্রথম price call P = 0x1002c12-এ, price = 0x1002c9e, দূরত্ব 140: hi20 = 0, lo12 = 140. লক্ষ্য কাছে হলে linker জোড়াটিকে একটি jal-এ ছোট করতে পারে (linker relaxation), কিন্তু তার জন্য object-এ R_RISCV_RELAX চিহ্ন লাগে; এই run-এর object-এ তা ছিল না, তাই linked file-এও জোড়াটি রয়ে গেছে। নিচের JavaScript নিজে সূত্র চালায় আর linked file-এর আসল bytes-এর সঙ্গে মেলায়:

// main.o (RISC-V)-এর সত্যিকারের relocation, link-এর পরের সত্যিকারের ঠিকানা দিয়ে নিজে বসানো
const SYM = { price: 0x1002c9e, delivery: 0x1002cd0, printf: 0x1003240,
              step: 0x1008d88, rounds: 0x1008e88, ".L.str": 0x1000208 };   // bazar.rv-এর symbol
const MAIN = 0x1002c00;                        // main কোথায় বসেছে; বদলে দেখুন
const R = [ // [offset, type, symbol, main.o-র bytes, bazar.rv-এর bytes]
  [0x12, "CALL_PLT", "price", "97000000e7800000", "97000000e780c008"],
  [0x2a, "CALL_PLT", "delivery", "97000000e7800000", "97000000e780600a"],
  [0x36, "HI20", ".L.str", "37050000", "37050001"],
  [0x3a, "LO12_I", ".L.str", "13050500", "13058520"],
  [0x48, "HI20", "step", "37050000", "37950001"],
  [0x50, "LO12_I", "step", "03360500", "033685d8"],
  [0x6a, "LO12_S", "rounds", "2330a900", "2334a9e8"]];
const word = (h, i = 0) => parseInt(h.slice(i, i + 8).match(/../g).reverse().join(""), 16) >>> 0;
const hex = w => (w >>> 0).toString(16).padStart(8, "0").match(/../g).reverse().join("");
const split = v => { const hi = (v + 0x800) >> 12; return [hi & 0xfffff, v - hi * 4096]; };
const U = (w, hi) => ((w & 0xfff) | (hi << 12)) >>> 0;                     // lui/auipc: ওপরের ২০ bit
const I = (w, lo) => ((w & 0xfffff) | ((lo & 0xfff) << 20)) >>> 0;         // addi/ld/jalr: imm[11:0]
const Sx = (w, lo) => ((w & 0x01fff07f) | (((lo >> 5) & 0x7f) << 25) | ((lo & 0x1f) << 7)) >>> 0;
let ok = 0;
for (const [off, t, s, before, real] of R) {
  const S = SYM[s], P = MAIN + off;
  let out;
  if (t === "CALL_PLT") { const [hi, lo] = split(S - P);           // pc-relative: S - P
    out = hex(U(word(before), hi)) + hex(I(word(before, 8), lo));
    console.log(`+${off.toString(16)} ${t} ${s}: S-P = ${S - P} → hi20=${hi}, lo12=${lo}`);
  } else { const [hi, lo] = split(S);                               // absolute: S
    out = hex(t === "HI20" ? U(word(before), hi) : t === "LO12_I" ? I(word(before), lo) : Sx(word(before), lo));
    console.log(`+${off.toString(16)} ${t} ${s}: S = 0x${S.toString(16)} → hi20=0x${hi.toString(16)}, lo12=${lo}`);
  }
  console.log(`    ${before} → ${out} ${out === real ? "(bazar.rv-এর সঙ্গে মিলেছে)" : "(আলাদা: " + real + ")"}`);
  ok += out === real;
}
console.log(`${ok}/${R.length} relocation হুবহু মিলেছে`);

আসল আউটপুট (browser-এর JavaScript):

+12 CALL_PLT price: S-P = 140 → hi20=0, lo12=140
    97000000e7800000 → 97000000e780c008 (bazar.rv-এর সঙ্গে মিলেছে)
+2a CALL_PLT delivery: S-P = 166 → hi20=0, lo12=166
    97000000e7800000 → 97000000e780600a (bazar.rv-এর সঙ্গে মিলেছে)
+36 HI20 .L.str: S = 0x1000208 → hi20=0x1000, lo12=520
    37050000 → 37050001 (bazar.rv-এর সঙ্গে মিলেছে)
+3a LO12_I .L.str: S = 0x1000208 → hi20=0x1000, lo12=520
    13050500 → 13058520 (bazar.rv-এর সঙ্গে মিলেছে)
+48 HI20 step: S = 0x1008d88 → hi20=0x1009, lo12=-632
    37050000 → 37950001 (bazar.rv-এর সঙ্গে মিলেছে)
+50 LO12_I step: S = 0x1008d88 → hi20=0x1009, lo12=-632
    03360500 → 033685d8 (bazar.rv-এর সঙ্গে মিলেছে)
+6a LO12_S rounds: S = 0x1008e88 → hi20=0x1009, lo12=-376
    2330a900 → 2334a9e8 (bazar.rv-এর সঙ্গে মিলেছে)
7/7 relocation হুবহু মিলেছে

সাতটি relocation-এর প্রতিটিতে সূত্র থেকে বানানো bytes linked bazar.rv-এর bytes-এর সঙ্গে হুবহু; লেখকের lab-এ Python-এ একই হিসাব main.o-র সব ১৭টিতে মিলেছে। .L.str-এর lo12 = 520 ধনাত্মক, তাই সেখানে সরল ভাগও কাজ করত; ভুলটি ধরা পড়ে কেবল যখন ঠিকানার bit 11 এক (step, rounds). U, I আর Sx তিনটি ছোট function তিন ধরনের নির্দেশ-ক্ষেত্রে bit বসায়; sd-এর (S-type) ১২ bit দুই টুকরোয় ভাগ হয়ে থাকে, তাই LO12_S আলাদা। MAIN বদলে দেখুন: call-এর দূরত্ব বদলায় আর “আলাদা” দেখায়, কিন্তু পরম ঠিকানার relocation বদলায় না।

৪ · Static linking — symbol resolution আর archive

Static linking-এ library-র দরকারি কোড executable-এর ভেতরে কপি হয়। প্রথম কাজ symbol resolution. Linker ফাইলগুলো command line-এর ক্রমে পড়ে, আর দুটি তালিকা রাখে: যেসব নামের সংজ্ঞা পাওয়া গেছে, আর যেসব নাম কেউ চেয়েছে কিন্তু এখনো পাওয়া যায়নি (U). bazar.rv বানানোর সময় C-এর startup code crt1.o আগে আসে; এর symbol লেখকের lab-এ সত্যিকারের musl-এর crt1.o থেকে পড়া:

1crt1.o (startup)2main.o3shop.o4libc-এর archive (.a)5weak-এর হিসাব6layout + relocation
Linker-এর দুই তালিকা
সংজ্ঞা
U
weak U
  1. crt1.o. _start আর _start_c সংজ্ঞায়িত। এটি main আর __libc_start_main চায়, আর weak হিসেবে _DYNAMIC, _init, _fini. তাই আপনার program-এ main না থাকলে error আসে startup code থেকে, আপনার ফাইল থেকে নয়।
  2. main.o. main সংজ্ঞায়িত, U থেকে সরল। নতুন চাওয়া: price, delivery, printf, step. rounds local, তাই নাম মেলানোয় অংশ নেয় না: অন্য ফাইলে আরেকটি static rounds থাকলেও সংঘাত নেই।
  3. shop.o. price, delivery, step মিলে গেল। বাকি শুধু libc-এর দুই নাম।
  4. libc-এর archive. Static library (.a) অনেক .o-র একটি বান্ডিল; এই run-এর RISC-V musl libc.a-তে ১,০৫৪টি member. Linker শুধু সেই member নেয়, যা বর্তমান U-র কোনো নামের সংজ্ঞা দেয়। নেওয়া member নিজেও নতুন নাম চাইতে পারে, তাই U খালি না হওয়া পর্যন্ত বারবার।
  5. Weak. _init আর _fini-এর weak সংজ্ঞা libc-এ ছিল। _DYNAMIC-এর সংজ্ঞা কোথাও নেই (static program-এ dynamic section থাকে না); weak undefined হলে error নয়, ঠিকানা 0. Executable-এর symbol table-এ সত্যিই _DYNAMIC = 0.
  6. এবার layout আর relocation. সব নাম মিলেছে, তাই section বসানো আর অংশ ৩-এর হিসাব। কোনো U বাকি থাকলে এখানেই থামত “undefined reference” দিয়ে।
নিয়ম ৭৪.২ — ELF static linker-এর resolution (GNU ld, lld-এর সাধারণ আচরণ)

(১) দুটি strong (global) সংজ্ঞা একই নামে: multiple definition error. (২) একটি strong আর এক বা একাধিক weak: strong জেতে। (৩) শুধু weak: প্রথমটি নেওয়া হয় (linker-ভেদে খুঁটিনাটি আলাদা হতে পারে)। (৪) কোনো সংজ্ঞা নেই: strong reference হলে undefined reference, weak reference হলে ঠিকানা 0. (৫) Archive member টানা হয় শুধু তখন, যখন সেটি একটি strong undefined নামের সংজ্ঞা দেয়; weak reference archive থেকে কিছু টানে না। (৬) Archive একবার, তার অবস্থানে, পড়া হয়: পরের ফাইল যে নাম চায়, আগে পড়া archive থেকে তা আর আসে না (GNU ld-এর ডিফল্টে; --start-group দিয়ে বারবার পড়ানো যায়)।

এই নিয়মগুলো নিজের হাতে দেখার জন্য নিচে একটি খেলনা linker. Object-এর format লেখকের নিজের, ELF-এর আদলে (সত্যিকারের ELF নয়): bytes, সংজ্ঞার তালিকা আর relocation (offset, ধরন, নাম, addend). “নির্দেশ” x86-এর মতো দেখতে: e8 + rel32 মানে call, a1 + abs32 মানে একটি পরম ঠিকানা থেকে পড়া। shop.o-তে coupon-এর একটি weak সংজ্ঞা (ফেরত 0), আর promo.o-তে strong সংজ্ঞা (ফেরত 10):

import struct   # খেলনা linker: ELF-এর আদলে নিজস্ব object format (সত্যিকারের ELF নয়)
obj = lambda name, text, data, defs, relocs: dict(        # defs: নাম -> (section, offset, bind)
    name=name, text=bytes.fromhex(text), data=bytes.fromhex(data), defs=defs, relocs=relocs)
main_o = obj("main.o", "e800000000 e800000000 a100000000 c3", "", {"main": ("text", 0, "global")},
             [(1, "PC32", "price", -4), (6, "PC32", "delivery", -4), (11, "ABS32", "step", 0)])
shop_o = obj("shop.o", "b801000000c3 b802000000c3 b800000000c3", "e204000000000000",
             {"price": ("text", 0, "global"), "delivery": ("text", 6, "global"),
              "step": ("data", 0, "global"), "coupon": ("text", 12, "weak")}, [])
promo_o = obj("promo.o", "b80a000000c3", "", {"coupon": ("text", 0, "global")}, [])
def link(objs, base=0x1000):
    addr, place = base, {}
    for sec in ("text", "data"):                 # ধাপ ১: একই ধরনের section পাশাপাশি
        for o in objs: place[o["name"], sec] = addr; addr += len(o[sec])
        addr = (addr + 15) & ~15                  # পরের section ১৬-এর গুণিতকে
    table, image = {}, {o["name"]: bytearray(o["text"]) for o in objs}   # ধাপ ২: symbol resolution
    for o in objs:
        for s, (sec, off, bind) in o["defs"].items():
            old = table.get(s)
            if old and old[1] == bind == "global": raise ValueError(f"multiple definition of '{s}': {old[2]}, {o['name']}")
            if not old or (old[1] == "weak" and bind == "global"):
                table[s] = (place[o["name"], sec] + off, bind, o["name"])
    for o in objs:                               # ধাপ ৩: relocation বসানো
        for off, kind, s, a in o["relocs"]:
            if s not in table: raise ValueError(f"{o['name']}: undefined reference to '{s}'")
            S, P = table[s][0], place[o["name"], "text"] + off
            v = S + a - P if kind == "PC32" else S + a   # PC-relative বা পরম
            image[o["name"]][off:off + 4] = struct.pack("<i", v)
            print(f"  {o['name']}+{off:<2} {kind:5} {s:8} S={S:#x} P={P:#x} -> {v}")
    return table, b"".join(image.values())
table, exe = link([main_o, shop_o, promo_o])
for s, (v, bind, who) in table.items(): print(f"  {s:8} {v:#x} {bind:6} ({who})")
print("  text:", exe.hex(" "))
for objs in ([main_o], [main_o, shop_o, shop_o]):
    try: link(objs)
    except ValueError as e: print("  link error:", e)

আসল আউটপুট (browser-এর CPython, Pyodide):

  main.o+1  PC32  price    S=0x1010 P=0x1001 -> 11
  main.o+6  PC32  delivery S=0x1016 P=0x1006 -> 12
  main.o+11 ABS32 step     S=0x1030 P=0x100b -> 4144
  main     0x1000 global (main.o)
  price    0x1010 global (shop.o)
  delivery 0x1016 global (shop.o)
  step     0x1030 global (shop.o)
  coupon   0x1022 global (promo.o)
  text: e8 0b 00 00 00 e8 0c 00 00 00 a1 30 10 00 00 c3 b8 01 00 00 00 c3 b8 02 00 00 00 c3 b8 00 00 00 00 c3 b8 0a 00 00 00 c3
  link error: main.o: undefined reference to 'price'
  link error: multiple definition of 'price': shop.o, shop.o

প্রথম তিন লাইন relocation: price-এর call-এ S − (P + 4) = 0x1010 − 0x1005 = 11, তাই bytes e8 0b 00 00 00; step-এর পরম ঠিকানা 0x1030 = 4144, তাই a1 30 10 00 00. Layout: main.o-র ১৬ byte 0x1000-এ, shop.o-র ১৮ byte 0x1010-এ, promo.o-র ৬ byte 0x1022-এ; .data পরের ১৬-এর গুণিতকে, 0x1030. coupon গেছে promo.o-র strong সংজ্ঞায় (নিয়ম ২); shop.o-র weak কোড (b8 00 00 00 00 c3) executable-এ রয়ে গেছে, কেউ ডাকে না, ঠিক বাস্তব linker-এর মতো (যদি না অব্যবহৃত section ফেলে দেওয়ার option দেওয়া হয়)। শেষ দুই লাইন নিয়ম ৪ আর ১-এর error. খেলনাটি প্রথম অমীমাংসিত নামেই থামে; GNU ld সব অমীমাংসিত নাম একসঙ্গে জানায়, যা নিচের সত্যিকারের run-এ দেখবেন।

এবার সত্যিকারের GNU ld. নিচের bash script Wandbox-এর Linux-এ চলে (GCC 13.3, Ubuntu): তিনটি C ফাইল, একটি archive (ar rcs), আর চার রকম link. main.c-তে coupon শুধু weak হিসেবে ঘোষিত; সংজ্ঞা নেই এমন অবস্থায় ঠিকানা 0, তাই coupon ? … : -1. Linker-এর বার্তায় system path ছোট করতে একটি sed:

# symbol resolution-এর নিয়ম, সত্যিকারের GNU ld দিয়ে: archive-এর ক্রম, weak আর দুবার সংজ্ঞা
cat > shop.c <<'EOF'
long step = 1250;
long price(long qty, long unit) { long p = qty * unit; return p >= 1000 ? p - p / 10 : p; }
long delivery(long total) { return total >= 1000 ? 0 : 60; }
EOF
cat > promo.c <<'EOF'
long coupon(long total) { return total / 20; }      /* strong সংজ্ঞা */
EOF
cat > main.c <<'EOF'
#include <stdio.h>
long price(long qty, long unit);
long delivery(long total);
long coupon(long total) __attribute__((weak));       /* না পেলেও link হবে */
int main(void) {
    long first = price(2, 520) + delivery(price(2, 520));
    printf("%ld, coupon: %ld\n", first, coupon ? coupon(first) : -1L);
    return 0;
}
EOF
gcc -O1 -c main.c shop.c promo.c && ar rcs libshop.a shop.o promo.o
ld_msg() { sed -e 's#^.*/ld: #ld: #' -e 's#^.*collect2: #collect2: #'; }
echo "== ১. main.o libshop.a";        gcc main.o libshop.a -o a1 2>&1 | ld_msg && ./a1
echo "== ২. libshop.a main.o";        gcc libshop.a main.o -o a2 2>&1 | ld_msg
echo "== ৩. main.o shop.o promo.o";   gcc main.o shop.o promo.o -o a3 2>&1 | ld_msg && ./a3
echo "== ৪. main.o shop.o shop.o";    gcc main.o shop.o shop.o -o a4 2>&1 | ld_msg
echo "== libshop.a-র ভেতরে"; ar t libshop.a

আসল আউটপুট (Wandbox, GCC 13.3 আর GNU ld):

== ১. main.o libshop.a
996, coupon: -1
== ২. libshop.a main.o
ld: main.o: in function `main':
main.c:(.text+0x10): undefined reference to `price'
ld: main.c:(.text+0x22): undefined reference to `price'
ld: main.c:(.text+0x2a): undefined reference to `delivery'
collect2: error: ld returned 1 exit status
== ৩. main.o shop.o promo.o
996, coupon: 49
== ৪. main.o shop.o shop.o
ld: shop.o: in function `price':
shop.c:(.text+0x0): multiple definition of `price'; shop.o:shop.c:(.text+0x0): first defined here
ld: shop.o: in function `delivery':
shop.c:(.text+0x36): multiple definition of `delivery'; shop.o:shop.c:(.text+0x36): first defined here
ld: shop.o:(.data+0x0): multiple definition of `step'; shop.o:(.data+0x0): first defined here
collect2: error: ld returned 1 exit status
== libshop.a-র ভেতরে
shop.o
promo.o

১. main.o-র strong চাওয়া price-এর জন্য shop.o টানা হলো, কিন্তু promo.o নয়, কারণ coupon-এর reference weak (নিয়ম ৫); তাই -1. ২. Archive আগে পড়া হলো, তখন কেউ কিছু চায়নি, তাই কিছু টানা হয়নি; পরে main.o এসে চাইল, কিন্তু archive আর পড়া হয় না (নিয়ম ৬)। লক্ষ করুন বার্তার .text+0x10, +0x22, +0x2a: এগুলো main.o-র relocation entry-র offset, যেখানে linker ঠিকানা বসাতে পারেনি। ৩. promo.o সরাসরি দিলে সেটি সব সময় link হয়, আর coupon(996) = 996 / 20 = 49. ৪. একই ফাইল দুবার: তিনটি strong নামেই multiple definition (নিয়ম ১)। ছোট শিক্ষা: “undefined reference” পেলে প্রথমে দেখুন library ঠিক ক্রমে আছে কি না, আর weak symbol দিয়ে ঐচ্ছিক feature বানালে মনে রাখুন archive থেকে সেটি নিজে থেকে আসবে না।

৫ · Shared library, PIC, GOT আর PLT — compiler কী আলাদা লেখে

Dynamic linking-এ library-র কোড executable-এ কপি হয় না; executable-এ শুধু লেখা থাকে কোন shared library লাগবে, আর program চালু হওয়ার সময় dynamic linker সেগুলো আনে। সমস্যা হলো, একটি .so প্রতিটি process-এ ভিন্ন ঠিকানায় বসতে পারে (ASLR), অথচ তার কোডের পাতাগুলো সব process ভাগ করে শুধু-পড়ার হিসেবে রাখতে চায়। কোডে পরম ঠিকানা লিখলে প্রতিটি process-এ কোড বদলাতে হতো। সমাধান position-independent code (PIC): কোড নিজের ভেতরের জিনিস খোঁজে PC থেকে দূরত্বে, আর বাইরের জিনিসের ঠিকানা পড়ে একটি টেবিল থেকে, GOT. বাইরের function ডাকা হয় ছোট লাফের কোড PLT দিয়ে, যা GOT-এ লেখা ঠিকানায় লাফ দেয়। PLT/GOT-এর ধাপে ধাপে ছবি, lazy binding-এর সত্যিকারের প্রমাণ আর dlopen আছে Operating Systems কোর্সের পর্ব ৩০-এ; এখানে compiler আর linker কী লেখে, শুধু সেটুকু।

প্রথম পার্থক্য compile-এর সময়েই। একই main.c, x86-64-এর জন্য, দুই target-এ Clang 22 (লেখকের lab, সত্যিকারের run): musl target-এ step পড়ার relocation R_X86_64_PC32 step (ধরে নেওয়া হয় step এই executable-এই থাকবে), আর x86_64-linux-gnu target-এ R_X86_64_REX_GOTPCRELX step (ঠিকানা GOT থেকে পড়তে হবে)। তারপর shop.c-কে -fPIC -shared দিয়ে libshop.so বানিয়ে তার সঙ্গে link করা হলো, আর pyelftools দিয়ে পড়া হলো:

~/link $ python -m ziglang cc -target x86_64-linux-gnu -O1 -fPIC -shared shop.c -o out/libshop.so
~/link $ python -m ziglang cc -target x86_64-linux-gnu -O2 out/main.x86g.o out/libshop.so -o out/bazar.so.exe
== out/bazar.so.exe: ELFCLASS64 ET_EXEC EM_X86_64 entry=0x10015b0
-- .rela.dyn (2)
   off=0x1002940 R_X86_64_GLOB_DAT        __libc_start_main
   off=0x1002948 R_X86_64_GLOB_DAT        step
-- .rela.plt (3)
   off=0x1002968 R_X86_64_JUMP_SLOT       price
   off=0x1002970 R_X86_64_JUMP_SLOT       delivery
   off=0x1002978 R_X86_64_JUMP_SLOT       printf
    DT_NEEDED out/libshop.so
    DT_NEEDED libc.so.6
    DT_FLAGS 8
    DT_FLAGS_1 1
     interp: /lib64/ld-linux-x86-64.so.2

এবার relocation-গুলো আর linker-এর জন্য নয়, dynamic linker-এর জন্য, আর সব কটির লক্ষ্য GOT-এর ঘর (0x1002940 থেকে)। GLOB_DAT step: চালু হওয়ার সময় libshop.so-তে step-এর ঠিকানা খুঁজে GOT-এ লিখতে হবে। JUMP_SLOT price: PLT-এর price-ঘরের GOT-এ। DT_NEEDED out/libshop.so: library-তে কোনো SONAME ছিল না, তাই linker যে path পেয়েছে তা-ই লিখেছে। DT_FLAGS 8 হলো DF_BIND_NOW, আর DT_FLAGS_1 1 হলো DF_1_NOW: এই executable-এ lazy binding নেই; dynamic linker main-এর আগেই সব ঘর পূরণ করে। Wandbox-এর Ubuntu-র GCC 13.3-এর ডিফল্টও একই: একই রকম build-এ readelf -d দেখিয়েছে (FLAGS) BIND_NOW আর Flags: NOW PIE; -Wl,-z,lazy দিলে শুধু PIE থাকে। তাই “dynamic linking মানে প্রথম call-এ ঠিকানা খোঁজা” কথাটি সব system-এ ডিফল্ট নয়; নিজের toolchain-এ দেখে বলতে হয়।

Wandbox-এর GCC আরেকটি জিনিস দেখিয়েছে। Ubuntu-র GCC ডিফল্টে PIE বানায়, আর extern step-কে PC-relative পড়ে, যেন সেটি executable-এই আছে। step আসলে libshop.so-তে, তাই linker একটি copy relocation বসিয়েছে: R_X86_64_COPY step. চালু হওয়ার সময় dynamic linker step-এর মান library থেকে executable-এর নিজের .bss-এ কপি করে, আর library-ও তখন থেকে সেই কপিটিই ব্যবহার করে। দুই compiler, দুই কৌশল: Clang-এর এই run GOT দিয়ে পড়েছে (প্রতি পড়ায় একটি বাড়তি load), GCC-র run সরাসরি পড়েছে কিন্তু variable-টির আকার executable-এ আটকে গেছে (library পরে বড় করলে ABI ভাঙে)। এমন নকশা-সিদ্ধান্তই ABI-এর অংশ, যার function call-এর দিক পর্ব ৭১-এ।

“static” শব্দের তিন অর্থ গুলিয়ে ফেলবেন না। C-তে static long rounds মানে local symbol (internal linkage); -static flag মানে static linking; আর “static” storage মানে program-এর পুরো জীবন ধরে টিকে থাকা (পর্ব ১৬)। তিনটির সম্পর্ক ঐতিহাসিক, নিয়মে নয়। Wandbox-এ একই ছোট program static link করলে ফাইল 785,416 bytes, dynamic link করলে 16,056 bytes হয়েছে (GCC 13.3, একবারের run).

৬ · Loader আর program-এর শুরু — execve থেকে _start হয়ে main

Executable তৈরি; এবার চালানো। Loader-এর কাজ ফাইলের অংশ মেমরিতে বসানো আর প্রথম নির্দেশে লাফ দেওয়া। Linux-এ এর প্রথম অংশ kernel-এর execve; process আর virtual memory-র দিক Operating Systems কোর্সের পর্ব ০৮ আর পর্ব ৩৫-এ। Loader section দেখে না; দেখে program header-এর তালিকা, যেখানে প্রতিটি PT_LOAD বলে: ফাইলের কোন অংশ (offset, filesz) মেমরির কোন ঠিকানায় (vaddr, memsz), কোন অনুমতিতে। প্রথম নির্দেশের ঠিকানা header-এর e_entry-তে: এটিই আসল entry point, আর সেটি main নয়।

1execve("./bazar.rv")23 × PT_LOAD পড়া3map, .bss শূন্য, stack4_start   0x1002ba85_start_c 0x1002bca6__libc_start_main7main     0x1002c008exit(0)
অবস্থা
pc
ঘটনা
  1. execve. Kernel ফাইলের প্রথম ৬৪ byte পড়ে: magic ঠিক, ET_EXEC, যন্ত্র RISC-V, e_entry = 0x1002ba8. কোনো PT_INTERP নেই, তাই কোনো dynamic linker লাগবে না (static).
  2. Program header. তিনটি PT_LOAD: শুধু-পড়া 0x1000000 (0x1ba8 byte: header, .rodata), পড়া-চালানো 0x1002ba8 (0x51e0 byte: .text), পড়া-লেখা 0x1008d88 (ফাইলে 0xfc byte, মেমরিতে 0x740).
  3. Map আর stack. শেষ segment-এর memsz − filesz = 0x644 byte ফাইলে নেই: এটিই .bss (rounds 0x1008e88-এ), যা শূন্য দিয়ে ভরা হয়। Kernel stack-এ argc, argv, environment আর auxiliary vector রাখে।
  4. _start (assembly). gp-তে __global_pointer$ (0x1000800), a0-তে stack pointer, a1-তে &_DYNAMIC: weak undefined বলে 0. তারপর _start_c-তে tail call (jalr x0, ফেরার ঠিকানা ছাড়া)।
  5. _start_c (C). Stack থেকে argc আর argv বের করে, a0-তে main-এর ঠিকানা (0x1002c00), a3, a4-তে _init, _fini; তারপর __libc_start_main-এ tail call. main এখানে ডাকা হয় না, ঠিকানা হিসেবে পাঠানো হয়।
  6. __libc_start_main. __init_libc (environment, auxv, thread-এর তথ্য), তারপর পরের ধাপে constructor চালানো (libc_start_init).
  7. main. musl-এর source অনুযায়ী এখানে exit(main(argc, argv, envp)): পাঠানো ঠিকানা দিয়ে main ডাকা হয়। price, delivery, printf চলে, আউটপুট 996, 5000, 3.
  8. exit(0). main ০ ফেরত দিলে exit buffer-এ জমা stdout লিখে দেয়, তারপর exit system call; kernel সব মেমরি ফিরিয়ে নেয়।

ঠিকানাগুলো লেখকের lab-এ linked bazar.rv-এর symbol table আর program header থেকে, আর _start থেকে __libc_start_main পর্যন্ত call-এর লক্ষ্য একটি ছোট Python RV64 decoder দিয়ে নির্দেশ পড়ে বের করা (auipc/jalr আর auipc/addi জোড়া)। শেষ ধাপে main-এর call একটি register দিয়ে (indirect), তাই সেটি decoder-এর তালিকায় সরাসরি আসেনি; সেখানে musl-এর source-এর ওপর ভরসা করা হয়েছে। Dynamic executable হলে ধাপ ১-এ PT_INTERP থাকে (/lib64/ld-linux-x86-64.so.2), kernel আগে সেটি বসায় আর তার entry-তে লাফ দেয়; dynamic linker library আনে, GOT পূরণ করে, তারপর program-এর e_entry-তে যায়।

৭ · Windows-এর PE/COFF, আর Haat-এর জন্য linking

Windows-এর format আলাদা: object file COFF, আর executable ও DLL PE (Portable Executable), যা COFF-এর ওপর গড়া। ধারণাগুলো একই: section, symbol, relocation. একই main.c, -target x86_64-windows-gnu দিয়ে (লেখকের lab, সত্যিকারের run; COFF header নিজের ছোট Python reader দিয়ে পড়া):

~/link $ python -m ziglang cc -target x86_64-windows-gnu -O1 -g0 -fno-sanitize=undefined -c main.c -o main.obj
Machine=0x8664 sections=9 symbols=29 size=1681
  sym main         value=0x0 section=1 class=EXTERNAL
  sym __main       value=0x0 section=0 class=EXTERNAL
  sym price        value=0x0 section=0 class=EXTERNAL
  sym step         value=0x0 section=0 class=EXTERNAL
  section .text      size=286 relocs=13
     off=0x000c IMAGE_REL_AMD64_REL32 __main
     off=0x001b IMAGE_REL_AMD64_REL32 price
     off=0x004a IMAGE_REL_AMD64_REL32 .refptr.step
     …
  section .bss       size=4 relocs=0
~/link $ python -m ziglang cc -target x86_64-windows-gnu -O1 -g0 -fno-sanitize=undefined main.c shop.c -o bazar.exe
~/link $ ./bazar.exe
996
5000
3

তিনটি জিনিস লক্ষ করুন। (ক) Relocation-এর নাম আলাদা (IMAGE_REL_AMD64_REL32), কাজ একই: চার byte-এর PC-relative দূরত্ব। (খ) main নিজেই __main ডাকে: MinGW ধাঁচের toolchain-এ এটি constructor চালানোর জন্য, যা Linux-এ __libc_start_main-এর কাজ। (গ) .bss 4 byte: Windows x64-এ long ৩২ bit (LLP64 মডেল), Linux x86-64-এ ৬৪ bit (LP64). একই C কোড, ভিন্ন ABI; বাজারঘরের অঙ্ক ৩২ bit-এ আঁটে বলে আউটপুট একই। আর এই exe লেখকের Windows যন্ত্রে সত্যিই চলে 996, 5000, 3 ছেপেছে। PE executable সাধারণত একটি পছন্দের ঠিকানা (ImageBase) আর base relocation-এর তালিকা রাখে, যাতে অন্য ঠিকানায় বসালে loader ঠিকানা সারাতে পারে; DLL-এর function ডাকা হয় Import Address Table দিয়ে, যা ভূমিকায় GOT-এর কাছাকাছি। macOS-এর format আবার আলাদা: Mach-O.

Haat-এর native program-এ linker কী করবে

পর্ব ৭২-এর Haat → RISC-V back end একটি assembly ফাইল বানাবে। চালানো যায় এমন program পেতে আরও তিনটি টুকরো লাগে, আর এখানেই linking সামনে আসে। নিচের নকশা এই পর্বের প্রস্তাব; পর্ব ৭২-এর back end এটিই মেনে চলেছে, পার্থক্য শুধু শেষ বিন্দুতে:

  • Runtime library. Haat-এর print Int, Bool আর Str ছাপে (reference-এর সিদ্ধান্ত ২৭), আর runtime error বার্তা 3:18: runtime error: division by zero (সিদ্ধান্ত ২৬)। এগুলো প্রতিবার assembly-তে না লিখে C-তে একবার লেখা যায়: haat_print_int, haat_div_zero(line, col). Compiler-এর বানানো কোডে এগুলো undefined symbol, আর linker runtime-এর .o থেকে মেলায়।
  • নামের নিয়ম. Haat-এর fn exit(...) বা fn printf(...) বৈধ নাম। Symbol-এর নাম হুবহু রাখলে C library-র নামের সঙ্গে সংঘাত হতে পারে, আর static link-এ library-র কোনো অংশ ভুল করে Haat-এর function ডাকতেও পারে। তাই একটি উপসর্গ, যেমন haat_price: এটি সরল ধরনের name mangling, যা C++-এ overload আর namespace-এর জন্য অনেক জটিল।
  • Top-level আর hoisting. Haat-এ top-level function program-এর শুরু থেকে দেখা যায় (সিদ্ধান্ত ১৭)। Linker-এর জগতে এটি স্বাভাবিক: global symbol-এর ক্রম গুরুত্বহীন, তাই পারস্পরিক recursion-এ কোনো বাড়তি কাজ নেই। Function-এর ভেতরে ব্যবহৃত top-level variable (সিদ্ধান্ত ১৮) .data বা .bss-এ global symbol হবে; “not initialized yet” পরীক্ষার জন্য পাশে একটি flag লাগবে।
  • শুরু. Haat-এর top-level statement-গুলো compiler একটি function-এ (ধরুন haat_main) রাখবে, আর runtime-এর C main সেটি ডাকবে। বাকিটা এই পর্বের ধাপ ৬-এর মতোই: _start → libc → main. (পর্ব ৭২-এর back end libc ছাড়াই চলে, তাই সেখানে runtime-এর নিজের ছোট _start সরাসরি haat_main ডাকে; আর Str সেই back end-এর বাইরে, তাই runtime ছাপে শুধু Int আর Bool.)

৮ · Link-time optimization — linker যখন compiler

আলাদা compile-এর একটি দাম আছে। main.c compile করার সময় compiler price-এর দেহ দেখে না, তাই inline করতে পারে না, আর step-এর মান 1250 কি না তা-ও জানে না। Link-time optimization (LTO) এই দেয়াল সরায়: -flto দিলে .o-তে machine code নয়, compiler-এর IR থাকে, আর link-এর সময় সব ফাইলের IR একসঙ্গে optimize হয়। Inlining আর interprocedural optimization-এর বিস্তারিত পর্ব ৬৭-এ; এখানে সত্যিকারের প্রমাণ। লেখকের lab-এ Clang 22 (x86_64-linux-musl, -O2):

~/link $ python -m ziglang cc … -O2 -flto -c main.c -o main.lto.o
~/link $ python -c "print(open('main.lto.o','rb').read()[:4])"
b'BC\xc0\xde'
(pyelftools, link-এর পরে)
bazar.nolto  main size 307  calls: ['price', 'price', 'delivery', 'printf', 'printf', 'printf']
bazar.lto    main size 58   calls: ['printf', 'printf', 'printf']   price symbol: নেই

BC C0 DE হলো LLVM bitcode-এর magic: এটি ELF নয়। LTO-র পরে main ৩০৭ byte থেকে ৫৮ byte, আর price, delivery-কে আর ডাকে না; price নামের symbol-টিই executable-এ নেই। main-এর bytes-এ 996 (0x3e4) আর 5000 (0x1388) সরাসরি ধ্রুবক হিসেবে বসে আছে: পুরো হিসাব আর while loop compile-এর সময়েই শেষ, শুধু rounds-এ একবারে 4 যোগ রয়ে গেছে, কারণ সেটি memory-তে থাকা একটি variable. Wandbox-এ GCC 13.3-এর -flto একই কাজ করেছে (সত্যিকারের run): দুই build-ই 996, 5000, 3 ছাপে; nm-এ সাধারণ build-এ price|delivery|step-এর ৩টি symbol, LTO build-এ ০টি; আর main-এর disassembly-তে mov $0x3e4,%edx ও mov $0x1388,%edx. দাম: link ধীর আর বেশি মেমরি খায়, কারণ linker-এর ভেতরে compiler-এর middle end আর back end চলে। পর্ব ৬৮-এ যে LLVM IR দেখেছেন, LTO-তে linker ঠিক সেটিই পড়ে।

Linker compiler-এর চেয়েও পুরোনো ধারণা। ১৯৫০-এর দশকের প্রথম দিকের যন্ত্রে (যেমন Cambridge-এর EDSAC) subroutine-এর লাইব্রেরিকে মেমরির যেকোনো জায়গায় বসানোর জন্য relocating loader ব্যবহার হতো বলে উল্লেখ পাওয়া যায়; পরে IBM-এর system-এ “linkage editor” নামটি চালু হয়। Unix-এর প্রথম দিকের format ছিল a.out; AT&T-র System V-এ এল COFF; আর ELF তৈরি হয় UNIX System V Release 4-এর জন্য (মোটামুটি ১৯৮০-এর দশকের শেষে), যা Linux ১৯৯০-এর দশকের মাঝামাঝি a.out ছেড়ে গ্রহণ করে। Windows NT (১৯৯৩) COFF থেকে PE গড়ে। John R. Levine-এর Linkers and Loaders (১৯৯৯/২০০০) বইটি আজও এই বিষয়ের মানদণ্ড।

আরও গভীরে: বড় C++ বা browser প্রকল্পে link একসময় build-এর সবচেয়ে ধীর ধাপ হয়ে ওঠে, তাই নতুন linker এসেছে গতির জন্য: GNU-র gold (Ian Lance Taylor, ২০০৮ সালের দিকে), LLVM-এর lld, আর Rui Ueyama-র mold (২০২০-এর দশকের শুরুতে), যা section কপি আর relocation বসানো বহু thread-এ ভাগ করে। LTO-রও দুই ধারা আছে: “full” LTO পুরো program-এর IR একটি module-এ মেলায়, আর ThinLTO (LLVM) ছোট সারাংশ দেখে কোন function কোথায় inline হবে ঠিক করে, তারপর ফাইলগুলো সমান্তরালে optimize করে। খুঁটিনাটি version-ভেদে বদলায়; নিজের toolchain-এর দলিল দেখুন।

পরীক্ষা ও ইন্টারভিউতে: এই প্রশ্নগুলো প্রায়ই আসে, বিশ্ববিদ্যালয়, চাকরি বা ইন্টারভিউর পরীক্ষায়। Compiler, assembler, linker, loader-এর কাজ? → source থেকে assembly, assembly থেকে object, object জুড়ে executable, executable মেমরিতে বসিয়ে চালানো। “undefined reference” আর “multiple definition” কোন ধাপের error? → linker-এর symbol resolution-এর। Relocation কী, হাতে হিসাব করুন → (offset, type, symbol, addend); PC-relative-এ S + A − P, যেমন x86-64-এ rel32 = 299. Static আর dynamic linking-এর পার্থক্য? → কোড কপি বনাম চালু হওয়ার সময় জোড়া; আকার, আপডেট আর নির্ভরতার আপস। PIC আর GOT কেন? → library যেকোনো ঠিকানায় বসে, কোডের পাতা ভাগ হয়; বাইরের ঠিকানা টেবিলে।

৯ · AI-এর যুগে linking

Linker-এর error AI-কে দেখালে প্রায়ই কাজের পরামর্শ পাবেন, কারণ বার্তাগুলো চেনা। ভুল আসে সূক্ষ্ম জায়গায়: সংখ্যার হিসাব, ডিফল্ট আচরণ, আর এক system-এর নিয়ম সব system-এ চাপানো।

AI-এর ভুলকীভাবে ধরবেন
RISC-V-এ hi20 = S >> 12 লেখা, 0x800 যোগ ছাড়া; বা x86-64-এ −4 addend ভুলে যাওয়াLinked file-এর bytes পড়ে সূত্রের ফলের সঙ্গে মেলানো, বিশেষ করে bit 11 এক এমন ঠিকানায়
“Dynamic linking-এ সবসময় lazy binding” বা “static library-র পুরোটা executable-এ যায়”readelf -d-এ FLAGS দেখা; nm দিয়ে কোন member এসেছে দেখা
Weak symbol-এর নিয়ম ভুল: “weak reference archive থেকে সংজ্ঞা টেনে আনে” বা “দুটি strong-এর মধ্যে প্রথমটি জেতে”তিন ফাইলের ছোট পরীক্ষা (অংশ ৪-এর মতো), নিজের linker-এ
Library-র ক্রমের error-এ “header যোগ করুন” পরামর্শError-টি compile না link-এর, বার্তায় ld: আছে কি না দেখা
বানানো linker flag বা relocation type-এর নাম, বা অন্য যন্ত্রের নিয়মpsABI দলিল আর ld --help; নিজের object-এ readelf -r

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

আমি Linux-এ RISC-V (riscv64, musl, static) আর x86-64 (glibc, dynamic) দুই target-এ একটি ছোট C program link করছি। toolchain: Clang 22 আর lld, তুলনার জন্য GCC 13 আর GNU ld. ১. main.o-র readelf -r আউটপুট নিচে দিলাম। প্রতিটি relocation-এর জন্য সূত্র (S, A, P দিয়ে) লেখো, আর link-এর পরের ঠিকানা দিলে কোন bytes বসবে হিসাব করে দেখাও। ২. R_RISCV_HI20/LO12_I-এর ভাগে 0x800 কেন যোগ হয়, ছোট প্রমাণসহ বলো। ৩. Weak symbol আর archive member টানার নিয়ম GNU ld আর lld-এ কী, কোথায় দুটি আলাদা হতে পারে বলো। ৪. প্রতিটি দাবির জন্য আমি কোন command চালিয়ে যাচাই করব (readelf, nm, objdump), সেটিও দাও। নিশ্চিত না হলে অনুমান করবে না; কোন version-এর কথা বলছ, তা লিখবে।

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

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

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

প্র ০১Compiler কেন সরাসরি executable বানায় না? Linker নামের আলাদা ধাপটি ইতিহাসে কীভাবে এল, আর আজও কেন টিকে আছে?

প্রথম দিকের কম্পিউটারে program লেখা হতো হাতে, আর বারবার লাগে এমন অংশ (বর্গমূল, ছাপানো) subroutine হিসেবে কাগজের টেপে রাখা হতো। সমস্যা ছিল: subroutine কোন ঠিকানায় বসবে, তা প্রতিটি program-এ আলাদা। ১৯৫০-এর দশকের শুরুর দিকে Cambridge-এর EDSAC-এ এই সমস্যার সমাধানে টেপ পড়ার সময় ঠিকানা সারিয়ে নেওয়ার ব্যবস্থা ছিল বলে উল্লেখ পাওয়া যায়; এটিই relocating loader-এর প্রাচীন রূপ। পরে IBM-এর system-এ এই কাজ একটি আলাদা প্রোগ্রাম করত, যার নাম “linkage editor”. অর্থাৎ library আর relocation-এর ধারণা উচ্চ-স্তরের ভাষার প্রায় সমান পুরোনো।

আজও আলাদা ধাপ টিকে আছে তিন কারণে। প্রথম, separate compilation: হাজার ফাইলের প্রকল্পে একটি ফাইল বদলালে শুধু সেটি compile হয়, বাকিদের .o আগের মতো থাকে; link সস্তা, compile দামি। দ্বিতীয়, ভাষার মিশ্রণ: একটি executable-এ C, C++, Rust, Fortran আর হাতে লেখা assembly একসঙ্গে থাকতে পারে, কারণ সবাই একই object format আর ABI মানে। Linker ভাষা চেনে না, শুধু symbol আর relocation চেনে; ঠিক এ কারণেই Haat-এর back end নিজের linker না লিখে সিস্টেমেরটি ব্যবহার করতে পারে। তৃতীয়, library বিতরণ: একটি library source ছাড়াই .a বা .so হিসেবে দেওয়া যায়।

তবু সীমানা ঝাপসা হচ্ছে। LTO-তে linker compiler-এর অংশ চালায়; Go-র মতো কিছু ভাষার নিজস্ব linker আছে, যা ভাষার নিয়ম জানে; আর JIT compiler (পর্ব ৬১) চলার সময় নিজেই কোড বানিয়ে নিজেই “link” করে, কোনো ফাইল ছাড়া।

মূল উপলব্ধি: Linker একটি চুক্তির রক্ষক: ভাষা যা-ই হোক, object format, symbol আর relocation-এর সাধারণ চুক্তি মানলে সব টুকরো জোড়া লাগে; এই চুক্তিই ধাপটিকে সত্তর বছর ধরে টিকিয়ে রেখেছে।

প্র ০২Static না dynamic linking — কোনটি ভালো? Go আর Rust-এর মতো আধুনিক ভাষা এই প্রশ্নে কোন দিকে গেছে, আর কেন?

দুটির আপস পরিষ্কার। Static linking-এ executable স্বয়ংসম্পূর্ণ: অন্য যন্ত্রে কপি করলেই চলে, library-র version নিয়ে ঝামেলা নেই, আর চালু হওয়া সামান্য দ্রুত (dynamic linker-এর কাজ নেই)। দাম: ফাইল বড় (এই পর্বের Wandbox run-এ ছোট program static-এ 785,416 bytes, dynamic-এ 16,056 bytes), আর library-তে নিরাপত্তা-ত্রুটি সারাতে প্রতিটি program নতুন করে link করতে হয়। Dynamic linking-এ একটি library আপডেট করলে সব program সারে, মেমরিতে কোডের একটি কপি ভাগ হয়; দাম: চালানোর যন্ত্রে ঠিক version লাগে, আর library-র ABI ভাঙলে পুরোনো program ভাঙে।

ABI-র এই ঝুঁকি সামলাতে glibc symbol versioning ব্যবহার করে: এই পর্বের Wandbox আউটপুটে __libc_start_main@GLIBC_2.34 আর __printf_chk@GLIBC_2.3.4 দেখেছেন। একই নামের function-এর একাধিক version library-তে থাকে, আর পুরোনো program পুরোনো version-টিই পায়। Windows-এর পুরোনো দিনের “DLL hell” (একটি program DLL বদলে দিলে আরেকটি ভাঙা) এই সমস্যারই নাম।

Go সাধারণত সব Go কোড static link করে একটি একক ফাইল বানায় (C কোড ব্যবহার করলে, অর্থাৎ cgo থাকলে, ছবিটি বদলায়), যা container আর server-এ বিতরণ সহজ করে। Rust-এর crate-গুলো সাধারণত static link হয়, কারণ Rust-এর নিজের ABI স্থিতিশীল নয়; তবে Linux-এর -gnu target-এ libc সাধারণত dynamic থাকে, আর -musl target-এ পুরোপুরি static বানানো সহজ। দুটি ভাষাই monomorphization (পর্ব ৩৭) ব্যবহার করে, যেখানে generic কোডের কপি ব্যবহারকারীর program-এ তৈরি হয়; এমন কোড dynamic library-র সীমানা পেরোতে পারে না, তাই static-এর দিকে ঝোঁকা স্বাভাবিক। এসব ডিফল্ট version-ভেদে বদলাতে পারে; নিশ্চিত হতে নিজের toolchain-এ readelf -d দেখুন।

মূল উপলব্ধি: Static বনাম dynamic আসলে “কে কখন আপডেট করে” প্রশ্ন; ভাষার নকশা (স্থিতিশীল ABI আছে কি না, generic কীভাবে বানানো হয়) প্রায়ই উত্তরটি আগেই ঠিক করে দেয়।

প্র ০৩RISC-V কেন ঠিকানাকে ২০ + ১২ bit-এ ভাগ করে, আর linker relaxation কেন linker-এর কাজকে কঠিন করে তোলে?

RISC-V-এর মূল নির্দেশ সব ৩২ bit, যাতে decode সরল থাকে। Opcode আর register-এর পরে immediate-এর জন্য জায়গা থাকে বড়জোর ২০ bit (U-type: lui, auipc) বা ১২ bit (I-type, S-type). ৩২ bit-এর একটি ঠিকানা তাই দুই নির্দেশে যায়, আর দুটি relocation লাগে: HI20 আর LO12. ১২ bit-এর অংশ চিহ্নসহ যোগ হয়, তাই ওপরের অংশ হিসাব হয় (S + 0x800) >> 12; এই পর্বের অনুশীলন ৪-এ এর প্রমাণ। x86-64-এর নির্দেশ দৈর্ঘ্যে পরিবর্তনশীল, তাই call-এর ভেতরেই পুরো ৩২ bit-এর দূরত্ব বসে, আর একটি relocation-ই যথেষ্ট। এ দুটি দুই নকশা-দর্শনের ফল: সরল decode বনাম ঘন কোড।

ভাগ করার দাম হলো কোডের আকার: প্রতিটি call দুই নির্দেশ (৮ byte), অথচ লক্ষ্য কাছে হলে একটি jal (±1 MiB পর্যন্ত) বা compressed নির্দেশই চলত। Compiler তা জানে না, কারণ ঠিকানা জানা যায় link-এর সময়। তাই RISC-V-এর toolchain linker relaxation ব্যবহার করে: compiler বা assembler জোড়ার পাশে R_RISCV_RELAX চিহ্ন দেয়, আর linker সম্ভব হলে জোড়া ছোট করে। সমস্যা হলো, একটি নির্দেশ ছোট হলে তার পরের সব কোড সরে যায়: অন্য সব symbol-এর ঠিকানা, branch-এর দূরত্ব, debug তথ্য সব আবার হিসাব করতে হয়, আর সরার ফলে আরও জোড়া কাছে এসে আবার ছোট হতে পারে। তাই linker বারবার pass চালায়। সাধারণ linker-এ “section-এর ভেতরে bytes স্থির” অনুমানটি এখানে ভাঙে।

এই পর্বের zig/Clang run-এর object-এ R_RISCV_RELAX ছিল না, তাই linked file-এ auipc আর jalr জোড়া অক্ষত (jalr ra, 140(ra)). এটি এই run-এর ডিফল্টের ফল; GNU toolchain-এ relaxation সাধারণত ডিফল্টে চালু থাকে বলে জানা যায়, আর -mno-relax দিয়ে বন্ধ করা যায়।

মূল উপলব্ধি: ISA-র একটি সরল নিয়ম (সব নির্দেশ ৩২ bit) জটিলতা মুছে দেয় না, linker-এর দিকে সরিয়ে দেয়; compiler লেখককে জানতে হয় কোন সিদ্ধান্ত কোন ধাপে নেওয়া যায়।

প্র ০৪C++-এর template আর inline function প্রতিটি ফাইলে আবার তৈরি হয়। তাহলে link-এর সময় “multiple definition” হয় না কেন, আর এই ব্যবস্থার ঝুঁকি কী?

C++-এ একটি header-এ লেখা inline function বা std::vector<int>-এর মতো template instantiation যতগুলো ফাইল ব্যবহার করে, ততগুলো .o-তে তার কোড তৈরি হয়। নিয়ম ৭৪.২ অনুযায়ী এটি multiple definition হওয়ার কথা। ELF toolchain এর সমাধান করে দুই উপায়ে: এমন সংজ্ঞাকে weak হিসেবে, আর সাধারণত আলাদা “COMDAT group”-এ রাখা হয়। COMDAT মানে: একই নামের group একাধিক ফাইলে এলে linker একটি রাখে, বাকিগুলো ফেলে দেয়। ফলে executable-এ একটিই কপি থাকে।

এর পেছনে C++-এর One Definition Rule (ODR): এমন প্রতিটি কপি হুবহু একই হতে হবে। কিন্তু linker তা যাচাই করে না; সে কেবল নাম দেখে একটি বেছে নেয়। দুটি ফাইল যদি একই নামের inline function ভিন্ন দেহে বানায় (যেমন ভিন্ন macro বা ভিন্ন compile flag-এর জন্য), linker নীরবে একটি রাখে, আর অন্য ফাইলের caller-রা ভুল কোড চালায়। এটি undefined behavior, আর এমন ভুল ধরা কঠিন: আউটপুট নির্ভর করে link-এর ক্রমের ওপর। কিছু toolchain-এ LTO বা বিশেষ বিশ্লেষণ চালু থাকলে এমন অমিলের কিছু অংশ ধরা পড়ে।

নামের দিকেও একই সমস্যা। Linker-এর symbol সমতল: overload করা price(int) আর price(double) আলাদা রাখতে C++ compiler নামের সঙ্গে parameter-এর type জুড়ে দেয় (Itanium C++ ABI-তে _Z5pricei-এর মতো)। Rust-এরও নিজস্ব mangling আছে। Generic কোডের কপি কীভাবে তৈরি হয় তা পর্ব ৩৭-এ, আর template-কে metaprogramming হিসেবে পর্ব ৭৮-এ; এখানে দেখার বিষয় হলো, ভাষার উচ্চ-স্তরের ধারণা শেষে linker-এর সরল নিয়মে নামিয়ে আনতে হয়।

মূল উপলব্ধি: Linker ভাষা বোঝে না, শুধু নাম মেলায়; ভাষা তার নিয়ম (ODR, overload, generic) নামের কৌশল আর weak/COMDAT দিয়ে linker-এর ভাষায় অনুবাদ করে, আর যা অনুবাদ হয় না তা যাচাইও হয় না।

প্র ০৫RELRO, BIND_NOW আর PIE-এর মতো ব্যবস্থা কেন এল? Linking-এর নকশা নিরাপত্তার সঙ্গে কীভাবে জড়িত?

Dynamic linking-এর GOT হলো লেখা যায় এমন মেমরিতে রাখা function-ঠিকানার টেবিল। কোনো program-এ memory-safety বাগ থাকলে (যেমন buffer overflow, Cybersecurity কোর্সের পর্ব ৪৭) আক্রমণকারী সেই টেবিলের একটি ঘর বদলে দিতে পারলে পরের call অন্য কোথাও যায়। আর program বা library প্রতিবার একই ঠিকানায় বসলে কোন ঘর কোথায়, তা আগে থেকেই জানা থাকে। প্রতিরক্ষার ব্যবস্থাগুলো এই দুই দুর্বলতা সরায়, আর সবগুলোই linker ও loader-এর নকশার অংশ।

RELRO (relocation read-only): dynamic linker কাজ শেষ করার পরে GOT-সহ relocation-এর লক্ষ্য অংশ শুধু-পড়ার করে দেওয়া হয়। Lazy binding থাকলে PLT-র GOT ঘরগুলো পরে লেখা লাগে, তাই সেগুলো খোলা রাখতে হয়; BIND_NOW দিলে সব ঘর শুরুতেই পূরণ হয়, আর পুরো অংশ বন্ধ করা যায় (“full RELRO”). এই পর্বের দুই run-এই (zig/lld আর Ubuntu-র GCC 13.3) ডিফল্টে BIND_NOW ছিল, আর bazar.so.exe-এ PT_GNU_RELRO segment-ও ছিল। PIE executable-কে প্রতিবার ভিন্ন ঠিকানায় বসাতে দেয়, ফলে ASLR program-এর নিজের কোডেও খাটে; দাম PIC কোডের সামান্য খরচ আর RELATIVE relocation-এর কাজ। Windows-এ একই ভূমিকায় ASLR-এর জন্য base relocation, আর আমদানির টেবিল সুরক্ষার নিজস্ব ব্যবস্থা।

আরেকটি বিষয় symbol interposition: ELF-এর নিয়মে এক library-র global function অন্য একটি আগে-লোড-হওয়া library বা executable-এর একই নামের function দিয়ে প্রতিস্থাপিত হতে পারে (LD_PRELOAD এর পরিচিত ব্যবহার, যা debugging আর মাপজোকে কাজে লাগে)। এর জন্য compiler shared library-র ভেতরের call-কেও সাধারণত PLT দিয়ে পাঠায়, যা inline করা আটকায়। -fvisibility=hidden দিয়ে শুধু দরকারি নাম বাইরে দেখালে, আর কিছু compiler-এর -fno-semantic-interposition-এর মতো option দিলে, কোড দ্রুত হয় আর বাইরের দিকের তলও ছোট হয়। খুঁটিনাটি compiler-ভেদে আলাদা; Operating Systems কোর্সের পর্ব ৩০-এ PIE আর ASLR-এর সত্যিকারের পরীক্ষা আছে।

মূল উপলব্ধি: নমনীয়তা (lazy binding, interposition, নির্দিষ্ট ঠিকানা) আর নিরাপত্তার মধ্যে আপস আছে; আধুনিক toolchain ডিফল্টে নিরাপদ দিকটি বেছে নিয়েছে, আর কোন ডিফল্ট চালু তা নিজের ফাইলে দেখে নেওয়াই ভালো অভ্যাস।

অনুশীলন

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

  1. নকশা ও বাস্তবায়ন — archive আর weak reference: অংশ ৪-এর খেলনা linker-এ দুটি জিনিস যোগ করুন, যাতে সেটি GNU ld-এর নিয়ম ৫ আর ৪ মানে: (ক) pull(objs, archive): archive-এর member শুধু তখন নেওয়া হবে, যখন সেটি কোনো strong undefined নামের সংজ্ঞা দেয়, fixpoint পর্যন্ত; (খ) object-এ weak_refs নামের একটি set থাকলে সেই নামের সংজ্ঞা না পেলে S = 0, error নয়। পরীক্ষা: একটি main.o, যা price, delivery, step strong আর coupon weak হিসেবে চায়; archive-এ shop2.o (shop.o, কিন্তু weak coupon ছাড়া) আর promo.o.
    def pull(objs, archive):                         # archive থেকে শুধু দরকারি member, fixpoint পর্যন্ত
        objs = list(objs)
        while True:
            have = {s for o in objs for s in o["defs"]}
            need = {r[2] for o in objs for r in o["relocs"]
                    if r[2] not in o.get("weak_refs", ())} - have   # weak reference টানে না
            new = [m for m in archive if m not in objs and need & set(m["defs"])]
            if not new: return objs
            objs += new
    
    # link()-এর relocation ধাপে একটি পরিবর্তন:
                if s in table: S = table[s][0]
                elif s in o.get("weak_refs", ()): S = 0      # weak reference, সংজ্ঞা নেই: 0
                else: raise ValueError(f"{o['name']}: undefined reference to '{s}'")

    লেখকের lab-এ সত্যিকারের run (main.o-র শেষে একটি a1 + abs32 নির্দেশ, offset 16-এ coupon):

    নেওয়া: ['main.o', 'shop2.o']
      main.o+1  PC32  price    S=0x1015 P=0x1001 -> 16
      main.o+6  PC32  delivery S=0x101b P=0x1006 -> 17
      main.o+11 ABS32 step     S=0x1030 P=0x100b -> 4144
      main.o+16 ABS32 coupon   S=0x0 P=0x1010 -> 0
      coupon -> নেই (0)
    নেওয়া: ['main.o', 'promo.o', 'shop2.o']
      main.o+1  PC32  price    S=0x101b P=0x1001 -> 22
      main.o+6  PC32  delivery S=0x1021 P=0x1006 -> 23
      main.o+11 ABS32 step     S=0x1030 P=0x100b -> 4144
      main.o+16 ABS32 coupon   S=0x1015 P=0x1010 -> 4117

    প্রথম link-এ archive থেকে শুধু shop2.o এল, promo.o নয়, আর coupon = 0: অংশ ৪-এর GNU ld run-এর ক্ষেত্র ১-এর সঙ্গে মেলে (coupon: -1). দ্বিতীয় link-এ promo.o সরাসরি দেওয়া, তাই coupon = 0x1015: ক্ষেত্র ৩-এর মতো। খেয়াল করুন, প্রথম খসড়ায় লেখক need-এ weak reference বাদ দিতে ভুলে গিয়েছিলেন; তখন promo.o-ও টানা হচ্ছিল, যা GNU ld করে না। এমন ভুল ধরা পড়ে শুধু সত্যিকারের linker-এর সঙ্গে মিলিয়ে দেখলে।

  2. ভুল খুঁজুন: একজন সহকর্মী নিজের ছোট RISC-V linker-এ R_RISCV_HI20/LO12_I এভাবে লিখেছেন: hi = S >> 12, lo = S & 0xfff. তাঁর test program-এর string .L.str (S = 0x1000208) ঠিক ছাপে, কিন্তু step (S = 0x1008d88) পড়লে ভুল মান আসে। কেন? কোন ঠিকানায় ভুল হবে, আর কোথায় হবে না?

    ১২ bit-এর ক্ষেত্র চিহ্নসহ পড়া হয়। .L.str-এ lo = 0x208 = 520, যার bit 11 শূন্য, তাই চিহ্নসহ পড়লেও 520: ঠিকানা 0x1000000 + 520 = 0x1000208, সঠিক। step-এ lo = 0xd88, bit 11 এক, তাই CPU পড়ে 0xd88 − 4096 = −632: ঠিকানা 0x1008000 − 632 = 0x1007d88, আসলের চেয়ে 4096 কম। ld তাই ভুল জায়গা থেকে পড়ে। সাধারণ নিয়ম: S-এর bit 11 এক হলে (S mod 4096 ≥ 2048) সরল ভাগ ঠিক 4096 কম ঠিকানা দেয়; নইলে ঠিক থাকে। লেখকের lab-এ main.o-র ১৭টি relocation-এ সরল ভাগ চালিয়ে linked file-এর সঙ্গে মেলানো হয়েছে: ১৪টি মেলে, ৩টি মেলে না, আর সেই তিনটিই step আর rounds-এর HI20 (offset 0x48, 0x4c, 0x66). LO12-এর bytes দুই পদ্ধতিতে একই, কারণ 0xd88 আর −632 একই ১২ bit; ভুলটি আসলে ওপরের ভাগে, যেখানে একটি বাড়তি 1 লাগত। সংশোধন: hi = (S + 0x800) >> 12, lo = S − (hi << 12). Test-এর শিক্ষা: শুধু “একটি ঠিকানায় কাজ করে” যথেষ্ট নয়; bit 11 এক আর শূন্য, দুই রকম ঠিকানাই রাখুন।

  3. হিসাব ও trace: (ক) x86-64 musl main.o-তে price-এর দ্বিতীয় call-এর relocation R_X86_64_PLT32 price − 4, offset 0x23. Link-এর পরে main = 0x10027c0, price = 0x1002900. Call-এর পাঁচ byte কী হবে? (খ) RISC-V main.o-তে printf-এর প্রথম call R_RISCV_CALL_PLT, offset 0x3e; main = 0x1002c00, printf = 0x1003240. hi20, lo12 কত, আর jalr-এর ৪ byte কী? (গ) gcc libshop.a main.o -o a2 (price শুধু libshop.a-তে) কী দেবে?

    (ক) P = 0x10027c0 + 0x23 = 0x10027e3. মান = S + A − P = 0x1002900 − 4 − 0x10027e3 = 281 = 0x119. Little-endian-এ: e8 19 01 00 00. লেখকের lab-এ linked bazar.x86-এর ওই জায়গায় সত্যিই এই bytes, আর একইভাবে delivery-র call (offset 0x2b) পায় 321.

    (খ) P = 0x1002c3e, S − P = 0x602 = 1538. hi20 = (1538 + 0x800) >> 12 = 0 (কারণ 1538 + 2048 = 3586 < 4096), lo12 = 1538, যা 2047-এর নিচে, তাই আঁটে। auipc ra, 0 অপরিবর্তিত (97 00 00 00); jalr ra, 1538(ra): imm 0x602 bit 31–20-এ, তাই word 0x602080e7, bytes e7 80 20 60. Linked bazar.rv-এ হুবহু এই bytes.

    (গ) Error: undefined reference to `price' (আর delivery), কারণ archive পড়ার সময় কেউ কিছু চায়নি (নিয়ম ৬)। অংশ ৪-এর Wandbox run-এর ক্ষেত্র ২ ঠিক এটিই দেখিয়েছে, main.o-র relocation-এর offset-সহ।

  4. প্রমাণ — hi20/lo12 ভাগ সবসময় কাজ করে: প্রমাণ করুন: যেকোনো পূর্ণসংখ্যা v-এর জন্য hi = ⌊(v + 2048) / 4096⌋ আর lo = v − 4096·hi নিলে (১) −2048 ≤ lo ≤ 2047, অর্থাৎ lo চিহ্নসহ ১২ bit-এ আঁটে; আর (২) 4096·hi + lo = v. তারপর বলুন RV64-এ lui-এর কোন ধর্মের জন্য এই কৌশল শুধু একটি নির্দিষ্ট ঠিকানা-পরিসরে সরাসরি খাটে।
    1. Floor-এর সংজ্ঞা: 4096·hi ≤ v + 2048 < 4096·hi + 4096.
    2. সবখানে থেকে 4096·hi + 2048 বিয়োগ করুন: −2048 ≤ v − 4096·hi < 2048, অর্থাৎ −2048 ≤ lo ≤ 2047 (পূর্ণসংখ্যা বলে). এটি চিহ্নসহ ১২ bit-এর পরিসর ঠিক।
    3. lo-এর সংজ্ঞা থেকেই 4096·hi + lo = v. আর arithmetic shift-এ (v + 0x800) >> 12 = ⌊(v + 2048) / 4096⌋, তাই কোডের সূত্র এই প্রমাণেরই রূপ। ∎

    lui-এর সীমা: RV64-এ lui ২০ bit-কে 12 bit বাঁয়ে সরিয়ে ৩২ bit-এর মান বানায়, তারপর bit 31 থেকে sign-extend করে ৬৪ bit বানায়। তাই lui + addi দিয়ে সরাসরি পাওয়া যায় শুধু এমন পরম ঠিকানা, যা চিহ্নসহ ৩২ bit-এর পরিসরে (মোটামুটি −2 GiB থেকে +2 GiB); psABI-র “medlow” code model এই কারণে ধরে নেয় program নিচের ২ GiB-এ থাকবে। বড় program-এর জন্য “medany” model, যেখানে auipc দিয়ে PC থেকে ±2 GiB দূরত্বে। লেখকের lab-এ সূত্রটি −231 থেকে 231 − 1 পরিসরের দশ লাখ এলোমেলো মান আর সব সীমার মানে যাচাই করা হয়েছে: সব ক্ষেত্রে lo পরিসরে আর hi·4096 + lo = v.

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

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

ক্রমদুটি C ফাইল থেকে static executable বানিয়ে চালানো পর্যন্ত ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. প্রতিটি ফাইল আলাদা compile আর assemble করে object file
  2. Linker-এর symbol resolution: প্রতিটি undefined নামের সংজ্ঞা খোঁজা
  3. Section জোড়া লাগিয়ে প্রতিটি symbol-এর চূড়ান্ত ঠিকানা ঠিক করা
  4. প্রতিটি relocation entry-তে হিসাব করা bytes লেখা
  5. Kernel program header দেখে segment মেমরিতে বসায়
  6. _start থেকে libc হয়ে main ডাকা

x86-64-এ call-এর relocation R_X86_64_PLT32 price − 4. Link-এর পরে চার byte-এর ক্ষেত্রটির ঠিকানা P = 0x10027d1 আর price = 0x1002900. ক্ষেত্রে কোন সংখ্যা বসবে?

  • 299
  • 303
  • 0x1002900
  • −299

RISC-V-এ একটি global variable-এর ঠিকানা S = 0x1008d88, যা lui আর ld-এর জোড়ায় (R_RISCV_HI20, R_RISCV_LO12_I) বসবে। কোন জোড়া সঠিক?

  • hi20 = 0x1008, lo12 = 0xd88 (3464)
  • hi20 = 0x1008, lo12 = −632
  • hi20 = 0x1009, lo12 = −632
  • hi20 = 0x1009, lo12 = 3464

GNU ld-এ gcc libshop.a main.o -o app চালানো হলো, আর price-এর সংজ্ঞা শুধু libshop.a-র একটি member-এ। কী ঘটবে?

  • ঠিকমতো link হবে, ক্রম গুরুত্বহীন
  • undefined reference to `price'
  • multiple definition of `price'
  • price-এর ঠিকানা 0 বসবে

একটি C ফাইলে long coupon(long) __attribute__((weak)); ঘোষিত, কিন্তু static link-এ কোনো ফাইলে coupon-এর সংজ্ঞা নেই। Link-এর ফল কী?

  • undefined reference error
  • Linker libc থেকে একটি coupon খুঁজে আনবে
  • Linker একটি খালি function বানাবে
  • Link সফল, আর coupon-এর ঠিকানা 0

একটি ELF executable-এর একটি PT_LOAD segment-এ filesz = 0xfc আর memsz = 0x740. বাড়তি 0x644 byte কী?

  • Heap-এর জন্য রাখা জায়গা
  • .bss, যা loader শূন্য দিয়ে ভরে
  • Stack
  • Relocation entry-গুলো

Shared library-র কোড সাধারণত position-independent (PIC) হিসেবে compile করা হয়, আর বাইরের variable-এর ঠিকানা GOT থেকে পড়ে। মূল কারণ কোনটি?

  • PIC কোড সবসময় দ্রুত চলে
  • CPU GOT ছাড়া memory পড়তে পারে না
  • Library যেকোনো ঠিকানায় বসলেও কোড না বদলে চলবে, আর কোডের পাতা ভাগ করা যাবে
  • C++-এর name mangling-এর জন্য

দুটি C ফাইল -flto দিয়ে compile করা হলো। এক ফাইলের main অন্য ফাইলের ছোট function price ডাকে। LTO-র আগে আর পরে কী বদলাতে পারে?

  • price main-এর ভেতরে inline হতে পারে, আর তার symbol হারিয়ে যেতে পারে
  • Program-এর আউটপুট বদলে যাবে
  • .o ফাইলে বেশি machine code থাকবে
  • Link আগের চেয়ে দ্রুত হবে

শব্দকোষ

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

মনে রাখুন

  1. Object file: section (.text, .data, .bss, .rodata), symbol (global, local, weak, undefined) আর relocation entry (offset, type, symbol, addend).
  2. Relocation: পরম ঠিকানা S + A, PC-relative S + A − P; RISC-V-এ ঠিকানা দুই ভাগে, hi20 = (S + 0x800) >> 12.
  3. Static linker: symbol resolution (strong জেতে, দুটি strong error, সংজ্ঞাহীন weak = 0), archive থেকে শুধু দরকারি member, ক্রমে; তারপর layout আর relocation.
  4. Dynamic: PIC কোড, GOT-এ ঠিকানা, PLT দিয়ে call; GLOB_DAT, JUMP_SLOT, COPY relocation dynamic linker-এর জন্য; BIND_NOW অনেক toolchain-এর ডিফল্ট।
  5. Loader আর LTO: kernel PT_LOAD বসায় (.bss শূন্য), e_entry = _start → libc → main; LTO-তে linker পুরো program-এর IR optimize করে।

পরের পর্বে: পর্ব ৭৫ (Garbage collection — reference counting, mark-sweep, copying আর generational). এই পর্বে .data আর .bss-এর global গুলো program-এর পুরো জীবন বাঁচে; heap-এ তৈরি Haat-এর closure আর string কখন মুছবে, সেটি runtime-এর প্রশ্ন।

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

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