এই পর্বে যা শিখবেন
- 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-এর কাছ থেকে কী আশা করে।
একটি 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) |
|---|---|---|
.text | machine 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, .strtab | symbol-এর তালিকা আর তাদের নাম | নিচের reader-এ |
.rela.text | .text-এর relocation entry | 17টি |
একটি 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 থেকে
.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
| S | |
| hi20 | |
| lo12 | |
| +0x48 | |
| +0x50 |
- Link-এর আগে।
lui a0, 0আরld a2, 0(a0): দুটিতেই ঠিকানার জায়গা শূন্য। Relocation দুটি বলে, 0x48-এর নির্দেশেstep-এর ওপরের ভাগ, 0x50-এর নির্দেশে নিচের ভাগ বসবে। - S জানা গেল। Linker
shop.o-র.data-কে executable-এর.data-র শুরুতে বসিয়েছে, তাইstep= 0x1008d88. এবার শুধু ভাগ করা বাকি। - সরল ভাগ, আর তার ভুল। ওপরের ২০ bit 0x1008, নিচের ১২ bit 0xd88 = 3464. কিন্তু ১২ bit-এর ক্ষেত্র চিহ্নসহ: 0xd88-এর সবচেয়ে বড় bit 1, তাই CPU পড়ে −632. ঠিকানা হতো 0x1008000 − 632 = 0x1007d88, আসলের চেয়ে ৪০৯৬ কম।
- সংশোধন: 0x800 যোগ। hi = (0x1008d88 + 0x800) >> 12 = 0x1009. নিচের ভাগ ঋণাত্মক হবে জেনে ওপরের ভাগ একটি বাড়ানো হলো।
lui a0, 0x1009-এর bytes37 95 00 01. - নিচের ভাগ। lo = 0x1008d88 − 0x1009000 = −632, যা ১২ bit-এ 0xd88.
ld-এর imm ক্ষেত্রে (bit 31–20) বসে:03 36 85 d8, অর্থাৎld a2, -632(a0). - যাচাই। 0x1009000 − 632 = 0x1008d88. লেখকের lab-এ
pyelftoolsদিয়ে পড়া linkedbazar.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
| সংজ্ঞা | |
| U | |
| weak U |
- crt1.o.
_startআর_start_cসংজ্ঞায়িত। এটিmainআর__libc_start_mainচায়, আর weak হিসেবে_DYNAMIC,_init,_fini. তাই আপনার program-এmainনা থাকলে error আসে startup code থেকে, আপনার ফাইল থেকে নয়। - main.o.
mainসংজ্ঞায়িত, U থেকে সরল। নতুন চাওয়া:price,delivery,printf,step.roundslocal, তাই নাম মেলানোয় অংশ নেয় না: অন্য ফাইলে আরেকটিstatic roundsথাকলেও সংঘাত নেই। - shop.o.
price,delivery,stepমিলে গেল। বাকি শুধু libc-এর দুই নাম। - libc-এর archive. Static library (
.a) অনেক.o-র একটি বান্ডিল; এই run-এর RISC-V musllibc.a-তে ১,০৫৪টি member. Linker শুধু সেই member নেয়, যা বর্তমান U-র কোনো নামের সংজ্ঞা দেয়। নেওয়া member নিজেও নতুন নাম চাইতে পারে, তাই U খালি না হওয়া পর্যন্ত বারবার। - Weak.
_initআর_fini-এর weak সংজ্ঞা libc-এ ছিল।_DYNAMIC-এর সংজ্ঞা কোথাও নেই (static program-এ dynamic section থাকে না); weak undefined হলে error নয়, ঠিকানা 0. Executable-এর symbol table-এ সত্যিই_DYNAMIC= 0. - এবার layout আর relocation. সব নাম মিলেছে, তাই section বসানো আর অংশ ৩-এর হিসাব। কোনো U বাকি থাকলে এখানেই থামত “undefined reference” দিয়ে।
(১) দুটি 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 | |
| ঘটনা |
- execve. Kernel ফাইলের প্রথম ৬৪ byte পড়ে: magic ঠিক,
ET_EXEC, যন্ত্র RISC-V,e_entry= 0x1002ba8. কোনো PT_INTERP নেই, তাই কোনো dynamic linker লাগবে না (static). - Program header. তিনটি PT_LOAD: শুধু-পড়া 0x1000000 (0x1ba8 byte: header,
.rodata), পড়া-চালানো 0x1002ba8 (0x51e0 byte:.text), পড়া-লেখা 0x1008d88 (ফাইলে 0xfc byte, মেমরিতে 0x740). - Map আর stack. শেষ segment-এর memsz − filesz = 0x644 byte ফাইলে নেই: এটিই
.bss(rounds0x1008e88-এ), যা শূন্য দিয়ে ভরা হয়। Kernel stack-এ argc, argv, environment আর auxiliary vector রাখে। - _start (assembly).
gp-তে__global_pointer$(0x1000800),a0-তে stack pointer,a1-তে&_DYNAMIC: weak undefined বলে 0. তারপর_start_c-তে tail call (jalr x0, ফেরার ঠিকানা ছাড়া)। - _start_c (C). Stack থেকে argc আর argv বের করে,
a0-তেmain-এর ঠিকানা (0x1002c00),a3,a4-তে_init,_fini; তারপর__libc_start_main-এ tail call.mainএখানে ডাকা হয় না, ঠিকানা হিসেবে পাঠানো হয়। - __libc_start_main.
__init_libc(environment, auxv, thread-এর তথ্য), তারপর পরের ধাপে constructor চালানো (libc_start_init). - main. musl-এর source অনুযায়ী এখানে
exit(main(argc, argv, envp)): পাঠানো ঠিকানা দিয়েmainডাকা হয়।price,delivery,printfচলে, আউটপুট996,5000,3. - exit(0).
main০ ফেরত দিলেexitbuffer-এ জমা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-এর
printInt, 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-এর Cmainসেটি ডাকবে। বাকিটা এই পর্বের ধাপ ৬-এর মতোই:_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-কে কাজে লাগাতে প্রসঙ্গ আর যাচাইয়ের পথ নিজেই বলে দিন:
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 দিয়ে যাচাই করা।
-
নকশা ও বাস্তবায়ন — 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,stepstrong আরcouponweak হিসেবে চায়; archive-এshop2.o(shop.o, কিন্তু weakcouponছাড়া) আর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-এর সঙ্গে মিলিয়ে দেখলে। -
ভুল খুঁজুন: একজন সহকর্মী নিজের ছোট 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 এক আর শূন্য, দুই রকম ঠিকানাই রাখুন। -
হিসাব ও trace: (ক) x86-64 musl
main.o-তেprice-এর দ্বিতীয় call-এর relocationR_X86_64_PLT32 price − 4, offset 0x23. Link-এর পরেmain= 0x10027c0,price= 0x1002900. Call-এর পাঁচ byte কী হবে? (খ) RISC-Vmain.o-তেprintf-এর প্রথম callR_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-এ linkedbazar.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, bytese7 80 20 60. Linkedbazar.rv-এ হুবহু এই bytes.(গ) Error:
undefined reference to `price'(আরdelivery), কারণ archive পড়ার সময় কেউ কিছু চায়নি (নিয়ম ৬)। অংশ ৪-এর Wandbox run-এর ক্ষেত্র ২ ঠিক এটিই দেখিয়েছে,main.o-র relocation-এর offset-সহ। -
প্রমাণ — hi20/lo12 ভাগ সবসময় কাজ করে: প্রমাণ করুন: যেকোনো পূর্ণসংখ্যা v-এর জন্য hi = ⌊(v + 2048) / 4096⌋ আর lo = v − 4096·hi নিলে (১) −2048 ≤ lo ≤ 2047, অর্থাৎ lo চিহ্নসহ ১২ bit-এ আঁটে; আর (২) 4096·hi + lo = v. তারপর বলুন RV64-এ
lui-এর কোন ধর্মের জন্য এই কৌশল শুধু একটি নির্দিষ্ট ঠিকানা-পরিসরে সরাসরি খাটে।- Floor-এর সংজ্ঞা: 4096·hi ≤ v + 2048 < 4096·hi + 4096.
- সবখানে থেকে 4096·hi + 2048 বিয়োগ করুন: −2048 ≤ v − 4096·hi < 2048, অর্থাৎ −2048 ≤ lo ≤ 2047 (পূর্ণসংখ্যা বলে). এটি চিহ্নসহ ১২ bit-এর পরিসর ঠিক।
- 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 বানিয়ে চালানো পর্যন্ত ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)
- প্রতিটি ফাইল আলাদা compile আর assemble করে object file
- Linker-এর symbol resolution: প্রতিটি undefined নামের সংজ্ঞা খোঁজা
- Section জোড়া লাগিয়ে প্রতিটি symbol-এর চূড়ান্ত ঠিকানা ঠিক করা
- প্রতিটি relocation entry-তে হিসাব করা bytes লেখা
- Kernel program header দেখে segment মেমরিতে বসায়
_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 আগের চেয়ে দ্রুত হবে
শব্দকোষ
লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:
মনে রাখুন
- Object file: section (
.text,.data,.bss,.rodata), symbol (global, local, weak, undefined) আর relocation entry (offset, type, symbol, addend). - Relocation: পরম ঠিকানা S + A, PC-relative S + A − P; RISC-V-এ ঠিকানা দুই ভাগে, hi20 = (S + 0x800) >> 12.
- Static linker: symbol resolution (strong জেতে, দুটি strong error, সংজ্ঞাহীন weak = 0), archive থেকে শুধু দরকারি member, ক্রমে; তারপর layout আর relocation.
- Dynamic: PIC কোড, GOT-এ ঠিকানা, PLT দিয়ে call; GLOB_DAT, JUMP_SLOT, COPY relocation dynamic linker-এর জন্য; BIND_NOW অনেক toolchain-এর ডিফল্ট।
- Loader আর LTO: kernel PT_LOAD বসায় (
.bssশূন্য),e_entry=_start→ libc →main; LTO-তে linker পুরো program-এর IR optimize করে।
আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ
- পর্ব ৭৫ · Garbage collection — reference counting, mark-sweep, copying আর generationalপরবর্তী পর্বRuntime-এর আরেক অংশ: heap-এর মেমরি ফেরত নেওয়া।
- প্রোগ্রামিং ভাষা ও কম্পাইলার · কোর্স হোম৮৬টি পর্বপুরো কোর্সের মানচিত্র আর Haat প্রজেক্টের পথ।
- পর্ব ০৫ · Compiler-এর ধাপগুলোএই কোর্সেSource থেকে executable: এই পর্বের ধাপগুলোর জায়গা পুরো pipeline-এ।
- Operating Systems · পর্ব ৩০পাশের ট্র্যাকPLT, GOT, lazy binding, dlopen আর ASLR, OS-এর চোখে।
- C প্রোগ্রামিং · পর্ব ২৯পাশের ট্র্যাকHeader, library আর Make: বহু ফাইলের C প্রকল্প।
- Full-Stack · পর্ব ৭৯পাশের ট্র্যাকJavaScript-এর bundler: web-এর জগতে linker-এর আত্মীয়।