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

Cross-compilation আর build — compiler, linker, map file আর binary

Cross-Compilation and Build — Host vs Target, Target Triples, Object Files, Linking, Map Files, ELF to BIN/HEX, Makefiles and Reproducible Builds

Taught in Bangla, this lesson follows one file through a real Clang 22 and ld.lld cross-build for thumbv7m-none-eabi: preprocessing (7 lines to 90), Thumb-2 assembly, an 828-byte object with symbols and relocations, and linking. It reproduces an undefined-symbol link error and the patched BL bytes, reads the map file for sizes, converts ELF to .bin and Intel HEX with objcopy (1204 bytes, or 384 MiB with a wrong .data LMA), and builds with a Makefile, a host-side unit test and a reproducible-build check.

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

  • Host আর target-এর পার্থক্য, target triple আর -mcpu দিয়ে compiler-কে ঠিক chip চেনানো
  • একটি firmware ফাইলকে preprocess, compile, assemble আর link-এর ভেতর দিয়ে নিয়ে প্রতিটি ধাপের আসল ফল পড়া
  • Object file-এর section, symbol আর relocation, আর undefined বা duplicate symbol-এর link error সারানো
  • Map file থেকে flash আর SRAM-এর খরচ, আর ELF থেকে .bin ও Intel HEX বানানো ও যাচাই
  • Makefile বা build script দিয়ে incremental build, আর reproducible build-এর শর্ত

১ · Host আর target — অন্যের মাপে জামা সেলাই

আপনার ল্যাপটপে লেখা C program সাধারণত সেই ল্যাপটপেই চলে। Compiler যে CPU-তে চলছে, তার জন্যই machine code বানায়। Microcontroller-এর জগতে তা হয় না। বাজারঘরের smart scale-এর Cortex-M3 chip-এ মাত্র 128 KiB flash আর 20 KiB SRAM; সেখানে compiler, editor বা operating system বসানোর জায়গাই নেই। তাই firmware বানানো হয় একটি বড় কম্পিউটারে, আর চলে ছোট chip-এ। এই কাজের নাম cross-compilation, আর যে compiler এটি করে সে cross-compiler.

উপমা — মিরপুরের দর্জি আর প্রবাসী ক্রেতা: মিরপুরের এক দর্জি দুবাইয়ে থাকা এক ভাইয়ের জন্য পাঞ্জাবি বানাচ্ছেন। ক্রেতা সামনে নেই, তাই গায়ে দিয়ে মাপ মেলানোর উপায় নেই। দর্জির ভরসা একটি মাপের কাগজ: বুক, কাঁধ, লম্বা। দোকানটি হলো host (আপনার PC), ক্রেতা হলো target (Cortex-M3), আর মাপের কাগজটি target triple ও -mcpu. কাগজে একটি সংখ্যা ভুল হলে পাঞ্জাবি দোকানে দেখতে নিখুঁত লাগবে, কিন্তু ক্রেতার গায়ে উঠবে না। Firmware-এর ক্ষেত্রেও ভুল flag দিলে build সফল হয়, কিন্তু chip-এ চলে না।

C-র সাধারণ toolchain-এর চার ধাপ (preprocess, compile, assemble, link) আপনি C কোর্সের পর্ব ০৩-এ (C-র টুলচেইন) দেখেছেন, আর compiler-এর ভেতরের পথ Programming Languages কোর্সের পর্ব ০৫-এ (compiler pipeline). এখানে সেগুলো আবার শেখানো হবে না। এই পর্বের প্রশ্ন একটাই: target যখন অন্য একটি chip, তখন প্রতিটি ধাপে কী বদলায়, আর কোন ভুল শুধু embedded কাজেই দেখা দেয়।

বিষয়Host (এই lab-এর PC)Target (বাজারঘর board BG-M3)
CPU আর instruction setx86-64ARM Cortex-M3, Thumb-2
Operating systemWindowsনেই, bare metal
Memoryকয়েক GBflash 128 KiB, SRAM 20 KiB
pointer-এর মাপ8 byte4 byte
Program কীভাবে চলেসরাসরি চালানো যায়flash-এ লিখে, বা simulator-এ

লেখার নিয়ম আর lab: এই পর্বে hex লেখা হবে C-র ধাঁচে, 0x দিয়ে: 0x08000000. সব command আর output নিজের lab-এ আসল run থেকে নেওয়া: Clang 22.1.8 আর LLD 22.1.8 (PyPI-র ziglang 0.17.1; Zig MIT, LLVM অংশ Apache-2.0 with LLVM exception), চালানো কোর্সের virtual বাজারঘর board BG-M3-এ (Unicorn 2.1.4; binding BSD, engine GPLv2). BG-M3 কোনো আসল পণ্য নয়, আসল Cortex-M3 chip-এর আদলে বানানো শেখার মডেল (পর্ব ০৬)। Lab-এ clang মানে python -m ziglang clang, ld.lld মানে python -m ziglang ld.lld; Zig-এর cache ফোল্ডার lab-এর ভেতরে রাখা হয়েছে।

Host-এর compiler নিজেই বলে দেয় সে কোন target-এর জন্য বানায়, যদি কিছু বলা না হয়। আর কোনো triple দিলে তা পূর্ণ রূপে লিখে দেখায় (সত্যিকারের run):

~/lab/xbuild $ clang --version | head -2
clang version 22.1.8
Target: x86_64-unknown-windows-gnu
~/lab/xbuild $ clang --target=thumbv7m-none-eabi -print-target-triple
thumbv7m-unknown-none-eabi

প্রথম উত্তর: কিছু না বললে এই Clang Windows-এর x86-64 program বানাত। দ্বিতীয়টি পরের অংশের বিষয়।

একটি শব্দের দুই অর্থ নিয়ে সাবধান থাকুন। Firmware-এর আলোচনায় “host” মানে যে কম্পিউটারে build হয়, আর “target” মানে chip. কিন্তু GNU-র পুরোনো build-ব্যবস্থায় (যেমন GCC নিজে compile করার সময়) তিনটি শব্দ আছে: build (যে মেশিনে compiler-টি বানানো হচ্ছে), host (যে মেশিনে সেই compiler চলবে) আর target (যার জন্য সে কোড বানাবে)। আমাদের ক্ষেত্রে প্রথম দুটি একই PC, তাই দুটি শব্দেই কাজ চলে। কোনো লেখায় “host” পড়লে প্রসঙ্গ দেখে বুঝে নিন কোন অর্থে বলা।

২ · Target triple আর -mcpu — compiler-কে ঠিক chip চেনানো

Target triple একটি ছোট নাম, যার প্রতিটি অংশ একটি প্রশ্নের উত্তর। thumbv7m-none-eabi-কে Clang পূর্ণ রূপে লিখল thumbv7m-unknown-none-eabi: চারটি অংশ।

অংশমানমানে
architecturethumbv7mARMv7-M স্থাপত্য, Thumb instruction (Thumb-2) চলবে
vendorunknownকোনো নির্দিষ্ট নির্মাতার বিশেষ নিয়ম নেই
OSnoneoperating system নেই, firmware নিজেই সব
environment/ABIeabiARM-এর embedded ABI (EABI) মেনে function ডাকা আর ডেটা সাজানো

Triple বলে পরিবার; -mcpu=cortex-m3 বলে পরিবারের ঠিক কোন সদস্য, যাতে compiler সেই core-এর instruction আর timing-এর অভ্যাস ধরে কোড বানায়। Reference lab-এর build আরও কয়েকটি flag দেয়, প্রত্যেকটির একটি কাজ আছে:

CFLAGS = --target=thumbv7m-none-eabi -mcpu=cortex-m3 -mthumb -mfloat-abi=soft
         -ffreestanding -nostdlib -O2 -std=c11 -Wall -Wextra
         -ffunction-sections -fdata-sections -fno-unwind-tables
         -fno-asynchronous-unwind-tables -fno-sanitize=undefined

-mfloat-abi=soft: Cortex-M3-এ FPU নেই, তাই float-এর হিসাব library function-এ। -ffreestanding: freestanding পরিবেশ, অর্থাৎ OS আর পূর্ণ C library ধরে নেওয়া চলবে না (embedded C-র এই দিকগুলো পর্ব ৩৪-এ)। -nostdlib: link-এ কোনো standard library বা startup ফাইল আপনা থেকে যোগ হবে না; startup কোড আমাদের নিজের startup.c. -ffunction-sections -fdata-sections: প্রতিটি function আর variable আলাদা section পায়, যাতে linker অব্যবহৃতগুলো ফেলে দিতে পারে (অংশ ৬)। শেষ flag-টি এই কোর্সের lab-এর নিয়ম; এখানে কোনো sanitizer চালু নেই, তাই output বদলায় না।

Compiler target ধরে কিছু predefined macro নিজে থেকেই দেয়। একই খালি ফাইলে clang ... -dM -E চালিয়ে চারটি target-এর বাছাই করা macro (সত্যিকারের run):

MacroCortex-M3
thumbv7m
Cortex-M0
thumbv6m
Cortex-M4F
thumbv7em…hf
x86-64 Linux
__ARM_ARCH767নেই
__ARM_FEATURE_IDIV1নেই1নেই
__thumb2__1নেই1নেই
__SOFTFP__ / __ARM_FPsoftsoft__ARM_FP 0x6—
__SIZEOF_LONG__4448
__SIZEOF_POINTER__4448

M4F-এর জন্য flag ছিল --target=thumbv7em-none-eabihf -mcpu=cortex-m4 -mfloat-abi=hard -mfpu=fpv4-sp-d16. সবচেয়ে কাজের সারি __ARM_FEATURE_IDIV: Cortex-M0-এর ARMv6-M স্থাপত্যে ভাগের hardware instruction নেই। এর ফল অংশ ৫-এ link error হয়ে দেখা দেবে।

Cross-compilation-এর প্রথম ধাক্কা প্রায়ই আসে header-এ। Reference lab-এর board.py যে -isystem পথটি দেয়, সেটি বাদ দিয়ে চালালে (সত্যিকারের run):

In file included from price.c:2:
./price.h:5:10: fatal error: 'stdint.h' file not found
    5 | #include <stdint.h>

Host-এর C library-র header target-এর জন্য চলে না, আর none OS-এর কোনো C library এই lab-এ নেই। stdint.h-এর মতো freestanding header compiler নিজেই দেয়; এই ziglang-এর Clang সেগুলো lib/include ফোল্ডারে রাখে, তবে সরাসরি চালালে নিজে খুঁজে পায়নি। তাই build-এ -isystem <ziglang>/lib/include দিতে হয়। পূর্ণ toolchain-এ এই কাজটি করে sysroot: target-এর header আর library যে ফোল্ডারে সাজানো থাকে। এরপর থেকে command-এ এই পথ $ZINC নামে লেখা হবে।

৩ · চার ধাপ, একটি ফাইল — price.c-এর যাত্রা

এই পর্বের firmware ইচ্ছে করে ছোট রাখা হয়েছে, যাতে প্রতিটি ধাপ চোখে দেখা যায়। বাজারঘরের smart scale-এর দামের হিসাব আলাদা ফাইলে, reference lab-এর README-র নির্ধারিত সূত্রে: দাম (paisa) = (নিট গ্রাম × 6550 + 500) ÷ 1000, integer-এ।

/* price.h - bazarghar smart scale: price in integer paisa */
#ifndef PRICE_H
#define PRICE_H
#include <stdint.h>
#define RATE_PAISA_PER_KG 6550u          /* 65.50 Tk per kg */
uint32_t price_paisa(uint32_t net_g);
#endif

/* price.c - net weight in grams -> price in paisa, round half up */
#include "price.h"

uint32_t price_paisa(uint32_t net_g)
{
    return (net_g * RATE_PAISA_PER_KG + 500u) / 1000u;
}

আর main.c তিনটি ওজনের দাম UART-এ ছাপে। Board-এর bazarghar.h, bglib.h আর startup.c reference lab থেকে নিজের lab-এ কপি করা, বদলানো হয়নি:

#include "bazarghar.h"
#include "bglib.h"
#include "price.h"

char shop_name[] = "BazarGhar";            /* not const: lives in .data */
static const uint32_t loads_g[3] = {150, 1250, 500};

int main(void)
{
    uart_init();
    uart_puts(shop_name);
    uart_puts(" scale\r\n");
    for (int i = 0; i < 3; i++) {
        uart_put_u32(loads_g[i]);
        uart_puts(" g -> ");
        uart_put_fixed2((int32_t)price_paisa(loads_g[i]));
        uart_puts(" Tk\r\n");
    }
    board_exit(0);
}

ধাপ ১, preprocess (-E). Preprocessor #include করা ফাইলের লেখা এনে বসায় আর macro-র নাম বদলে দেয় (সত্যিকারের run):

~/lab/xbuild $ clang $CFLAGS -isystem $ZINC -E price.c -o price.i
~/lab/xbuild $ wc -l price.c price.i main.c main.i
   7 price.c
  90 price.i
  21 main.c
 265 main.i
~/lab/xbuild $ grep -v '^#' price.i | grep -v '^\s*$' | tail -5
uint32_t price_paisa(uint32_t net_g);
uint32_t price_paisa(uint32_t net_g)
{
    return (net_g * 6550u + 500u) / 1000u;
}

RATE_PAISA_PER_KG নামটি আর নেই, জায়গায় 6550u. বাকি ৮০-এর বেশি লাইন এসেছে stdint.h থেকে: target-এর uint32_t কী, তা এখানেই ঠিক হয়। main.i-তে board-এর header-এর macro-ও খুলেছে: board_exit()-এর ভেতরের SIMCTRL->EXIT হয়ে গেছে ((SIMCTRL_TypeDef *)0x400FF000u)->EXIT; register-কে struct আর pointer দিয়ে ছোঁয়ার এই কৌশল পর্ব ৩৬-এ (C-তে memory-mapped register). এই পুরো লেখাটিই একটি translation unit, compiler একবারে যা দেখে।

ধাপ ২, compile (-S). Compiler C থেকে target-এর assembly লেখে। Cortex-M3-এর জন্য price_paisa (সত্যিকারের run, -O2):

~/lab/xbuild $ clang $CFLAGS -isystem $ZINC -S price.c -o price.s
price_paisa:
	movw	r1, #6550
	muls	r0, r1, r0
	movw	r1, #19923
	add.w	r0, r0, #500
	movt	r1, #4194
	umull	r0, r1, r0, r1
	lsrs	r0, r1, #6
	bx	lr

আটটি instruction, কোনো ভাগের instruction নেই। 1000 দিয়ে ভাগকে compiler একটি গুণ আর shift-এ বদলেছে: movw/movt মিলে r1 = 4194 × 65536 + 19923 = 0x10624DD3, umull ৬৪-bit গুণফলের ওপরের word r1-এ রাখে, আর lsrs #6 মিলিয়ে মোট 38 bit ডানে সরানো। 238 ÷ 1000 ≈ 274877906.9, ওপরে গোল করলে 274877907 = 0x10624DD3. তাই এই গুণ-আর-shift 1000 দিয়ে ভাগের সমান ফল দেয়। ফাইলের বাকি অংশে .cpu cortex-m3 আর .eabi_attribute লাইন আছে: target-এর পরিচয় object-এ লিখে রাখার নির্দেশ।

ধাপ ৩, assemble (-c). Assembler লেখাকে byte-এ বদলে object file বানায়। Clang-এর assembler compiler-এর ভেতরেই, তাই আলাদা program চলে না। নিজের lab-এর ছোট stdlib Python ELF reader elfinfo.py দিয়ে পড়া (সত্যিকারের run, বাছাই করা লাইন):

~/lab/xbuild $ clang $CFLAGS -isystem $ZINC -c price.c -o price.o
~/lab/xbuild $ python -B elfinfo.py price.o -h -S -s
ELF32 little-endian, machine ARM (40), type REL (relocatable object), entry 0x00000000, flags 0x05000000
  Nr Name                       Type        Addr      Size Flg
   3 .text.price_paisa          PROGBITS    00000000    26 AX
  Value     Size Bind   Section                Name
  00000001    26 GLOBAL .text.price_paisa      price_paisa

ফাইলটি 828 byte, কিন্তু কোড মাত্র 26 byte, নিজের section .text.price_paisa-এ (-ffunction-sections-এর ফল)। Symbol-এর মান 1, ঠিকানা 0 নয়: Thumb function-এর ঠিকানায় bit 0 = 1 রাখা হয় (পর্ব ২৯)। type REL মানে এটি এখনো ঠিকানাহীন টুকরো। ধাপ ৪, link পরের দুই অংশে। পুরো যাত্রা নিচের ছবিতে, আর ধাপে ধাপে stepper-এ।

ছবি ৩৭.১ — host PC-তে build, target-এ চলা

বাজারঘরের scale firmware: প্রতিটি তীরে একটি টুল, প্রতিটি বাক্সে আসল ফাইল আর মাপ

Cross-compilation-এর পথ: host থেকে target host PC (x86-64) target price.c C source, ৭ লাইন ↓ clang -E price.i ৯০ লাইন, macro খোলা ↓ clang -S price.s Thumb-2, ৮টি instruction ↓ clang -c price.o + main.o + … object, ঠিকানা এখনো 0 ↓ ld.lld -T bazarghar.ld scale.elf + scale.map ঠিকানাসহ, 9812 B ↓ objcopy -O binary/hex scale.bin · scale.hex flash-এর ছবি, 1204 B ↓ flash programmer BG-M3-এর flash 0x08000000, Cortex-M3
1price.c (৭ লাইন)2clang -E price.c -o price.i3clang -S price.c -o price.s4clang -c price.c -o price.o5ld.lld -T bazarghar.ld *.o6objcopy -O binary scale.elf
প্রতিটি ধাপের আসল ফল
ফাইল
আকার
দামের লাইন
  1. Source. সাত লাইনের price.c; দামের হার একটি macro, RATE_PAISA_PER_KG. এখানে এখনো কোনো CPU-র চিহ্ন নেই।
  2. Preprocess. price.h আর stdint.h-এর লেখা ঢুকে ফাইল ৯০ লাইন, 1735 byte. Macro-র জায়গায় সংখ্যা 6550u. ফল এখনো C.
  3. Compile. Cortex-M3-এর আটটি Thumb-2 instruction. movw r1, #6550-এ দামের হার সরাসরি instruction-এর ভেতরে; ভাগ হয়েছে umull আর lsrs দিয়ে।
  4. Assemble. 828 byte-এর object, কোড 26 byte. প্রথম চার byte 41 F6 96 11 হলো movw r1, #6550-এর machine code. ঠিকানা এখনো 0, কারণ কোথায় বসবে কেউ জানে না।
  5. Link. main.o, startup.o, bglib.o-এর সঙ্গে জুড়ে price_paisa বসল 0x080000F8-এ; symbol-এর মান Thumb bit সহ 0x080000F9. ELF-এ debug-এর জন্য symbol table-ও আছে, তাই 9812 byte.
  6. Binary. .bin-এ শুধু flash-এ যা যাবে: 1204 byte. ফাইলের offset 0xF8-এ সেই একই 41 F6 96 11, কারণ offset = ঠিকানা − 0x08000000.

৪ · Object file-এর ভেতরে — section, symbol আর relocation

একটি object file তিনটি জিনিস বহন করে। এক, section: নাম দেওয়া ঝুড়িতে কোড আর ডেটা। দুই, symbol: “এই নাম আমার কাছে আছে” বা “এই নাম আমার দরকার”। তিন, relocation: “ঠিকানা জানা গেলে এই byte-গুলো ঠিক করে দিতে হবে”। ফাইলের ফরম্যাট ELF, desktop Linux-এর মতোই; শুধু machine ঘরে ARM লেখা। main.o পড়া হলো (সত্যিকারের run, বাছাই করা লাইন):

~/lab/xbuild $ python -B elfinfo.py main.o -S -s -r
  Nr Name                       Type        Addr      Size Flg
   3 .text.main                 PROGBITS    00000000   150 AX
   4 .rel.text.main             REL         00000000   208
   7 .data.shop_name            PROGBITS    00000000    10 AW
   8 .rodata.str1.1             PROGBITS    00000000    22 A
  Value     Size Bind   Section                Name
  00000001   150 GLOBAL .text.main             main
  00000000     0 GLOBAL UND (undefined)        uart_init
  00000000    10 GLOBAL .data.shop_name        shop_name
  00000000     0 GLOBAL UND (undefined)        uart_puts
  00000000     0 GLOBAL UND (undefined)        uart_put_u32
  00000000     0 GLOBAL UND (undefined)        price_paisa
  00000000     0 GLOBAL UND (undefined)        uart_put_fixed2
  relocations in .rel.text.main:
    offset 0x0000  R_ARM_THM_CALL         uart_init
    offset 0x0004  R_ARM_THM_MOVW_ABS_NC  shop_name
    offset 0x0008  R_ARM_THM_MOVT_ABS     shop_name
    offset 0x0032  R_ARM_THM_CALL         price_paisa

তিনটি জিনিস চোখে পড়ে। প্রথমত, shop_name const নয়, তাই .data.shop_name-এ (10 byte = “BazarGhar” আর শেষের শূন্য); const টেবিল loads_g-এর কোনো section-ই নেই, কারণ -O2-এ compiler loop খুলে তিনটি সংখ্যা সরাসরি কোডে বসিয়েছে। দ্বিতীয়ত, পাঁচটি symbol UND: main.o এদের ব্যবহার করে, কিন্তু সংজ্ঞা দেয় না। তৃতীয়ত, প্রতিটি ব্যবহারের জায়গায় একটি relocation: offset 0x32-এর R_ARM_THM_CALL বলে, “এখানে একটি Thumb BL আছে, price_paisa-এর ঠিকানা জানা গেলে লাফের দূরত্ব বসাতে হবে”। MOVW/MOVT জোড়া বলে, “shop_name-এর ৩২-bit ঠিকানার নিচের আর ওপরের অর্ধেক এখানে বসাতে হবে”। পুরো তালিকায় এমন ২৬টি relocation; price_paisa-র ডাক তিনবার (offset 0x32, 0x5A, 0x7A), কারণ loop খোলা।

অন্য দুটি object-এর কথাও জেনে রাখুন। startup.o সংজ্ঞা দেয় g_vectors (vector table, 96 byte), Reset_Handler, memcpy, memset আর এগারোটি weak handler; তার নিজের দরকার main আর _sidata, _sdata, _estack-এর মতো ছয়টি নাম, যা দেবে linker script. bglib.o দেয় সাতটি UART আর সংখ্যা-ছাপার function. কে কী দেয় আর কী চায়, এই হিসাব মেলানোই linker-এর প্রথম কাজ।

Object-এ আরও কয়েকটি section আছে, যা flash-এ কখনো যায় না। .ARM.attributes বলে কোডটি কোন CPU আর কোন float-নিয়মের জন্য, যাতে ভুল মিশ্রণ ধরা যায়; .ARM.exidx হলো exception বা stack-trace-এর জন্য stack খোলার টেবিল, এখানে শুধু “খোলা যাবে না” চিহ্ন, আর reference lab-এর linker script একে /DISCARD/ করে। ELF header-এর flags 0x05000000-এর ওপরের byte 5 মানে ARM EABI-র version 5; link করা ELF-এ এর সঙ্গে 0x200 যোগ হয়ে 0x05000200, যা soft-float নিয়মের চিহ্ন। দুই ভিন্ন float-নিয়মের object একসাথে মেশানোর ভুল এই চিহ্ন আর attributes দেখেই ধরা যায়।

৫ · Linker — নাম মেলানো, ঠিকানা বসানো, আর link error

Linker (এখানে LLD, ld.lld) দুই ধাপে কাজ করে। প্রথমে symbol resolution: প্রতিটি UND নামের জন্য ঠিক একটি সংজ্ঞা খোঁজে। তারপর linker script অনুযায়ী প্রতিটি section-কে ঠিকানা দেয়, আর relocation-গুলোর জায়গায় আসল সংখ্যা বসায়। ইচ্ছে করে price.o বাদ দিয়ে link করা হলো (সত্যিকারের run):

~/lab/xbuild $ ld.lld -T bazarghar.ld --gc-sections -Map=build/scale.map -o build/scale.elf main.o startup.o bglib.o
ld.lld: error: undefined symbol: price_paisa
>>> referenced by main.c
>>>               main.o:(main)
(একই দুই লাইন আরও দুবার: তিনটি ডাক)

এটিই সেই undefined reference, GCC-র ভাষায় “undefined reference to”. Compile ঠিক ছিল; main.c শুধু price.h-এর ঘোষণা দেখেছিল, আর ঘোষণা মানে প্রতিশ্রুতি, সংজ্ঞা নয়। প্রতিশ্রুতি রাখার ফাইলটিই link-এ দেওয়া হয়নি। সমাধান: price.o যোগ করা। ঘটনাটি byte ধরে দেখুন:

1main.o: UND price_paisa2link main startup bglib3error: undefined symbol4link + price.o5main+0x32: FF F7 FE FF6        → 00 F0 31 F87UART: 1250 g -> 81.88 Tk
price_paisa-র হিসাব
সংজ্ঞা
main+0x32-এর byte
ফল
  1. শুরুর অবস্থা. main.o-এর symbol table-এ price_paisa UND. Offset 0x32-এর BL-এর byte FF F7 FE FF, একটি ফাঁকা জায়গা-রাখা মান; পাশে relocation R_ARM_THM_CALL.
  2. Link শুরু. LLD তিনটি object-এর সব সংজ্ঞা জড়ো করে: main, shop_name, startup-এর নাম, bglib-এর সাতটি function. price_paisa তাদের মধ্যে নেই।
  3. Error. undefined symbol: price_paisa, তিনটি ডাকের জন্য তিনবার, exit code 1. scale.elf তৈরি হয়নি। মনে রাখুন, compile ঠিক ছিল; এটি link-এর ভুল।
  4. ঠিক তালিকা. price.o যোগ করতেই সংজ্ঞা মিলল: .text.price_paisa, 26 byte. এবার কোনো UND বাকি নেই; linker script-এর ছয়টি নাম LLD নিজে বানায়।
  5. Relocation পূরণ. price_paisa বসল 0x080000F8-এ। BL নিজে আছে 0x08000092-এ; Thumb-এ লাফ মাপা হয় PC + 4 থেকে, তাই দূরত্ব 0x080000F8 − 0x08000096 = 98. সেই 98 encode করে byte হলো 00 F0 31 F8.
  6. Board-এ চালানো. বাকি দুই ডাকও (0x080000BA আর 0x080000DA) একই ঠিকানায় যায়, দূরত্ব 58 আর 26. UART-এ তিনটি দাম 9.83, 81.88, 32.75 টাকা, README-র নির্ধারিত সংখ্যার সঙ্গে হুবহু।

সফল build-এর পুরো run (সত্যিকারের run; python -B board.py run, reference lab-এর ফোল্ডার থেকে):

[     0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
[     0.0192 ms] UART: BazarGhar scale
[     0.0494 ms] UART: 150 g -> 9.83 Tk
[     0.0838 ms] UART: 1250 g -> 81.88 Tk
[     0.1155 ms] UART: 500 g -> 32.75 Tk
[     0.1164 ms] exit(0) after 931 cycles

“BazarGhar” ছাপা হওয়া মানে .data-র মান flash থেকে SRAM-এ ঠিকমতো কপি হয়েছে; সেই কাজ startup code-এর, যার বিস্তার পর্ব ৩২-এ (Boot আর startup code). Board এক instruction-কে এক cycle ধরে গোনে (Spec decision 17), তাই 931 আসলে instruction-এর সংখ্যা।

উল্টো ভুলও আছে: একই নামের দুটি সংজ্ঞা। price.o-র একটি কপি দ্বিতীয়বার দিলে LLD বলে duplicate symbol: price_paisa; আর main.o বাদ দিলে undefined symbol: main, ব্যবহারকারী startup.o-এর Reset_Handler. দুটিই আসল run. Linker-এর এই প্রথম কাজটি একটি খেলনা program-এ দেখুন; symbol-এর তালিকা ওপরের আসল object থেকে নেওয়া (weak handler বাদ):

# খেলনা linker, ধাপ ১: symbol resolution (তালিকা আসল .o ফাইল থেকে)
OBJS = {   # ফাইল: (যে নাম সংজ্ঞায়িত করে, যে নাম শুধু ব্যবহার করে)
    "main.o":    ({"main", "shop_name"},
                  {"uart_init", "uart_puts", "uart_put_u32", "price_paisa", "uart_put_fixed2"}),
    "price.o":   ({"price_paisa"}, set()),
    "startup.o": ({"g_vectors", "Reset_Handler", "Default_Handler", "memcpy", "memset"},
                  {"main", "_sidata", "_sdata", "_edata", "_sbss", "_ebss", "_estack"}),
    "bglib.o":   ({"uart_init", "uart_putc", "uart_puts", "uart_put_u32",
                   "uart_put_i32", "uart_put_fixed2", "div_round"}, set()),
}
OBJS["price_copy.o"] = OBJS["price.o"]
SCRIPT = {"_sidata", "_sdata", "_edata", "_sbss", "_ebss", "_estack"}  # bazarghar.ld

def link(files):
    owner, errors = {}, []
    for f in files:                                  # ১) সব সংজ্ঞা জড়ো করা
        for s in sorted(OBJS[f][0]):
            if s in owner:
                errors.append(f"duplicate symbol: {s} ({owner[s]}, {f})")
            owner[s] = f
    for f in files:                                  # ২) প্রতিটি ব্যবহারের সংজ্ঞা চাই
        for s in sorted(OBJS[f][1]):
            if s not in owner and s not in SCRIPT:
                errors.append(f"undefined symbol: {s} (used by {f})")
    return errors or [f"ok: {len(owner)} symbols from objects + {len(SCRIPT)} from the script"]

for files in (["main.o", "startup.o", "bglib.o"],
              ["main.o", "price.o", "startup.o", "bglib.o"],
              ["main.o", "price.o", "startup.o", "bglib.o", "price_copy.o"],
              ["price.o", "startup.o", "bglib.o"]):
    print(" + ".join(files))
    for line in link(files):
        print("   ", line)

আসল আউটপুট (ব্রাউজারের Python):

main.o + startup.o + bglib.o
    undefined symbol: price_paisa (used by main.o)
main.o + price.o + startup.o + bglib.o
    ok: 15 symbols from objects + 6 from the script
main.o + price.o + startup.o + bglib.o + price_copy.o
    duplicate symbol: price_paisa (price.o, price_copy.o)
price.o + startup.o + bglib.o
    undefined symbol: main (used by startup.o)

চারটি ফল LLD-র চারটি আসল run-এর সঙ্গে মেলে। আসল linker এর পরে আরও কাজ করে: section সাজায়, ঠিকানা দেয়, relocation পূরণ করে, আর library থেকে শুধু দরকারি object টানে। কিন্তু link error-এর প্রায় সব গল্প এই দুটি loop-এই: কেউ দেয়নি, বা দুজনে দিয়েছে।

Target বদলালে নতুন link error: Cortex-M0 আর ভাগ

অংশ ২-এর টেবিলে দেখেছেন, Cortex-M0-এ __ARM_FEATURE_IDIV নেই। একই price.c --target=thumbv6m-none-eabi -mcpu=cortex-m0 দিয়ে compile করলে (সত্যিকারের run; .fnstart-এর মতো নির্দেশ-লাইন বাদ):

price_paisa:
	push	{r7, lr}
	ldr	r1, .LCPI0_0
	muls	r1, r0, r1
	movs	r2, #125
	lsls	r0, r2, #2
	adds	r0, r1, r0
	lsls	r1, r2, #3
	bl	__aeabi_uidiv
	pop	{r7, pc}
.LCPI0_0:
	.long	6550                            @ 0x1996
~/lab/xbuild/m0 $ ld.lld -T ../bazarghar.ld --gc-sections -o scale_m0.elf main.o startup.o bglib.o price.o
ld.lld: error: undefined symbol: __aeabi_uidiv
ld.lld: error: undefined symbol: __aeabi_uidivmod

Cortex-M0-এর instruction-এ movw নেই, তাই 6550 এসেছে flash-এর একটি word থেকে (.LCPI0_0), আর 500 ও 1000 বানানো হয়েছে 125-কে shift করে। ARMv6-M-এ umull-ও নেই, তাই compiler গুণ-আর-shift-এর কৌশল নেয়নি; ভাগের জন্য ডেকেছে __aeabi_uidiv, যার নাম ARM-এর run-time ABI ঠিক করে দেয়। bglib.c-এর v % 10 ডেকেছে __aeabi_uidivmod. সাধারণত এগুলো আসে compiler-এর runtime library থেকে (GCC-তে libgcc, LLVM-এ compiler-rt), কিন্তু -nostdlib সেটিও বাদ দিয়েছে। নিজের lab-এ ২৩ লাইনের একটি aeabi_div.c লেখা হলো (shift-আর-বিয়োগে ভাগ; __aeabi_uidivmod ভাগফল r0-তে আর ভাগশেষ r1-এ ফেরত দেয়, AAPCS-এর ৬৪-bit ফেরত মানের নিয়মে)। যোগ করে link আর run (সত্যিকারের run):

[     0.0241 ms] UART: BazarGhar scale
[     0.6635 ms] UART: 150 g -> 9.83 Tk
[     1.5791 ms] UART: 1250 g -> 81.88 Tk
[     2.2881 ms] UART: 500 g -> 32.75 Tk
[     2.2891 ms] exit(0) after 18313 cycles

দাম একই, কিন্তু instruction 931 থেকে 18313, প্রায় ২০ গুণ। বেশিরভাগ বাড়তি সময় সংখ্যা ছাপার helper-এর ভাগে, কারণ প্রতিটি অঙ্কের জন্য একটি ৩২-ধাপের ভাগ-loop চলে। ARMv6-M-এর instruction ARMv7-M-এর একটি উপসেট, তাই M0-এর কোড M3-এর আদলের board-এ চলেছে। আসল chip-এ সময়ের হিসাব datasheet থেকে নিতে হয়, এই board-এর গোনা থেকে নয় (Spec decision 17). শিক্ষা হলো, target বদলালে শুধু flag নয়, link-এর তালিকাও বদলাতে পারে।

৬ · Map file আর আকারের হিসাব

Link-এর সফল ফলের পাশে map file তৈরি হয়। Map পড়ার পুরো নিয়ম, LMA আর VMA, আর LLD-র কলাম পর্ব ৩১-এ (Memory map আর linker script); এখানে শুধু build-এর প্রশ্নে কাজে লাগা লাইন (সত্যিকারের run, build/scale.map, সংখ্যা hex, 0x ছাড়া):

     VMA      LMA     Size Align Out     In      Symbol
 8000000  8000000       60     4 .isr_vector
 8000060  8000060      448     4 .text
 8000060  8000060       96     4         main.o:(.text.main)
 80000f8  80000f8       1a     4         price.o:(.text.price_paisa)
 80002e0  80002e0      1b0     4         bglib.o:(.text.uart_put_fixed2)
 8000490  8000490       16     1         <internal>:(.rodata.str1.1)
20000000  80004a8        c     1 .data
20000000  80004a8        a     1         main.o:(.data.shop_name)
2000000c 2000000c        0     1 .bss

হিসাব: flash = .isr_vector 0x60 (96) + .text 0x448 (1096) + .data-র মান 0xc (12) = 1204 byte, 128 KiB-এর ১%-এরও কম। স্থির SRAM শুধু .data-র 12 byte; .bss খালি। .data-র মাপ 0xc, যদিও shop_name 0xa = 10 byte: linker script-এর ALIGN(4) শেষে দুই byte যোগ করেছে।

Link-এ --gc-sections দেওয়া, আর সেটিই এই ছোট সংখ্যার কারণ। --gc-sections vector table আর entry থেকে শুরু করে যে section-এ পৌঁছানো যায় না, তা ফেলে দেয়। একই object দিয়ে এটি ছাড়া link করে মাপা হলো (সত্যিকারের run):

Link.text.bin-এর মাপযা থেকে গেল
--gc-sections সহ1096 B1204 Bযা সত্যিই ডাকা হয়
ছাড়া1904 B2012 Bঅব্যবহৃত uart_put_i32 (510 B), memcpy, memset, div_round, uart_putc-ও

808 byte বাঁচল, প্রায় ৪০%. কিন্তু এর একটি শর্ত আছে: কোনো কোড vector table-কে ডাকে না, তাই linker script-এ KEEP(*(.isr_vector)) না থাকলে টেবিলটিই “অব্যবহৃত” ভেবে মুছে যেতে পারে। Reference lab-এর bazarghar.ld-এ KEEP আছে।

৭ · ELF থেকে .bin আর .hex — flash-এ যাওয়ার রূপ

ELF ফাইলে কোডের পাশে আছে section header, symbol table, আর debug তথ্য রাখার জায়গা: debugger-এর জন্য দারুণ, কিন্তু chip-এর flash এসব চায় না। Flash programmer বা bootloader সাধারণত চায় দুটি রূপের একটি। Raw binary (.bin): flash-এ যেমন বসবে ঠিক তেমন byte, কোনো ঠিকানা ছাড়া। Intel HEX (.hex): লেখা-ভিত্তিক, প্রতিটি লাইনে ঠিকানা আর checksum. দুটিই বানায় objcopy. Zig-এর নিজের zig objcopy ELF থেকে দুটিই পারে (সত্যিকারের run):

~/lab/xbuild $ python -m ziglang objcopy -O binary build/scale.elf build/scale.bin
~/lab/xbuild $ python -m ziglang objcopy -O hex build/scale.elf build/scale.hex
~/lab/xbuild $ wc -c build/scale.elf build/scale.bin build/scale.hex
 9812 build/scale.elf
 1204 build/scale.bin
 3426 build/scale.hex
~/lab/xbuild $ python -B elfinfo.py build/scale.elf -l
  LOAD VirtAddr   PhysAddr   FileSiz MemSiz Offset
       0x08000000 0x08000000      96     96 0x01000
       0x08000060 0x08000060    1096   1096 0x01060
       0x20000000 0x080004A8      12     12 0x02000

নিয়মটি সরল: প্রতিটি LOAD segment-এর byte বসে তার PhysAddr, অর্থাৎ LMA-তে; সবচেয়ে ছোট LMA হয় ফাইলের offset 0. নিয়ম বুঝেছি কি না যাচাই করতে নিজের lab-এ ২৩ লাইনের stdlib Python elf2bin.py লেখা হলো, যা ফাঁক থাকলে তা 0xFF (মোছা flash-এর মান) দিয়ে ভরে (সত্যিকারের run):

~/lab/xbuild $ python -B elf2bin.py build/scale.elf build/scale_py.bin
LMA 0x08000000 -> file offset 0x0000     96 bytes  (VMA 0x08000000)
LMA 0x08000060 -> file offset 0x0060   1096 bytes  (VMA 0x08000060)
LMA 0x080004A8 -> file offset 0x04A8     12 bytes  (VMA 0x20000000)
image: base 0x08000000, 1204 bytes, sha256 cc0c6bb2231ae796
~/lab/xbuild $ cmp build/scale.bin build/scale_py.bin && echo SAME
SAME
1base = min(LMA) = 0x080000002LOAD 0x08000000  96 B3LOAD 0x08000060  1096 B4LOAD 0x080004A8  12 B5  (VMA 0x20000000)6scale.bin = 1204 B
.bin-এ কী কোথায়
অংশ
offset
byte
  1. Base. তিনটি segment-এর সবচেয়ে ছোট LMA 0x08000000; সেটি ফাইলের offset 0. .bin-এ এই ঠিকানা কোথাও লেখা থাকে না, তাই flash programmer-কে আলাদা করে বলতে হয় যে লেখা শুরু হবে 0x08000000 থেকে।
  2. Vector table. প্রথম 96 byte. প্রথম word 00 50 00 20 = 0x20005000, stack-এর শুরু; দ্বিতীয় 19 01 00 08 = 0x08000119, Reset_Handler-এর ঠিকানা Thumb bit সহ। দুটিই little-endian, ছোট byte আগে।
  3. .text-এর ভেতরে. offset 0x60 থেকে 1096 byte. price_paisa 0x080000F8-এ, তাই offset 0xF8; সেখানে 41 F6 96 11, অর্থাৎ movw r1, #6550, object file-এর সেই একই চার byte.
  4. .text-এর শেষ. offset 0x4A0-তে string " Tk\r\n"-এর byte আর শেষের শূন্য, তারপর D4 D4: linker script-এর ALIGN(4)-এর দুই byte ফাঁক, যা LLD code section-এ শূন্যের বদলে এই মান দিয়ে ভরেছে।
  5. .data-র মান. চলবে SRAM-এর 0x20000000-এ, কিন্তু রাখা LMA 0x080004A8-এ, তাই offset 0x4A8: “BazarGhar”, শূন্য, আর দুই byte padding. Reset-এ startup এখান থেকেই SRAM-এ কপি করে।
  6. মোট. 96 + 1096 + 12 = 1204 byte, কোনো ফাঁক নেই। নিজের elf2bin.py-এর ফাইল আর zig objcopy-এর ফাইল byte-byte এক: নিয়মটি ঠিক বোঝা গেছে।

বাস্তবে এর মানে, .bin লেখার প্রতিটি টুলে শুরুর ঠিকানা আলাদা করে দিতে হয়, আর ঠিকানা ভুল দিলে টুল সাধারণত আপত্তি করে না। Bootloader থাকলে application শুরু হয় তার পরের কোনো ঠিকানা থেকে; তখন ভুল ঠিকানায় লেখা .bin bootloader-কেই মুছে দিতে পারে। এজন্য অনেক দল কারখানার কাজে ঠিকানাসহ ফরম্যাট পছন্দ করে।

Intel HEX-এর প্রতিটি লাইন: কোলন, byte-সংখ্যা (LL), ঠিকানার নিচের ১৬ bit (AAAA), ধরন (TT: 00 ডেটা, 01 শেষ, 04 ঠিকানার ওপরের ১৬ bit), ডেটা, আর একটি checksum (CC), যাতে সব byte-এর যোগফল 256-এর গুণিতক হয়। নিচের program আসল scale.hex-এর চারটি লাইন নিজে বানায় আর একটি লাইন উল্টো পড়ে:

# Intel HEX: প্রতিটি লাইন = ':' + LL AAAA TT data... CC
def record(addr16, rtype, data):
    body = bytes([len(data), addr16 >> 8, addr16 & 0xFF, rtype]) + data
    cc = (-sum(body)) & 0xFF          # সব byte + CC = 0 (mod 256)
    return ":" + (body + bytes([cc])).hex().upper()

BASE = 0x08000000
vec = bytes.fromhex("00500020" "19010008" "15010008" "15010008")
shop = b"BazarGhar\0\0\0"            # .data: LMA 0x080004A8, 12 B
print(record(0, 0x04, (BASE >> 16).to_bytes(2, "big")))  # ঠিকানার ওপরের অর্ধেক
print(record(0x0000, 0x00, vec))
print(record(0x04A8, 0x00, shop))
print(record(0, 0x01, b""))          # ফাইলের শেষ

line = ":0C04A80042617A617247686172000000D6"   # একটি লাইন উল্টো পড়া
raw = bytes.fromhex(line[1:])
print("sum mod 256 =", sum(raw) & 0xFF,
      "| addr = 0x%08X" % (BASE + int(line[3:7], 16)),
      "| text =", raw[4:-1].rstrip(b"\0").decode())
for i in range(0, 16, 4):            # vector table-এর word, little-endian
    print("word %d = 0x%08X" % (i // 4, int.from_bytes(vec[i:i + 4], "little")))

আসল আউটপুট (ব্রাউজারের Python):

:020000040800F2
:100000000050002019010008150100081501000822
:0C04A80042617A617247686172000000D6
:00000001FF
sum mod 256 = 0 | addr = 0x080004A8 | text = BazarGhar
word 0 = 0x20005000
word 1 = 0x08000119
word 2 = 0x08000115
word 3 = 0x08000115

প্রথম চারটি লাইন zig objcopy -O hex-এর ফাইলের প্রথম দুই, শেষের আগের এক আর শেষ লাইনের সঙ্গে অক্ষরে অক্ষরে মেলে। :02 0000 04 0800 বলে, “এরপরের সব ঠিকানার ওপরের অর্ধেক 0x0800”; তাই .data-র লাইনের 04A8 আসলে 0x080004A8. Word 2 আর 3 = 0x08000115: NMI আর HardFault দুটিই Default_Handler-এ যায়। .bin-এর তুলনায় .hex প্রায় তিন গুণ বড় (3426 বনাম 1204 byte), কিন্তু প্রতিটি লাইন নিজের ঠিকানা আর ভুল-ধরার checksum বহন করে।

এবার একটি সত্যিকারের ফাঁদ। নিজের lab-এ linker script-এর একটি কপিতে .data-র লাইন থেকে AT > FLASH মুছে link করা হলো। Link সফল, কিন্তু তৃতীয় segment-এর PhysAddr হলো 0x20000000; board ফাইলটি নিতেই অস্বীকার করল: error: segment at 0x20000000 is outside flash. আর objcopy নির্বিকারভাবে বানাল 402653196 byte-এর .bin (সত্যিকারের run; ফাইলটি পরে মুছে ফেলা হয়েছে)। কেন, নিচের program দেখায়:

# objcopy -O binary-র নিয়ম: প্রতিটি segment তার LMA-তে, মাঝের ফাঁক ভরা
GOOD = [(0x08000000, 96), (0x08000060, 1096), (0x080004A8, 12)]  # (LMA, FileSiz)
BAD  = [(0x08000000, 96), (0x08000060, 1096), (0x20000000, 12)]  # AT > FLASH ছাড়া

def image(segs):
    base = min(a for a, n in segs)
    end = max(a + n for a, n in segs)
    gap = (end - base) - sum(n for a, n in segs)
    return base, end - base, gap

FLASH = 128 * 1024
for name, segs in (("ঠিক ELF", GOOD), ("AT > FLASH ছাড়া", BAD)):
    base, size, gap = image(segs)
    print(f"{name}: base 0x{base:08X}, .bin = {size} B "
          f"({size / 2**20:.2f} MiB), ফাঁক {gap} B, flash-এ ধরবে? {size <= FLASH}")
print("ফাঁকটুকু:", hex(0x20000000 - 0x08000000), "=", (0x20000000 - 0x08000000) // 2**20, "MiB")

আসল আউটপুট (ব্রাউজারের Python):

ঠিক ELF: base 0x08000000, .bin = 1204 B (0.00 MiB), ফাঁক 0 B, flash-এ ধরবে? True
AT > FLASH ছাড়া: base 0x08000000, .bin = 402653196 B (384.00 MiB), ফাঁক 402651992 B, flash-এ ধরবে? False
ফাঁকটুকু: 0x18000000 = 384 MiB

402653196 সংখ্যাটি আসল objcopy-র ফাইলের মাপের সঙ্গে হুবহু মেলে। flash আর SRAM-এর ঠিকানার মাঝের পুরো 384 MiB ফাঁক ফাইলে ঢুকে গেছে, কারণ .data-র মান এখন “SRAM-এ রাখা”। তাই build-এর পরে .bin-এর মাপ একবার দেখে নেওয়া সস্তা কিন্তু দারুণ কাজের পরীক্ষা: হঠাৎ বিশাল হলে প্রায় নিশ্চিতভাবে কোনো section-এর LMA ভুল।

আরও গভীরে — BL-এর ২৪-bit লাফ: Thumb-2-এর BL দুটি ১৬-bit অর্ধেকে লেখা একটি ৩২-bit instruction. লাফের দূরত্ব S, J1, J2, imm10 আর imm11 নামের টুকরোয় ছড়ানো; ARMv7-M Architecture Reference Manual অনুযায়ী I1 = NOT(J1 XOR S), I2 = NOT(J2 XOR S), আর দূরত্ব = sign-extend(S:I1:I2:imm10:imm11:0), মোট ২৫ bit, তাই পরিসর প্রায় ±16 MiB. 00 F0 31 F8-এ S = 0, imm10 = 0, J1 = J2 = 1, imm11 = 0x31, তাই দূরত্ব 0x31 × 2 = 98, ঠিক stepper-এর হিসাব। Function এই পরিসরের বাইরে হলে, যেমন flash থেকে SRAM-এ রাখা কোনো function ডাকতে, linker নিজে একটি ছোট লাফের সেতু (veneer বা thunk) বসায়; তাই map-এ কখনো কখনো এমন নাম দেখা যায় যা আপনি লেখেননি।

৮ · Makefile, build script আর reproducible build

চারটি ফাইল, তিন ধরনের টুল, এক ডজন flag: প্রতিবার হাতে টাইপ করলে ভুল হবেই। Makefile নিয়মগুলো একবার লিখে রাখে: কোন ফাইল কোন ফাইল থেকে হয়, আর কোন command দিয়ে। এই firmware-এর জন্য একটি ন্যূনতম Makefile:

# Makefile - bazarghar scale firmware
CC      = python -m ziglang clang
LD      = python -m ziglang ld.lld
OBJCOPY = python -m ziglang objcopy
CFLAGS  = --target=thumbv7m-none-eabi -mcpu=cortex-m3 -mthumb -mfloat-abi=soft \
          -ffreestanding -nostdlib -O2 -std=c11 -Wall -Wextra \
          -ffunction-sections -fdata-sections -fno-sanitize=undefined \
          -isystem $(ZINC) -MMD
OBJS    = main.o price.o startup.o bglib.o

build/scale.bin: build/scale.elf
	$(OBJCOPY) -O binary $< $@

build/scale.elf: $(OBJS) bazarghar.ld
	$(LD) -T bazarghar.ld --gc-sections -Map=build/scale.map $(OBJS) -o $@

%.o: %.c
	$(CC) $(CFLAGS) -c $< -o $@

-include $(OBJS:.o=.d)

প্রতিটি নিয়মের লাইনের শুরুতে একটি tab, space নয়; এটি make-এর পুরোনো আর বিখ্যাত ফাঁদ। -MMD compiler-কে বলে প্রতিটি .o-এর পাশে একটি dependency file (.d) লিখতে, আর শেষ লাইন সেগুলো পড়ে। তাই header বদলালেও ঠিক ফাইলগুলো আবার compile হয়। bazarghar.ld-কে ELF-এর নির্ভরতায় রাখা হয়েছে, যাতে linker script বদলালেও link আবার হয়।

এই lab-এর Windows মেশিনে make install করা নেই। তাই একই নিয়ম ৪৪ লাইনের একটি Python build.py-তে লেখা হলো। নিয়ম দুটি: লক্ষ্য-ফাইল না থাকলে বা তার কোনো উৎস নতুন হলে আবার বানানো, আর header-এর তালিকা নেওয়া compiler-এর নিজের .d ফাইল থেকে। Makefile-টি নিজে এখানে চালানো হয়নি; নিচের সব output build.py-র (সত্যিকারের run):

~/lab/xbuild $ python -B build.py          # প্রথমবার, সব নতুন
  CC   main.c
  CC   price.c
  CC   startup.c
  CC   bglib.c
  LD   build/scale.elf
  BIN  build/scale.bin
  6 step(s) run
~/lab/xbuild $ python -B build.py          # কিছু বদলায়নি
  nothing to do: everything is up to date
~/lab/xbuild $ touch price.h; python -B build.py
  CC   main.c
  CC   price.c
  LD   build/scale.elf
  BIN  build/scale.bin
  4 step(s) run
~/lab/xbuild $ cat main.d price.d
main.o: main.c bazarghar.h bglib.h price.h
price.o: price.c price.h

price.h বদলালে শুধু যে দুটি ফাইল তাকে #include করে, সে দুটি আবার compile হলো; startup.c আর bglib.c ছোঁয়া হলো না। এটিই incremental build. হাজার ফাইলের প্রকল্পে এর ফলে কয়েক মিনিটের build কয়েক সেকেন্ডে নামে।

Host-এ test, target-এ build

Build script-এর আরেকটি কাজ একই উৎস দুইভাবে বানানো: target-এর জন্য firmware, আর host-এর জন্য test program. price_paisa()-এর কোনো hardware লাগে না, তাই একে PC-তেই পরীক্ষা করা যায়: host testing. নিচের block একটি remote Linux x86-64 compiler-এ চলে; দামের function হুবহু price.c-এর:

/* host_test.c - the same price_paisa() tested on the PC (host) */
#include <stdio.h>
#include <stdint.h>

#define RATE_PAISA_PER_KG 6550u          /* from price.h */

uint32_t price_paisa(uint32_t net_g)     /* same body as price.c */
{
    return (net_g * RATE_PAISA_PER_KG + 500u) / 1000u;
}

int main(void)
{
    const uint32_t g[]    = {150, 1250, 500, 5000};
    const uint32_t want[] = {983, 8188, 3275, 32750};
    int fail = 0;
    for (int i = 0; i < 4; i++) {
        uint32_t p = price_paisa(g[i]);
        printf("%5u g -> %5u paisa %s\n", g[i], p, p == want[i] ? "ok" : "FAIL");
        fail += p != want[i];
    }
    printf("host: sizeof(long)=%zu sizeof(void*)=%zu\n", sizeof(long), sizeof(void *));
    printf("%s\n", fail ? "TESTS FAILED" : "all tests passed");
    return fail;
}

আসল আউটপুট (Wandbox-এর C compiler):

  150 g ->   983 paisa ok
 1250 g ->  8188 paisa ok
  500 g ->  3275 paisa ok
 5000 g -> 32750 paisa ok
host: sizeof(long)=8 sizeof(void*)=8
all tests passed

চারটি দাম README-র সংখ্যার সঙ্গে মেলে: 9.83, 81.88, 32.75 টাকা, আর পুরো 5000 g-এ 327.50 টাকা। শেষ লাইনটি সতর্কবার্তা: এই Linux host-এ long আর pointer 8 byte, target-এ 4 (অংশ ২-এর টেবিল)। Windows x86-64-এ আবার long 4 byte, pointer 8: host-ও সব এক নয়। price.c-এ uint32_t ব্যবহার করা হয়েছে বলেই দুই জায়গায় একই হিসাব; long লিখলে host-এর test পাস করলেও target-এ overflow-এর সীমা আলাদা হতো। Host testing-এর পুরো পদ্ধতি পর্ব ৬৪-এ (এমবেডেড software testing).

Reproducible build — একই উৎস, একই byte

বাজারঘরের scale যদি এক বছর পরে মাঠে ভুল দাম দেখায়, তখন প্রশ্ন উঠবে: এই device-এ ঠিক কোন কোড চলছে? উত্তর দিতে হলে একই source থেকে আবার build করে byte-byte একই ফাইল পেতে হবে। এটিই reproducible build. নিজের lab-এ পাঁচটি পরীক্ষা (সব সত্যিকারের run):

পরীক্ষাSHA-256-এর শুরুফল
সব মুছে দুবার clean buildcc0c6bb2… দুবারইহুবহু এক
Link-এ object-এর ক্রম বদল (price.o শেষে)7cefb2a0…আলাদা; price_paisa সরে 0x08000474-এ
__DATE__ " " __TIME__ রাখা ফাইল, ২ সেকেন্ড পরপর07a76e8e…, 8fe76d4b…আলাদা; ভেতরে 06:09:50 আর 06:09:52
একই ফাইল, SOURCE_DATE_EPOCH=17951328006e87cd9f… দুবারইএক; ভেতরে Nov 20 2026 00:00:00
-g দিয়ে দুই আলাদা ফোল্ডারে0a1fee4b…, 01cfb0b6…আলাদা; debug তথ্যে ফোল্ডারের পথ

শিক্ষাগুলো সাজিয়ে বলা যায়। Toolchain-এর version আর flag স্থির রাখতে হবে; reference lab-ও তাই বলে, একই version-এ আবার build করলে একই output (Spec decision 30). Object-এর ক্রম build script-এ স্থির। __DATE__/__TIME__ এড়াতে হবে; Clang-এর -Wdate-time সতর্কবার্তাটি আসল run-এ বলল expansion of date or time macro is not reproducible. সত্যিই build-এর সময় লাগলে SOURCE_DATE_EPOCH দিয়ে একটি স্থির সময় দিতে হয়। আর -g-এর debug তথ্যে ফোল্ডারের পুরো পথ ঢোকে: -ffile-prefix-map=<ফোল্ডার>=. দেওয়ার পরে দুই ফোল্ডারের object-এর hash একই হলো (a017729a…)। Reference lab-এর board.py এজন্যই source-এর ফোল্ডার থেকে শুধু ফাইলের নাম দিয়ে compile করে, যাতে কোনো machine path ELF-এ না ঢোকে।

পরীক্ষা ও ইন্টারভিউতে: এই ধরনের প্রশ্ন প্রায়ই আসে।

  • Cross-compiler কী, কেন লাগে? যে compiler এক CPU-তে (host) চলে আর অন্য CPU-র (target) জন্য কোড বানায়; microcontroller-এ compiler চালানোর মতো সম্পদ বা OS নেই।
  • Toolchain-এর ধাপ আর প্রতিটির ফল? preprocess (.i), compile (.s), assemble (.o), link (.elf), তারপর objcopy (.bin/.hex).
  • “undefined reference/symbol” কোন ধাপের ভুল? Link-এর: কোনো object বা library-তে সংজ্ঞা নেই, যেমন একটি .c ফাইল বা runtime library link-এ বাদ।
  • .bin আর .hex-এর পার্থক্য? .bin কাঁচা byte, ঠিকানা বাইরে থেকে জানাতে হয়; Intel HEX লেখা-ভিত্তিক, প্রতিটি লাইনে ঠিকানা আর checksum.
  • -ffunction-sections আর --gc-sections কী করে? প্রতিটি function আলাদা section পায়, linker অব্যবহৃতগুলো ফেলে দেয়; এই firmware-এ .bin 2012 থেকে 1204 byte.

৯ · AI-এর যুগে — build-এর flag আর linker error যাচাই

AI assistant Makefile আর compiler flag-এর একটি চলনসই খসড়া দ্রুত দেয়, কারণ এমন হাজারো ফাইল ইন্টারনেটে আছে। কিন্তু খসড়াটি প্রায়ই অন্য chip, অন্য compiler বা অন্য linker-এর অভ্যাস মিশিয়ে ফেলে। এই পর্বের বিষয়ে চোখে পড়ার মতো ভুল:

AI-এর সাধারণ ভুলকীভাবে ধরবেন
ভুল core-এর flag: Cortex-M3-এ -mcpu=cortex-m4 -mfloat-abi=hard, বা M0-তে thumbv7mdatasheet-এ core আর FPU দেখা; -dM -E দিয়ে macro মেলানো
GCC-র flag Clang-এ বা GNU ld-এর বিকল্প LLD-তে চালানো (যেমন --specs=nano.specs)নিজের টুলের documentation; একবার চালিয়ে error পড়া
undefined symbol: __aeabi_uidiv-এর জন্য না বুঝে flag যোগ বা ভুল helper লেখাকোন target-এ ভাগের instruction নেই বোঝা; runtime library বা helper-কে host-এ test করা
Makefile-এ header-এর নির্ভরতা নেই, বা tab-এর জায়গায় space-MMD; একটি header touch করে দেখা কী আবার build হলো
.data-র LMA না বুঝে objcopy, বা .bin-এর শুরুর ঠিকানা ভুলELF-এর LOAD segment; .bin-এর মাপ আর প্রথম দুটি word পড়া
“reproducible” বলে __DATE__ রাখাদুবার clean build করে SHA-256 মেলানো

AI-কে দিয়ে build সাজাতে চাইলে নিজের toolchain আর chip-এর তথ্য নিজে দিন, আর প্রতিটি flag-এর কারণ চেয়ে নিন:

আমার microcontroller Cortex-M3 (FPU নেই), flash 0x08000000 থেকে 128 KiB. Toolchain: Clang + LLD (GCC নয়), C library নেই, নিজের startup.c আর linker script আছে। ১. main.c, price.c, startup.c, bglib.c থেকে .elf, .map, .bin আর .hex বানানোর একটি Makefile লেখো, header-এর নির্ভরতা -MMD দিয়ে। ২. প্রতিটি compiler আর linker flag-এর পাশে এক লাইনে কারণ লেখো; যে flag শুধু GCC বা GNU ld-এর, তা ব্যবহার করবে না। ৩. ভাগ বা ৬৪-bit গুণের জন্য কোনো runtime helper লাগবে কি না, আর লাগলে কোথা থেকে আসবে, বলো। ৪. build reproducible রাখতে কী কী এড়াতে হবে, তালিকা দাও। ৫. কোনো flag-এর নাম নিশ্চিত না হলে “নিশ্চিত নই” লেখো; অনুমান করবে না।

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

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

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

প্র ০১এই পর্বে একটি Clang দিয়েই x86-64, Cortex-M0, M3 আর M4F-এর কোড বানানো গেল। অথচ GCC দিয়ে ARM firmware বানাতে সাধারণত আলাদা arm-none-eabi-gcc install করতে হয়। এই পার্থক্য কোথা থেকে এল?

GCC-র ঐতিহ্যে একটি compiler binary build হওয়ার সময়েই একটি target ঠিক করে নেয়। GCC-কে নিজে compile করার সময় --target=arm-none-eabi দিলে যে program তৈরি হয়, সে শুধু ARM-এর জন্যই কোড বানায়; তার assembler আর linker (binutils) আর runtime library (libgcc) একই target-এর জন্য আলাদা করে build করা। তাই প্রতিটি target-এর জন্য একটি আলাদা “toolchain package”: x86-এর জন্য একটি, ARM Cortex-M-এর জন্য আরেকটি, RISC-V-এর জন্য আরেকটি। নামের শুরুর arm-none-eabi- অংশটিই target triple, যা দিয়ে একই মেশিনে কয়েকটি GCC পাশাপাশি রাখা যায়।

LLVM শুরু থেকেই অন্যভাবে সাজানো। Chris Lattner-এর নেতৃত্বে ২০০০-এর দশকে গড়ে ওঠা LLVM একটি সাধারণ মধ্যবর্তী ভাষা (IR) রাখে, আর প্রতিটি CPU-র জন্য আলাদা “back end” লাইব্রেরি। Clang (Apple, ২০০৭ থেকে) সাধারণত সব back end একসাথে নিয়ে build হয়, তাই একটি binary-ই --target দেখে ঠিক back end বেছে নেয়। এই পর্বের প্রতিটি run-এ সেটিই ঘটেছে: -print-target-triple দিয়ে Clang নিজের default (Windows x86-64) আর আমাদের দেওয়া thumbv7m-unknown-none-eabi দুটিই বলেছে। LLD-ও একইভাবে অনেক format আর CPU চেনে।

তবে compiler-ই পুরো toolchain নয়। Target-এর header আর library-ও লাগে। এই lab-এ C library নেই, আর Clang-এর নিজের freestanding header খুঁজে দিতে -isystem লাগল। Cortex-M0-এর জন্য ভাগের runtime helper ছিল না, তাই link ব্যর্থ হলো। অর্থাৎ “একটি compiler সব target” কথাটি সত্য, কিন্তু “একটি install সব target-এর জন্য তৈরি” কথাটি সত্য নয়। GCC-র পূর্ণ ARM package-এ এই সবকিছু একসাথে থাকে বলেই বহু দল সেটি পছন্দ করে; Zig-এর মতো প্রকল্প Clang-এর সঙ্গে header আর runtime-এর উৎস নিয়ে এসে এই ফাঁক অনেকটা ভরাট করার চেষ্টা করে।

Embedded দলের জন্য ব্যবহারিক প্রশ্ন তাই compiler-এর নাম নয়, toolchain-এর সম্পূর্ণতা: ঠিক target-এর startup, linker script, C library (newlib বা picolibc-এর মতো), runtime helper আর debugger একসাথে কাজ করে কি না।

মূল উপলব্ধি: GCC সাধারণত এক build-এ এক target, Clang/LLVM এক binary-তে বহু target; কিন্তু দুই ক্ষেত্রেই target-এর header, library আর runtime ঠিক জায়গায় থাকলে তবেই toolchain সম্পূর্ণ।

প্র ০২Cortex-M3-এ 1000 দিয়ে ভাগ একটি গুণ আর shift হয়ে গেল, আর Cortex-M0-তে একটি library ডাক। Firmware লেখার সময় এই পার্থক্য কতটা মাথায় রাখা উচিত?

ARMv7-M (Cortex-M3, M4) স্থাপত্যে UDIV আর SDIV instruction আছে, আর UMULL দিয়ে ৩২ × ৩২ থেকে ৬৪-bit গুণফল পাওয়া যায়। ARMv6-M (Cortex-M0, M0+) অনেক ছোট core-এর জন্য বানানো: ভাগের instruction নেই, আর গুণের instruction শুধু ৩২-bit ফল দেয়। এই পার্থক্য সিলিকনের জায়গা আর শক্তি বাঁচানোর সিদ্ধান্ত; ছোট core-এ প্রতিটি gate-এর দাম আছে।

Compiler দুই জায়গায় দুইভাবে সাড়া দিল। M3-এ ভাজক 1000 একটি স্থির সংখ্যা বলে compiler UDIV-ও ব্যবহার করেনি, আরও দ্রুত একটি কৌশল নিয়েছে: 0x10624DD3 দিয়ে গুণ করে ৩৮ bit ডানে সরানো। M0-তে UMULL নেই বলে এই কৌশল ব্যয়বহুল, তাই সে ডেকেছে __aeabi_uidiv, ARM-এর run-time ABI-তে নাম ঠিক করা একটি function. সেই function না থাকায় link ব্যর্থ, আর এই lab-এর shift-আর-বিয়োগের helper দিয়ে পুরো program-এর instruction সংখ্যা 931 থেকে 18313. আসল chip-এর library এর চেয়ে অনেক দ্রুত ভাগ লিখতে পারে, তবু hardware ভাগের চেয়ে ধীর।

এর মানে এই নয় যে M0-তে ভাগ নিষিদ্ধ। মানে হলো, যে loop হাজারবার চলে, সেখানে ভাগের দাম মাপা দরকার। প্রচলিত কৌশল: দুইয়ের ঘাত দিয়ে ভাগ (shift), স্থির ভাজকের জন্য আগে থেকে হিসাব করা গুণক, বা টেবিল। বাজারঘরের scale প্রতি 100 ms-এ একবার দাম হিসাব করে, তাই সেখানে এই খরচ নগণ্য; কিন্তু একটি 10 kHz-এর filter-এ তা ঠিক করে দিতে পারে deadline মিলবে কি না। সংখ্যা ছাপার helper-ও ভাগ-নির্ভর (প্রতি অঙ্কে % 10), যা ছোট core-এ লুকানো খরচ।

দ্বিতীয় শিক্ষা portability-র। একই C কোড দুই core-এ ঠিক ফল দিল, দাম 81.88 টাকাই; ভাষা ফলের নিশ্চয়তা দেয়, সময়ের নয়। তাই firmware-এর timing-এর দাবি সবসময় target-এর জন্য compile করা কোড আর datasheet দিয়ে যাচাই করতে হয়। Fixed-point হিসাবের পুরো আলোচনা পর্ব ৪০-এ।

মূল উপলব্ধি: instruction set ঠিক করে কোন হিসাব “বিনা মূল্যে” আর কোনটি library ডাক; target বদলালে ফল একই থাকে, কিন্তু খরচ, link-এর তালিকা আর timing বদলায়।

প্র ০৩ELF, .bin আর Intel HEX — একই firmware-এর তিন রূপ। কারখানায় device-এ firmware বসানো, মাঠে update আর debugging-এ কোনটি কেন বেছে নেওয়া হয়?

ELF সবচেয়ে সমৃদ্ধ রূপ। এতে প্রতিটি section-এর ঠিকানা, LMA আর VMA, symbol table, আর -g দিলে কোন byte কোন source লাইনের, সব থাকে। ফরম্যাটটি Unix System V-এর জগৎ থেকে এসেছে (১৯৮০-র দশকের শেষ থেকে ১৯৯০-এর শুরুতে ছড়ায়), আর ARM-এর EABI-ও একেই object আর executable-এর মান হিসেবে নিয়েছে। Debugger ELF ছাড়া প্রায় অন্ধ: HardFault-এর stacked PC পেলে কোন function-এ ভুল, তা symbol table-ই বলে। তাই develop আর debug-এর সময় ELF-ই কেন্দ্র; অনেক debug probe-এর software সরাসরি ELF থেকেই flash-এ লেখে। পর্ব ৩৮-এ (এমবেডেড debugging) এ নিয়ে আরও।

.bin সবচেয়ে সরল: ঠিক flash-এর ছবি। এই পর্বে 1204 byte, ELF-এর আট ভাগের এক ভাগ। Bootloader বা মাঠের update-এ এটি সুবিধাজনক, কারণ ফাইল ছোট, পড়া সহজ, আর hash বা signature করা সোজা। দুর্বলতা হলো ঠিকানা নেই: “কোথায় লিখতে হবে” তা আলাদা করে জানাতে হয়, আর ফাইলে বড় ফাঁক থাকলে তা-ও ভরে যায়, যেমন AT > FLASH ভুলে 384 MiB.

Intel HEX ১৯৭০-এর দশকে Intel-এর হাতে জন্ম, যখন EPROM programmer আর কাগজের টেপে ডেটা যেত; তাই এটি ASCII লেখা আর প্রতি লাইনে checksum রাখে। এই পর্বে 3426 byte, .bin-এর প্রায় তিন গুণ, কিন্তু প্রতিটি লাইন নিজের ঠিকানা বহন করে, ফলে একাধিক আলাদা অংশ (যেমন bootloader আর application) একটি ফাইলেই রাখা যায়, আর কোনো লাইনের একটি অক্ষর বদলালে checksum ধরে ফেলে। কারখানার programmer যন্ত্র আর বহু vendor tool এজন্য একে পছন্দ করে। Motorola-র S-record একই ধরনের আরেকটি ফরম্যাট।

ব্যবহারিক নিয়ম: release-এর সময় তিনটিই সংরক্ষণ করা, একই build থেকে। ELF রাখা হয় debug-এর জন্য (মাঠ থেকে আসা fault log মেলাতে), .bin বা .hex যায় device-এ। আর তিনটির মধ্যে যোগসূত্র নিশ্চিত করে reproducible build, যাতে মাঠের .bin-এর hash থেকে ঠিক ELF-টি খুঁজে পাওয়া যায়। নিরাপদ update-এ .bin-এর সঙ্গে signature আর version যোগ হয় (পর্ব ৭৭)।

মূল উপলব্ধি: ELF মানুষের আর debugger-এর জন্য, .bin সরল flash-ছবি, Intel HEX ঠিকানা আর checksum-সহ বহনযোগ্য রূপ; একই build-এর তিনটিই রেখে hash দিয়ে বেঁধে রাখাই নিরাপদ অভ্যাস।

প্র ০৪Reproducible build-কে অনেকে শুধু Linux distribution-এর ব্যাপার ভাবেন। একটি ছোট firmware দলের জন্য এর মূল্য কী, আর এই পর্বের পরীক্ষাগুলো কোন ঝুঁকি দেখাল?

Reproducible build-এর আন্দোলন বড় আকারে শুরু হয় Debian-এ, মোটামুটি ২০১৩ সাল থেকে, আর পরে reproducible-builds.org নামে বহু প্রকল্পের যৌথ উদ্যোগ হয়। মূল যুক্তি নিরাপত্তার: আপনি যে binary চালাচ্ছেন, তা যে প্রকাশিত source থেকেই এসেছে, তা যে কেউ আবার build করে byte মিলিয়ে যাচাই করতে পারবে। কেউ build server-এ ঢুকে কোড বদলালে hash মিলবে না। SOURCE_DATE_EPOCH-এর মতো প্রচলিত নিয়ম এই উদ্যোগ থেকেই এসেছে।

Firmware-এ যুক্তিটি আরও জোরালো। একটি device বছরের পর বছর মাঠে থাকে, প্রায়ই update ছাড়া। কোনো অভিযোগ এলে, যেমন বাজারঘরের scale ভুল দাম দেখাচ্ছে, দলকে ঠিক সেই firmware আবার বানাতে হবে, debugger-এ সেই ELF খুলতে হবে, আর পরিবর্তন কেবল যেখানে দরকার সেখানে করতে হবে। Build যদি reproducible না হয়, তাহলে “পুরোনো source থেকে নতুন build” আর “মাঠের device-এর firmware” আলাদা হতে পারে, আর একটি ভুল খোঁজা অনুমানে পরিণত হয়। Signed update-এর ক্ষেত্রেও স্বাধীন যাচাই সম্ভব হয়।

এই পর্বের পরীক্ষাগুলো ঝুঁকির উৎস চিনিয়েছে। সবচেয়ে চেনা __DATE__/__TIME__: দুই সেকেন্ড পরপর দুই build, দুই hash. কম চেনা দুটি আরও বিপজ্জনক, কারণ কেউ লক্ষ করে না। Link-এ object-এর ক্রম বদলাতেই price_paisa-র ঠিকানা 0x080000F8 থেকে 0x08000474-এ সরে গেল, পুরো binary আলাদা; একটি build script ফাইলের তালিকা ফোল্ডার থেকে “যে ক্রমে পাওয়া যায়” নিলে এক মেশিন থেকে আরেক মেশিনে ক্রম বদলাতে পারে। আর -g-এর debug তথ্যে build ফোল্ডারের পুরো পথ ঢোকে, তাই দুই developer-এর build কখনো মেলে না, যদি না -ffile-prefix-map দেওয়া হয়।

সবশেষে toolchain নিজে: compiler-এর version বদলালে optimization বদলায়, তাই binary-ও। Reference lab তাই নির্দিষ্ট version লিখে রাখে আর বলে, একই version-এ build করলে একই output (Spec decision 30). পূর্ণ সমাধান হলো toolchain-কেও version-সহ সংরক্ষণ করা, যেমন একটি container image বা install-এর hash.

মূল উপলব্ধি: reproducible build মানে source, toolchain আর build-পদ্ধতি তিনটিই স্থির; সময়, ফাইলের ক্রম আর ফোল্ডারের পথ চুপচাপ binary বদলায়, তাই দুবার build করে hash মেলানোই একমাত্র নির্ভরযোগ্য প্রমাণ।

প্র ০৫Makefile ১৯৭০-এর দশকের প্রযুক্তি। আজও firmware প্রকল্পে make, CMake বা IDE-র build বোতাম, কোনটি কেন টিকে আছে, আর কোন অভ্যাস যেকোনো build পদ্ধতিতে জরুরি?

make লিখেছিলেন Stuart Feldman, Bell Labs-এ, ১৯৭৬ সালে। প্রচলিত গল্প অনুযায়ী এর পেছনে ছিল এক সহকর্মীর অভিজ্ঞতা: একটি ফাইল বদলের পরে আবার compile না হওয়ায় পুরোনো program নিয়েই অনেকটা সময় নষ্ট হয়েছিল। মূল ধারণা আজও একই: লক্ষ্য, তার উৎস, আর তৈরির নিয়ম; উৎস নতুন হলে আবার তৈরি। এই পর্বের build.py ঠিক এই নিয়মই অনুসরণ করল, আর price.h বদলাতে শুধু দুটি .c আবার compile হলো।

Make-এর দুর্বলতাও পুরোনো। Header-এর নির্ভরতা নিজে জানে না (তাই -MMD আর .d ফাইল); শুধু ফাইলের সময় দেখে, তাই flag বদলালে বুঝতে পারে না যে সব আবার compile করা দরকার; tab আর space-এর পার্থক্যে ভুল হয়; আর Windows, Linux, macOS-এ shell-এর আচরণ আলাদা। CMake এর ওপরে একটি স্তর: প্রকল্পের বিবরণ থেকে make বা Ninja-র ফাইল লিখে দেয়, toolchain ফাইল দিয়ে cross-compiler ঠিক করে। Microcontroller নির্মাতাদের IDE-গুলোও ভেতরে সাধারণত make বা এমন কোনো ব্যবস্থাই চালায়, শুধু বোতামের আড়ালে।

কোনটি বেছে নেবেন, তা দলের আকার আর প্রকল্পের জীবনকালের প্রশ্ন। ছোট firmware-এ একটি পরিষ্কার Makefile যথেষ্ট আর সবচেয়ে স্বচ্ছ। কয়েকটি board আর configuration থাকলে CMake সুবিধা দেয়। IDE-র বোতাম শেখার সময় আরামদায়ক, কিন্তু build-এর flag যদি শুধু IDE-র ভেতরের setting-এ লুকানো থাকে, তাহলে অন্য মেশিনে বা continuous integration-এ একই build পাওয়া কঠিন হয়।

যেকোনো পদ্ধতিতে কয়েকটি অভ্যাস জরুরি: সব flag একটি জায়গায় লেখা আর version control-এ রাখা; header-এর নির্ভরতা compiler থেকে নেওয়া; প্রতিটি release-এর আগে একটি clean build; build-এর শেষে map থেকে flash আর SRAM-এর খরচ ছাপা ও সীমা পেরোলে ব্যর্থ করা; আর host-এ test, target-এ build দুটিই একই command থেকে চালানো যায় এমন রাখা। এই পর্বের Makefile আর build.py দুটিই এই অভ্যাসের ছোট উদাহরণ।

মূল উপলব্ধি: build টুল বদলায়, কিন্তু “লক্ষ্য, উৎস, নিয়ম” আর “একই command, একই ফল” নীতি বদলায় না; build-কে কোডের মতোই লিখে, রেখে আর যাচাই করে চালাতে হয়।

অনুশীলন

প্রথমে নিজে চেষ্টা করুন, তারপর উত্তর খুলুন। প্রতিটি সংখ্যা আসল build বা run-এ মেলানো।

  1. নকশা: .hex আর আকারের পাহারা. এই পর্বের Makefile-এ দুটি জিনিস যোগ করুন: (ক) build/scale.hex বানানোর একটি নিয়ম, (খ) একটি check লক্ষ্য, যা scale.bin 128 KiB-এর বেশি হলে build ব্যর্থ করে। প্রতিটি লাইন কেন, এক বাক্যে লিখুন।
    build/scale.hex: build/scale.elf
    	$(OBJCOPY) -O hex $< $@
    
    check: build/scale.bin
    	python -c "import os,sys; n=os.path.getsize('$<'); print(n, 'B of', 128*1024); sys.exit(n > 128*1024)"
    .PHONY: check

    কেন: .hex বানানো হয় ELF থেকে, কারণ ঠিকানাগুলো ELF-এর segment-এ আছে; $< প্রথম উৎস আর $@ লক্ষ্য। check-এর exit code 0 না হলে make থেমে যায়; .PHONY বলে এটি কোনো ফাইলের নাম নয়, তাই প্রতিবার চলবে।

    যাচাই: make এই lab-এ নেই, তাই Makefile চালানো হয়নি; তবে দুটি command আলাদাভাবে আসল run-এ চলেছে: zig objcopy -O hex 3426 byte-এর ফাইল দিল, আর Python লাইনটি ছাপল 1204 B of 131072, exit code 0.

  2. ভুল খুঁজুন. একজন বাজারঘরের scale firmware Cortex-M0 board-এর জন্য বানাচ্ছেন। Flag: --target=thumbv6m-none-eabi -mcpu=cortex-m0 -ffreestanding -nostdlib -O2. Compile ঠিক, কিন্তু link-এ: undefined symbol: __aeabi_uidiv আর undefined symbol: __aeabi_uidivmod. তাঁর সমাধান: “target-কে thumbv7m করে দিই, error চলে যাবে।” ভুলটি কোথায়, আর ঠিক সমাধান কী?

    কারণ: ARMv6-M-এ ভাগের instruction নেই, তাই compiler (… + 500u) / 1000u আর v % 10-এর জন্য ARM run-time ABI-র helper ডাকে। এগুলো থাকে runtime library-তে, যা -nostdlib বাদ দিয়েছে। Compile ঠিক ছিল; ভুলটি link-এর তালিকায়।

    প্রস্তাবিত সমাধানের ভুল: thumbv7m দিলে link হবে, কারণ M3-এর কোডে ভাগ hardware-এ। কিন্তু সেই কোডে movw, umull, add.w-এর মতো ৩২-bit Thumb-2 instruction আছে, যা Cortex-M0 চেনে না; আসল chip-এ চালালে প্রথম এমন instruction-এই fault হবে। দোকানে মাপ মিলিয়ে দেওয়া, কিন্তু ক্রেতার গায়ে না ওঠা পাঞ্জাবি।

    ঠিক সমাধান: target M0-ই রাখা, আর helper সরবরাহ করা: toolchain-এর runtime library (libgcc বা compiler-rt) link করা, বা নিজের যাচাই করা __aeabi_uidiv/__aeabi_uidivmod. এই পর্বের lab-এ দ্বিতীয় পথে link হলো, আর board-এ দাম এল 9.83, 81.88, 32.75 টাকা; instruction 931 থেকে 18313.

  3. হিসাব: Intel HEX-এর checksum আর ঠিকানা. একটি .hex ফাইলে আগে :020000040800F2 আছে, তারপর এই লাইন, শুধু শেষের দুই অক্ষর মোছা: :0C04A80042617A617247686172000000??. (ক) ডেটা কোন ৩২-bit ঠিকানায় বসবে? (খ) checksum কত? (গ) ডেটা ASCII-তে কী?
    1. টুকরো: LL = 0x0C (১২ byte), AAAA = 0x04A8, TT = 00 (ডেটা)। আগের 04 লাইন ওপরের ১৬ bit = 0x0800 দিয়েছে, তাই ঠিকানা = 0x0800 × 0x10000 + 0x04A8 = 0x080004A8.
    2. সব byte যোগ: 0x0C + 0x04 + 0xA8 + 0x00 = 0xB8 (184); ডেটা 42 61 7A 61 72 47 68 61 72 00 00 00 = 66 + 97 + 122 + 97 + 114 + 71 + 104 + 97 + 114 = 882. মোট 184 + 882 = 1066 = 0x42A.
    3. নিচের byte 0x2A; checksum = 0x100 − 0x2A = 0xD6, যাতে যোগফল 256-এর গুণিতক হয়। আসল ফাইলের লাইনেও D6.
    4. ASCII: 42 61 7A 61 72 47 68 61 72 = “BazarGhar”, তারপর শূন্য আর দুই byte padding: shop_name-এর শুরুর মান, .data-র LMA-তে।
  4. ফল আগে থেকে বলুন. নির্ভরতা: main.o: main.c bazarghar.h bglib.h price.h, price.o: price.c price.h, bglib.o: bglib.c bazarghar.h bglib.h, startup.o: startup.c; ELF নির্ভর করে চারটি .o আর bazarghar.ld-এর ওপর, .bin ELF-এর ওপর। সব up to date থাকা অবস্থায় (ক) শুধু bazarghar.ld, (খ) শুধু bazarghar.h বদলালে কোন কোন ধাপ চলবে? আর দুই ক্ষেত্রেই .bin-এর SHA-256 কি বদলাবে, যদি ফাইল দুটির শুধু সময় বদলায়, লেখা নয়?

    (ক) linker script: কোনো .o-এর উৎস বদলায়নি, তাই compile নেই; ELF-এর উৎস নতুন, তাই LD, তারপর BIN. আসল run: LD build/scale.elf, BIN build/scale.bin, 2 step(s) run.

    (খ) bazarghar.h: যে দুটি .o-এর তালিকায় এটি আছে: main.c আর bglib.c; তারপর LD আর BIN. আসল run: 4 step(s) run. startup.c এটি #include করে না, তাই ছোঁয়া হয়নি।

    Hash: বদলাবে না। লেখা একই, toolchain একই, ক্রম একই, তাই build reproducible: দুই ক্ষেত্রের পরেই sha256 ছিল cc0c6bb2…, আগের মতোই। Make সময় দেখে কাজ করে, কিন্তু ফল নির্ভর করে শুধু লেখার ওপর।

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

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

ক্রমCortex-M firmware-এর একটি .c ফাইল থেকে chip-এ চলা পর্যন্ত ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. Preprocessor #include আর macro খুলে .i বানায়
  2. Compiler target-এর assembly (.s) লেখে
  3. Assembler ঠিকানাহীন object (.o) বানায়
  4. Linker symbol মিলিয়ে, linker script মেনে ঠিকানাসহ .elf বানায়
  5. objcopy ELF থেকে .bin বা .hex বানায়
  6. Flash programmer ফাইলটি chip-এর flash-এ লেখে

Target triple thumbv7m-none-eabi-এ none অংশটি কী বোঝায়?

  • কোনো chip-নির্মাতা নেই
  • FPU নেই
  • কোনো operating system নেই, কোড সরাসরি hardware-এ চলবে
  • কোনো optimization হবে না

একটি firmware-এর main.c price.h-এর ঘোষণা দেখে price_paisa() ডাকে, কিন্তু link-এর তালিকায় price.o নেই। কোন ধাপে কী error আসবে?

  • Compile-এ “implicit declaration” error
  • Link-এ “undefined symbol: price_paisa”
  • Preprocess-এ “file not found”
  • Board-এ চালানোর সময় HardFault

একটি Cortex-M object file-এ একটি BL instruction-এর byte FF F7 FE FF, আর পাশে relocation R_ARM_THM_CALL price_paisa. এর সঠিক অর্থ কোনটি?

  • Assembler ভুল কোড বানিয়েছে
  • Function-টি vector table থেকে ডাকা হবে
  • Link-এর সময় ডাকটি মুছে ফেলা হবে
  • ঠিকানা এখনো অজানা; linker দূরত্ব হিসাব করে এই byte বদলে দেবে

একটি Cortex-M3 firmware-এর ELF-এ তিনটি LOAD segment-এর LMA: 0x08000000 (96 B), 0x08000060 (1096 B), 0x080004A8 (12 B). objcopy -O binary-এর .bin কত byte হবে, আর ফাইলের offset 0 কোন ঠিকানার?

  • 1204 byte; offset 0 = 0x08000000
  • 1204 byte; offset 0 = 0x00000000
  • 1096 byte; offset 0 = 0x08000060
  • প্রায় 128 MiB; offset 0 = 0x00000000

একই source আর একই compiler দিয়ে দুবার clean build করে firmware-এর SHA-256 আলাদা এল। নিচের কোনটি সবচেয়ে সম্ভাব্য কারণ?

  • -O2 প্রতিবার আলাদা optimization বেছে নেয়
  • Linker script-এর ALIGN(4) এলোমেলো padding দেয়
  • কোথাও __DATE__ বা __TIME__ ব্যবহার করা হয়েছে
  • SHA-256 প্রতিবার আলাদা ফল দেয়

Cortex-M0-এর জন্য -nostdlib দিয়ে build করা firmware-এ link error: undefined symbol: __aeabi_uidiv. এর মূল কারণ কী?

  • Programmer একটি function-এর নাম ভুল লিখেছেন
  • Cortex-M0-এ ভাগের instruction নেই, আর runtime library link হয়নি
  • Linker script-এ flash-এর মাপ ভুল
  • stdint.h খুঁজে পাওয়া যায়নি

শব্দকোষ

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

মনে রাখুন

  1. Host আর target: compiler চলে PC-তে, কোড বানায় chip-এর জন্য; --target=thumbv7m-none-eabi -mcpu=cortex-m3 -mfloat-abi=soft সেই মাপের কাগজ, আর header-এর পথ (-isystem বা sysroot) আলাদা করে দিতে হয়।
  2. চার ধাপ: -E → .i (macro খোলা), -S → .s, -c → .o (ঠিকানা 0, symbol আর relocation), link → .elf + .map.
  3. Link error: undefined = কেউ সংজ্ঞা দেয়নি, duplicate = দুজনে দিয়েছে; Cortex-M0-তে ভাগের জন্য __aeabi_uidiv-এর মতো runtime helper লাগে।
  4. ELF থেকে flash: .bin প্রতিটি segment-কে LMA-তে বসায় (এখানে 1204 B); Intel HEX-এ ঠিকানা আর checksum; বিশাল .bin মানে কোনো LMA ভুল।
  5. Build: Makefile বা build script দিয়ে incremental build (-MMD-এর .d); reproducible রাখতে version, ফাইলের ক্রম, __DATE__ আর debug path সামলানো, আর hash মেলানো।

পরের পর্বে: Firmware বানিয়ে flash-এ বসানো হলো; কিন্তু chip-এ কোনো screen নেই, তাহলে ভুল খুঁজবেন কীভাবে? UART-এ printf, LED-এর সংকেত, JTAG আর SWD, GDB-র breakpoint আর watchpoint, আর HardFault-এর stacked PC থেকে ভুলের লাইন খোঁজা, পর্ব ৩৮-এ (এমবেডেড debugging).

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

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