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

Memory map আর linker script — flash, SRAM আর peripheral register

Memory Map and Linker Script — Flash, SRAM, Peripheral Registers, Sections, LMA vs VMA and Map Files on ARM Cortex-M

Taught in Bangla, this lesson maps the fixed ARMv7-M address space and the virtual BG-M3 board's 128 KiB flash and 20 KiB SRAM. Clang-built firmware shows where each variable lands, reads the .data initial values stored at LMA 0x080007F0, and proves that skipping the startup copy turns an 81.88 Tk price into 0.00. It reads an ld.lld map file line by line (2040 bytes of flash, 20460 bytes left for the stack), places calibration data in its own flash section, and shows a linker check stopping a build.

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

  • Cortex-M-এর নির্দিষ্ট memory map-এর region আর বাজারঘর board-এর আসল flash, SRAM ও peripheral-এর ঠিকানা
  • .text, .rodata, .data, .bss, .noinit আর stack: কোন C variable কোথায় যায় আর কেন
  • LMA আর VMA-র পার্থক্য, আর reset-এর পরে .data কেন flash থেকে SRAM-এ কপি করতে হয়
  • Reference lab-এর linker script লাইন ধরে পড়া, আর একটি variable-কে নিজের পছন্দের section বা ঠিকানায় বসানো
  • আসল map file পড়ে flash, SRAM আর stack-এর হিসাব, আর link-এর সময় জায়গা না ধরার ভুল চেনা

১ · Memory map কী — পোস্ট অফিসের ঠিকানা-বই

CPU-র কাছে পুরো দুনিয়াটা কেবল ঠিকানার একটি লম্বা সারি। ৩২-bit Cortex-M যে ঠিকানাই পাঠাক, তার উত্তর আসে কোনো একটি জিনিস থেকে: program-এর flash, variable-এর SRAM, অথবা UART বা ADC-এর মতো কোনো peripheral-এর register. কোন ঠিকানা কার, সেই তালিকাই memory map.

উপমা — পোস্ট অফিসের ঠিকানা-বই: ঢাকার পোস্ট কোড দেখেই পিয়ন বোঝেন চিঠি কোন এলাকায় যাবে: 1000-এর ঘরে মতিঝিল-জিপিও, 1205 ধানমন্ডি, 1230 উত্তরা। দেশজুড়ে পোস্ট কোডের ভাগ আগে থেকে ঠিক করা, তাই যে-কোনো জেলার চিঠিও সঠিক থলেতে ওঠে। Cortex-M-এর memory map ঠিক এমন: ঠিকানার প্রথম কয়েকটি bit দেখেই বোঝা যায় সেটি program-এর জায়গা, ডেটার জায়গা, না যন্ত্রের register. আর linker script হলো সেই ঠিকানা-বই, যেটি দেখে linker ঠিক করে আপনার প্রতিটি function আর variable কোন বাড়িতে উঠবে।

পর্ব ২২-এ (Memory interfacing আর address decoding) 8085-এর জন্য memory map নিজে হাতে বানিয়েছেন: 74LS138 decoder দিয়ে ঠিক করেছেন কোন ঠিকানায় ROM আর কোন ঠিকানায় RAM. সেখানে নকশাকার board-এর তার দিয়ে মানচিত্র আঁকতেন, তাই প্রতিটি board-এর মানচিত্র আলাদা হতে পারত। Microcontroller-এ সেই decoding chip-এর ভেতরেই করা, আর ARM পুরো কাঠামোটি স্থাপত্যের নিয়মে বেঁধে দিয়েছে। তাই এই পর্বের প্রশ্ন আর “decoder-এ কোন তার কোথায়” নয়, বরং “আমার কোড আর ডেটা কোন region-এ কীভাবে সাজাব”।

লেখার নিয়ম: এই মডিউল থেকে hex লেখা হবে C-র ধাঁচে, 0x দিয়ে শুরু করে: 0x08000000, 0x20000000. 8085/8086-এর পর্বগুলোতে যেমন 2050H লেখা হতো, এখানে তা আর নয়। সব ঠিকানা আর আকার এসেছে নিজের lab-এ আসল build থেকে: Clang 22.1.8 (PyPI-র ziglang 0.17.1, MIT; LLVM অংশ Apache-2.0 with LLVM exception) দিয়ে compile, LLD দিয়ে link, আর কোর্সের virtual বাজারঘর board BG-M3-এ (Unicorn 2.1.4, binding BSD, engine GPLv2) চালানো। BG-M3 কোনো আসল পণ্য নয়; আসল Cortex-M3 chip-এর আদলে বানানো শেখার মডেল (পর্ব ০৬ দেখুন)।

এই পর্বে তিনটি স্তর একসাথে দেখবেন। প্রথমে স্থাপত্যের স্তর: ARM কোন region কোথায় রেখেছে। তারপর chip-এর স্তর: সেই region-এর ভেতরে একটি নির্দিষ্ট chip কতটুকু আসল মেমরি বসিয়েছে। শেষে program-এর স্তর: আপনার firmware-এর কোন অংশ সেই মেমরির কোন জায়গায় বসল। Linker script দ্বিতীয় স্তরের বর্ণনা দেয় আর তৃতীয় স্তরের নিয়ম ঠিক করে। Map file তৃতীয় স্তরের ফলাফল লিখে রাখে।

২ · ARMv7-M-এর নির্দিষ্ট memory map — ৪ GB-এর সাত ভাগ

৩২-bit ঠিকানা মানে 232 = 4 GiB ঠিকানা। ARMv7-M Architecture Reference Manual (Cortex-M3 আর M4 এই স্থাপত্যের) একটি default memory map দেয়, যা নিচের ছকে। প্রথম তিনটি region প্রতিটি 0.5 GiB. এই ভাগ শুধু নাম নয়: প্রতিটি region-এর জন্য স্থাপত্য আলাদা আচরণ ঠিক করে, যেমন কোন region থেকে instruction চালানো যায় আর কোন region-এ access-এর ক্রম কঠোরভাবে রাখা হয়।

ঠিকানাRegionসাধারণত যা থাকেBG-M3-এ
0x00000000–0x1FFFFFFFCodeflash-এ program, const ডেটা, vector tableflash 0x08000000, 128 KiB
0x20000000–0x3FFFFFFFSRAMvariable, stack, heapSRAM 0x20000000, 20 KiB
0x40000000–0x5FFFFFFFPeripheralchip-এর peripheral registerUART, GPIO, ADC… 0x40000000-এর 1 MiB-এ
0x60000000–0x9FFFFFFFExternal RAMবাইরের RAM (ঐচ্ছিক)নেই
0xA0000000–0xDFFFFFFFExternal deviceবাইরের deviceনেই
0xE0000000–0xE00FFFFFPrivate Peripheral Buscore-এর নিজের অংশ: NVIC, SysTick, SCBSCS 0xE000E000-এর 4 KiB
0xE0100000–0xFFFFFFFFVendor-specificchip-নির্মাতার নিজস্ব system অংশনেই

Region-এর এই কাঠামো স্থির, কিন্তু প্রতিটি region-এর ভেতরে কতটা আসলে ভরা থাকবে, সেটি chip-ভেদে আলাদা। STM32F103-এর মতো chip-এ flash থাকে 0x08000000-এ, আর BOOT pin অনুযায়ী তা 0x00000000-এও “ছায়া” হিসেবে দেখা যায় (ST-এর reference manual RM0008-এর boot configuration অংশ)। বাজারঘর board একই অভ্যাস নিয়েছে: flash 0x08000000-এ। তবে board-এ ছায়া নেই; reset-এর সময় CPU সরাসরি 0x08000000 থেকে প্রথম দুটি word পড়ে, আর VTOR শুরু থেকেই 0x08000000 (reference lab-এর README, Spec decision 18).

সবচেয়ে কাজের region হলো Private Peripheral Bus (PPB). এর ভেতরে System Control Space (SCS, 0xE000E000 থেকে 4 KiB), যেখানে SysTick (0xE000E010), NVIC (0xE000E100) আর SCB (0xE000ED00) বসে। এগুলো core-এর অংশ, chip-নির্মাতার নয়। তাই ST, NXP বা অন্য যে-কোনো নির্মাতার Cortex-M3-এ SysTick-এর LOAD register একই ঠিকানা 0xE000E014-এ। BG-M3-ও এই অংশে আসল ARM ঠিকানা মেনেছে। অন্যদিকে UART বা GPIO-র ঠিকানা নির্মাতা নিজে ঠিক করেন, তাই chip বদলালে তা reference manual থেকে নতুন করে নিতে হয়। এগুলো যে সাধারণ load/store দিয়ে চলে, সেটিই memory-mapped I/O (পর্ব ২৩)।

ছবি ৩১.১ — ARMv7-M-এর memory map আর বাজারঘর board-এ যা সত্যিই আছে

বাঁয়ে স্থাপত্যের region (মাপে আঁকা নয়), ডানে BG-M3-এর ভরা অংশ

ARMv7-M memory map আর BG-M3 শুরু (0x) Region BG-M3-এ Vendor PPB External device External RAM Peripheral SRAM Code E0100000 E0000000 A0000000 60000000 40000000 20000000 00000000 SCS 0xE000E000 SysTick NVIC SCB কিছু নেই → HardFault UART GPIO ADC… 0x40000000 থেকে SRAM 20 KiB 0x20000000 থেকে flash 128 KiB 0x08000000 থেকে

একটি ঠিকানা দেখে region আর board-এর আসল জিনিস চেনার কাজটি নিচের program করে। ঠিকানাগুলো এই পর্বের আসল build থেকে নেওয়া (পরের অংশে দেখবেন), শেষ দুটি ইচ্ছে করে ভুল:

# ARMv7-M-এর নির্দিষ্ট memory map: ঠিকানা দেখে region চেনা
ARCH = [  # (শুরু, শেষ, নাম) — ARMv7-M ARM-এর default map
    (0x00000000, 0x1FFFFFFF, "Code"),
    (0x20000000, 0x3FFFFFFF, "SRAM"),
    (0x40000000, 0x5FFFFFFF, "Peripheral"),
    (0x60000000, 0x9FFFFFFF, "External RAM"),
    (0xA0000000, 0xDFFFFFFF, "External device"),
    (0xE0000000, 0xE00FFFFF, "PPB"),
    (0xE0100000, 0xFFFFFFFF, "Vendor"),
]
BOARD = [  # BG-M3-এ সত্যিই যা বসানো (reference README)
    (0x08000000, 128 * 1024, "flash"),
    (0x20000000, 20 * 1024, "SRAM"),
    (0x40000000, 0x100000, "peripheral register"),
    (0xE000E000, 0x1000, "SCS (SysTick, NVIC, SCB)"),
]

def region(a):
    return next(n for lo, hi, n in ARCH if lo <= a <= hi)

def on_board(a):
    for base, size, n in BOARD:
        if base <= a < base + size:
            return f"{n} +0x{a - base:X}"
    return "কিছু নেই -> fault"

for name, a in [("shop[0]", 0x08000708), ("rate_paisa", 0x20000000),
                ("net_g (local)", 0x20004FFC), ("UART DR", 0x40004404),
                ("SysTick LOAD", 0xE000E014), ("SRAM-এর ঠিক পরে", 0x20005000),
                ("ভুল pointer", 0x60000000)]:
    print(f"{name:16} 0x{a:08X}  {region(a):11} | {on_board(a)}")
print("প্রতিটি region:", [(hi - lo + 1) // 2**20 for lo, hi, _ in ARCH], "MiB")

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

shop[0]          0x08000708  Code        | flash +0x708
rate_paisa       0x20000000  SRAM        | SRAM +0x0
net_g (local)    0x20004FFC  SRAM        | SRAM +0x4FFC
UART DR          0x40004404  Peripheral  | peripheral register +0x4404
SysTick LOAD     0xE000E014  PPB         | SCS (SysTick, NVIC, SCB) +0x14
SRAM-এর ঠিক পরে  0x20005000  SRAM        | কিছু নেই -> fault
ভুল pointer      0x60000000  External RAM | কিছু নেই -> fault
প্রতিটি region: [512, 512, 512, 1024, 1024, 1, 511] MiB

দুটি স্তর আলাদা করে দেখুন। 0x20005000 স্থাপত্যের হিসাবে SRAM region-এর ভেতরে, কিন্তু board-এর 20 KiB SRAM শেষ হয়েছে 0x20004FFF-এ। Region-এ জায়গা থাকা মানে সেখানে মেমরি আছে, এমন নয়। শেষ লাইনে মাপ: প্রথম তিনটি region 512 MiB করে, PPB মাত্র 1 MiB.

“কিছু নেই” বললে কী ঘটে, board-এ চালিয়ে দেখা হলো। একটি ছোট firmware 0x20005000 থেকে একটি word পড়ে (সত্যিকারের run, past_sram.c):

~/lab/_ref $ python -B board.py run ../mmap/build/past_sram.elf --cycles 100000
[     0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
[     0.0208 ms] UART: reading 0x20005000...
[     0.0214 ms] HardFault: Invalid memory read (UC_ERR_READ_UNMAPPED) at PC=0x08000078 main+0x18
[    12.5000 ms] stopped: cycle limit (100000) reached after 100000 cycles

Board সব রকম fault-কে HardFault-এ পাঠায়, আলাদা BusFault নেই (Spec decision 19). Startup-এর Default_Handler একটি অসীম loop, তাই run থামল cycle-সীমায়। আসল Cortex-M3-এ এমন ভুল access সাধারণত bus error হয়ে BusFault বা HardFault আনে; fault-এর পুরো গল্প পর্ব ৩০-এ (Cortex-M-এর exception আর NVIC) আর পর্ব ৬১-এ (Watchdog আর fault handling).

৩ · Section — কোন variable কোথায় বসে

Compiler প্রতিটি function আর variable-কে একটি নামওয়ালা ঝুড়িতে রাখে, যাকে বলে section. Linker পরে সব object file-এর একই ধরনের ঝুড়ি এক জায়গায় জড়ো করে memory map-এ বসায়। Microcontroller-এ পাঁচটি ঝুড়ি আর একটি এলাকা চেনা জরুরি:

Sectionকী থাকেকোথায়Reset-এর পরে
.isr_vectorvector table: প্রথম word-এ stack-এর শুরু, তারপর handler-এর ঠিকানাflash-এর একেবারে শুরুযেমন আছে
.textmachine codeflashযেমন আছে
.rodataconst ডেটা, string literal (read-only data)flashযেমন আছে
.dataশুরুর মান দেওয়া global/static variable (data segment)চলে SRAM-এ, মান রাখা flash-এflash থেকে কপি
.bssমান না দেওয়া বা শূন্য দেওয়া global/static (BSS)SRAMশূন্য করা হয়
.noinitযা reset পার হয়ে টিকে থাকবে (no-init)SRAMকেউ ছোঁয় না
stacklocal variable, function-এর ফেরার ঠিকানা, interrupt frame (stack)SRAM-এর মাথা থেকে নিচেMSP = _estack

তত্ত্ব যথেষ্ট; এবার বাজারঘরের smart scale-এর কয়েকটি variable নিয়ে একটি firmware বানানো হলো, যা প্রতিটির ঠিকানা আর মান UART-এ ছাপে। ঠিকানা ছাপার জন্য সামান্য hex-printer যোগ করা; বাকি সব reference lab-এর bglib দিয়ে। Rate আর tare বাজারঘরের নির্ধারিত সংখ্যা: 6550 paisa/kg আর 150 g.

/* where.c - where does each variable of the bazarghar scale live? */
#include "bazarghar.h"
#include "bglib.h"

const char shop[] = "BazarGhar";                 /* .rodata -> flash */
static const uint16_t cal[2] = {400, 1800};      /* .rodata -> flash */
uint32_t rate_paisa = 6550;                      /* .data: runs in SRAM, stored in flash */
int32_t  tare_g = 150;                           /* .data */
uint32_t sample_count;                           /* .bss: zeroed at boot */
int32_t  last_net_g;                             /* .bss */
__attribute__((section(".noinit"))) uint32_t boot_count;  /* untouched */

int main(void)
{
    volatile int32_t net_g = 1400 - tare_g;      /* local: on the stack */
    uart_init();
    sample_count++;
    last_net_g = net_g;
    show("shop[0]      @ ", shop, shop[0]);      /* show(): name, address, value */
    show("rate_paisa   @ ", &rate_paisa, (int32_t)rate_paisa);
    /* ... the other variables and _sidata, _sdata.._edata, _sbss.._ebss ... */
    uart_puts("price = ");
    uart_put_fixed2((net_g * (int32_t)rate_paisa + 500) / 1000);
    uart_puts(" Tk\r\n");
    board_exit(0);
}

পুরো ফাইলে show() আর put_hex() দুটি ছোট function, আর বাকি variable-এর লাইন আছে (এখানে “...” দিয়ে সংক্ষেপ)। Build আর run reference lab-এর নিয়মেই (সত্যিকারের run; Clang 22.1.8 + LLD 22.1.8, ziglang 0.17.1):

~/lab/_ref $ python -B board.py build ../mmap/where.c -o ../mmap/build/where.elf
built ../mmap/build/where.elf
~/lab/_ref $ python -B board.py run ../mmap/build/where.elf
[     0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
[     0.0462 ms] UART: shop[0]      @ 0x08000708 = 66
[     0.0914 ms] UART: cal[1]       @ 0x080007EE = 1800
[     0.1365 ms] UART: rate_paisa   @ 0x20000000 = 6550
[     0.1786 ms] UART: tare_g       @ 0x20000004 = 150
[     0.2164 ms] UART: sample_count @ 0x20000008 = 1
[     0.2612 ms] UART: last_net_g   @ 0x2000000C = 1250
[     0.2991 ms] UART: boot_count   @ 0x20000010 = 0
[     0.3440 ms] UART: net_g (local)@ 0x20004FFC = 1250
[     0.3890 ms] UART: _sidata      @ 0x080007F0 = 6550
[     0.4271 ms] UART: _sdata..edata  0x20000000 = 8
[     0.4652 ms] UART: _sbss..ebss    0x20000008 = 8
[     0.4893 ms] UART: price = 81.88 Tk
[     0.4901 ms] exit(0) after 3921 cycles

দাম 81.88 টাকা: 1250 g নিট ওজন × 6550 paisa/kg, README-র নির্ধারিত হিসাবের সঙ্গে হুবহু মেলে। এখন প্রতিটি লাইন কেন এমন, stepper-এ এক এক করে দেখুন:

5const char shop[] = "BazarGhar";6static const uint16_t cal[2] = {400,1800};7uint32_t rate_paisa = 6550;8int32_t  tare_g = 150;9uint32_t sample_count;10int32_t  last_net_g;11section(".noinit") boot_count;15volatile int32_t net_g = ...;
Build আর run থেকে
Section
মেমরি
ঠিকানা
মান
  1. const string. shop কখনো বদলাবে না, তাই compiler এটিকে .rodata.shop section-এ রাখে, আর linker script .rodata-কে flash-এ পাঠায়। ঠিকানা 0x08000708, প্রথম অক্ষর 'B' = 66. এক byte SRAM-ও খরচ হয়নি।
  2. static const টেবিল. cal-এর ঠিকানা 0x080007EC; আউটপুটের cal[1] 2 byte পরে, 0x080007EE-তে, মান 1800. খালি পাল্লায় 400 count আর 2000 g-এ 1800 count, বাজারঘরের নির্ধারিত calibration. static শুধু নামের দৃশ্যমানতা কমায়; জায়গা ঠিক করে const.
  3. মানসহ global. rate_paisa-কে program বদলাতে পারে, তাই তাকে SRAM-এ থাকতে হবে: 0x20000000. কিন্তু 6550 মানটি বিদ্যুৎ গেলে SRAM থেকে মুছে যায়, তাই মানটি flash-এ রাখা থাকে, আর reset-এ কপি হয়। এটিই .data.
  4. আরেকটি .data. tare_g ঠিক পরের word, 0x20000004, মান 150. দুটি মিলে .data 8 byte; আউটপুটের _sdata..edata ... = 8 লাইন সেটিই বলে।
  5. মান ছাড়া global. sample_count আর last_net_g-এর কোনো শুরুর মান লেখা নেই; C-র নিয়মে তারা শূন্য দিয়ে শুরু করে। ফ্ল্যাশে আটটি শূন্য রাখা অপচয়, তাই এরা .bss-এ: 0x20000008 আর 0x2000000C. Startup শুধু এলাকাটি শূন্য করে। main চলার পরে মান 1 আর 1250.
  6. নিজে ঠিক করা section. boot_count-কে __attribute__((section(".noinit"))) দিয়ে .noinit-এ পাঠানো হলো: 0x20000010. Startup একে শূন্য করে না। Board-এ power-on-এর সময় পুরো SRAM শূন্য (Spec decision 18), তাই 0 দেখাল; আসল chip-এ প্রথম power-on-এ এখানে যা খুশি থাকতে পারে।
  7. Local variable. net_g কোনো section-এ নেই; function চলার সময় stack-এ জায়গা পায়। Stack শুরু হয় SRAM-এর মাথা 0x20005000 থেকে নিচের দিকে, তাই প্রথম word 0x20004FFC. volatile না দিলে -O2-এ এটি হয়তো register-এই থেকে যেত, ঠিকানাই থাকত না।

একটি const-এর দাম: 1 KiB-এর একটি দামের টেবিল const ছাড়া লিখলে তা .data-তে যায়: flash-এ 1 KiB (মানের জন্য) আর SRAM-এ আরও 1 KiB. BG-M3-এর মাত্র 20 KiB SRAM-এ এটি অনেক। যে ডেটা বদলাবে না, তাতে const দেওয়া microcontroller-এ শুধু ভালো অভ্যাস নয়, মেমরির হিসাব। পরের ধাপের embedded C (পর্ব ৩৪) এ নিয়ে আরও বলবে।

৪ · LMA বনাম VMA — .data-র দুই ঠিকানা

.data-র প্রতিটি byte-এর দুটি ঠিকানা। VMA (virtual memory address; microcontroller-এ “চলার ঠিকানা”) হলো যেখানে program variable-টিকে পড়ে আর লেখে: SRAM-এর 0x20000000. LMA (load memory address, “রাখার ঠিকানা”) হলো যেখানে flash programmer মানটি লেখে আর বিদ্যুৎ ছাড়াও তা টিকে থাকে: flash-এর 0x080007F0. Code আর const-এর ক্ষেত্রে দুটি ঠিকানা একই, কারণ তারা flash থেকেই সরাসরি চলে বা পড়া হয়।

উপমা — দোকানের গুদাম আর তাক: বাজারঘরের মালিক রাতে আলুর বস্তা রাখেন তালা দেওয়া গুদামে (flash). সকালে দোকান খোলার সময় কর্মচারী কয়েক কেজি আলু এনে সামনের তাকে সাজান (SRAM). সারাদিন বেচাকেনা হয় তাক থেকে, তাকে কম-বেশি হয়। গুদামের ঠিকানা LMA, তাকের ঠিকানা VMA, আর সকালের সেই সাজানোর কাজটিই startup code-এর কপি-loop. কর্মচারী একদিন ভুলে গেলে তাক খালি থাকে, যদিও গুদামে আলু ভরা।

আসল ELF ফাইলেই দুটি ঠিকানা লেখা থাকে। একটি ছোট stdlib Python ELF reader (elfsec.py, ৪০ লাইনের) section header আর LOAD segment পড়ে। Segment-এর PhysAddr কলামই LMA (সত্যিকারের run):

~/lab/mmap $ python -B elfsec.py build/where.elf rate_paisa _sidata _estack
entry = 0x0800025D
Section          Type      Flags  Addr(VMA)   Size
.isr_vector      PROGBITS  A      0x08000000     96
.text            PROGBITS  AX     0x08000060   1936
.data            PROGBITS  AW     0x20000000      8
.bss             NOBITS    AW     0x20000008      8
.noinit          NOBITS    AW     0x20000010      4
LOAD segments:  VirtAddr    PhysAddr(LMA) FileSiz MemSiz
                0x08000000  0x08000000       96     96
                0x08000060  0x08000060     1936   1936
                0x20000000  0x080007F0        8      8
                0x20000008  0x20000008        0     12
text=2032 data=8 bss+noinit=12  flash=2040  sram(static)=20
symbol rate_paisa   0x20000000 size 4
symbol _sidata      0x080007F0 size 0
symbol _estack      0x20005000 size 0

তৃতীয় segment-টি দেখুন: চলবে 0x20000000-এ, কিন্তু রাখা 0x080007F0-এ। চতুর্থটির FileSiz 0: .bss আর .noinit-এর জন্য ফাইলে একটি byte-ও নেই (NOBITS), শুধু 12 byte জায়গার হিসাব। entry-র শেষ bit 1 (0x0800025D), কারণ Thumb code-এর ঠিকানায় bit 0 = 1 থাকে (পর্ব ২৯)। Board ELF লোড করার সময় flash programmer-এর মতোই প্রতিটি segment-কে তার LMA-তে লেখে। Flash-এর 0x080007F0-এ আসলে কী আছে, ছোট আরেকটি reader দিয়ে দেখা হলো:

~/lab/mmap $ python -B peek.py build/where.elf 0x080007F0 8
flash 0x080007F0: 96 19 00 00 96 00 00 00
  word 0x080007F0 = 0x00001996 = 6550
  word 0x080007F4 = 0x00000096 = 150
~/lab/mmap $ python -B peek.py build/where.elf 0x08000000 8
flash 0x08000000: 00 50 00 20 5D 02 00 08
  word 0x08000000 = 0x20005000 = 536891392
  word 0x08000004 = 0x0800025D = 134218333

6550 = 0x1996, আর little-endian ক্রমে ছোট byte আগে: 96 19 00 00. ঠিক পরে 150 = 0x96. Flash-এর একেবারে শুরুতে vector table-এর প্রথম দুটি word: stack-এর শুরু 0x20005000 আর Reset_Handler-এর ঠিকানা 0x0800025D. Reset-এ CPU এ দুটিই পড়ে MSP আর PC-তে নেয় (Spec decision 18).

ছবি ৩১.২ — where.elf: flash আর SRAM-এ কী কোথায়

আসল build-এর ঠিকানা; বাক্সগুলো মাপে আঁকা নয়

where.elf-এর flash আর SRAM বিন্যাস flash SRAM খালি 128 KiB পর্যন্ত .data-র মান LMA, 8 B .text + .rodata 1936 B .isr_vector 96 B 080007F0 08000060 08000000 20000000 stack ↓ (MSP) 20005000 খালি .noinit 4 B .bss 8 B .data 8 B VMA Reset_Handler কপি করে: LMA → VMA

কপি কে করে? Reference lab-এর startup.c-এর Reset_Handler, যা main-এর আগে চলে। এর তিনটি কাজ: .data কপি, .bss শূন্য, তারপর main() ডাকা। এর পুরো লাইন ধরে পড়া আর reset থেকে প্রথম instruction পর্যন্ত trace পর্ব ৩২-এর (Boot আর startup code) বিষয়; এখানে শুধু memory map-এর চোখে কপিটি দেখুন:

52uint32_t *src = &_sidata;53uint32_t *dst = &_sdata;54while (dst < &_edata)55    *dst++ = *src++;56for (dst = &_sbss; dst < &_ebss; )57    *dst++ = 0;58main();
Pointer আর SRAM
src
dst
rate_paisa
tare_g
sample_count
last_net_g
  1. শুরু. src flash-এর _sidata = 0x080007F0-এ, dst SRAM-এর _sdata = 0x20000000-এ। এই চিহ্নগুলো linker script বানায়, C কোড শুধু তাদের ঠিকানা নেয়। Board-এ power-on-এ SRAM পুরো শূন্য (Spec decision 18), তাই সব variable এখন 0.
  2. প্রথম word কপি. Flash থেকে 96 19 00 00 = 6550 এল 0x20000000-এ: rate_paisa = 6550. দুটি pointer-ই 4 byte এগোল: src 0x080007F4, dst 0x20000004.
  3. দ্বিতীয় word কপি. 96 00 00 00 = 150 গেল tare_g-এ। dst এখন 0x20000008 = _edata, তাই while-এর শর্ত মিথ্যা; .data-র 8 byte কপি শেষ।
  4. .bss-এর প্রথম word. dst নতুন করে _sbss = 0x20000008. সেখানে 0 লেখা হলো: sample_count = 0. Board-এ আগেও 0 ছিল, কিন্তু আসল chip-এ বা watchdog reset-এর পরে এখানে পুরোনো মান থাকতে পারে; তাই এই loop বাধ্যতামূলক।
  5. .bss-এর দ্বিতীয় word. last_net_g = 0, dst 0x20000010 = _ebss; loop শেষ। .noinit (0x20000010 থেকে) এই loop-এর বাইরে, তাই সেখানে কেউ লেখে না।
  6. main(). এবার C-র প্রতিশ্রুতি পূরণ: মানসহ global-এ তার মান, বাকিগুলো শূন্য। main sample_count-কে 1 করে, last_net_g = 1400 − 150 = 1250 লেখে, আর দাম ছাপে 81.88 টাকা, যা আসল run-এর শেষ UART লাইন।

কপি-loop না থাকলে কী হয়, তা আন্দাজে না বলে চালিয়ে দেখা ভালো। নিজের lab-এ startup.c-এর একটি কপি নিয়ে while loop-টি মুছে দেওয়া হলো (reference lab অপরিবর্তিত), বাকি সব একই (সত্যিকারের run):

~/lab/mmap $ python -B mk.py fw build/nocopy.elf where.c startup_nocopy.c
built nocopy.elf
~/lab/mmap $ python -B ../_ref/board.py run build/nocopy.elf
[     0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
...
[     0.1275 ms] UART: rate_paisa   @ 0x20000000 = 0
[     0.1653 ms] UART: tare_g       @ 0x20000004 = 0
...
[     0.3756 ms] UART: _sidata      @ 0x080007AC = 6550
...
[     0.4738 ms] UART: price = 0.00 Tk
[     0.4746 ms] exit(0) after 3797 cycles

6550 flash-এ ঠিকই আছে (_sidata-তে), কিন্তু SRAM-এর rate_paisa 0. ফলে tare 0, নিট ওজন 1400 g, আর দাম 0.00 টাকা: দোকানদার বিনা পয়সায় আলু দিয়ে দেবেন। (এই build-এ startup ছোট হয়েছে, তাই _sidata সরে 0x080007AC.) Board-এ SRAM শুরুতে শূন্য বলে ভুলটি অন্তত একই রকম দেখায়; আসল chip-এ SRAM-এর শুরুর মান অনির্দিষ্ট, তখন কী হয় নিচের মডেলে দেখুন। মডেলটি where.elf-এর আসল flash byte নেয়, আর “আসল chip”-এর SRAM-এর আবর্জনা বানায় seed দেওয়া random সংখ্যা দিয়ে:

# .data কপি আর .bss শূন্য করা — where.elf-এর আসল byte দিয়ে ছোট মডেল
import random, struct
FLASH_DATA = bytes.fromhex("96190000 96000000")   # flash 0x080007F0..F7
SDATA, EDATA, SBSS, EBSS = 0x20000000, 0x20000008, 0x20000008, 0x20000010
NAMES = {0x20000000: "rate_paisa", 0x20000004: "tare_g",
         0x20000008: "sample_count", 0x2000000C: "last_net_g"}

def boot(sram, copy=True, zero=True):
    if copy:                                   # while (dst < &_edata) *dst++ = *src++;
        sram[0:EDATA - SDATA] = FLASH_DATA
    if zero:                                   # for (dst = &_sbss; dst < &_ebss;) *dst++ = 0;
        sram[SBSS - SDATA:EBSS - SDATA] = bytes(EBSS - SBSS)
    return {n: struct.unpack_from("<i", sram, a - SDATA)[0] for a, n in NAMES.items()}

def price(v):                                  # main(): net = 1400 - tare
    net = 1400 - v["tare_g"]
    if not (0 <= v["rate_paisa"] <= 100000 and 0 <= net <= 5000):
        return "price: অর্থহীন (SRAM-এর আবর্জনা)"
    return f"net={net} g price={(net * v['rate_paisa'] + 500) // 1000 / 100:.2f} Tk"

random.seed(31)
junk = lambda: bytearray(random.randrange(256) for _ in range(16))
for label, sram, c, z in [("BG-M3, ঠিক startup", bytearray(16), True, True),
                          ("BG-M3, copy বাদ", bytearray(16), False, True),
                          ("আসল chip-এর মতো, copy বাদ", junk(), False, True),
                          ("আসল chip-এর মতো, ঠিক startup", junk(), True, True)]:
    v = boot(sram, c, z)
    print(f"{label}:\n  {v}\n  {price(v)}")

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

BG-M3, ঠিক startup:
  {'rate_paisa': 6550, 'tare_g': 150, 'sample_count': 0, 'last_net_g': 0}
  net=1250 g price=81.88 Tk
BG-M3, copy বাদ:
  {'rate_paisa': 0, 'tare_g': 0, 'sample_count': 0, 'last_net_g': 0}
  net=1400 g price=0.00 Tk
আসল chip-এর মতো, copy বাদ:
  {'rate_paisa': -918949882, 'tare_g': 960960072, 'sample_count': 0, 'last_net_g': 0}
  price: অর্থহীন (SRAM-এর আবর্জনা)
আসল chip-এর মতো, ঠিক startup:
  {'rate_paisa': 6550, 'tare_g': 150, 'sample_count': 0, 'last_net_g': 0}
  net=1250 g price=81.88 Tk

প্রথম দুটি ফল board-এর আসল run-এর সঙ্গে মেলে (81.88 আর 0.00 টাকা)। তৃতীয়টি দেখায়, আসল chip-এ একই bug প্রতি power-on-এ ভিন্ন আবর্জনা দিতে পারে, যা খুঁজে পাওয়া আরও কঠিন। শেষ ফলটি বলে, আবর্জনা যত খারাপই হোক, ঠিক startup সব মুছে C-র প্রতিশ্রুতি ফিরিয়ে আনে। sample_count চারবারই 0, কারণ মডেলে .bss শূন্য করা হয়েছে প্রতিবার।

৫ · Reference linker script — লাইন ধরে পড়া

এতক্ষণ যা দেখলেন, তার প্রতিটি ঠিকানা এসেছে reference lab-এর bazarghar.ld থেকে। পুরো ফাইল মাত্র ৫২ লাইনের। প্রধান অংশটি নিচে, ঠিক যেমন আছে:

MEMORY
{
    FLASH (rx)  : ORIGIN = 0x08000000, LENGTH = 128K
    RAM   (rwx) : ORIGIN = 0x20000000, LENGTH = 20K
}
_estack = ORIGIN(RAM) + LENGTH(RAM);     /* stack grows down from the top of SRAM */
_min_stack = 2K;                         /* link fails if less than this is left */
ENTRY(Reset_Handler)
SECTIONS
{
    .isr_vector : { KEEP(*(.isr_vector)) } > FLASH
    .text :
    {
        *(.text*)
        *(.rodata*)
        . = ALIGN(4);
    } > FLASH
    /DISCARD/ : { *(.ARM.exidx*) *(.ARM.extab*) *(.comment) }
    _sidata = LOADADDR(.data);
    .data :
    {
        _sdata = .;
        *(.data*)
        . = ALIGN(4);
        _edata = .;
    } > RAM AT > FLASH
    .bss (NOLOAD) : { _sbss = .; *(.bss*) *(COMMON) . = ALIGN(4); _ebss = .; } > RAM
    .noinit (NOLOAD) : { *(.noinit*) . = ALIGN(4); } > RAM
    ASSERT(_estack - . >= _min_stack, "not enough SRAM left for the stack")
}

ফাঁকা লাইন আর মন্তব্য বাদ দেওয়া, আর .bss ও .noinit এক লাইনে গুটানো; অর্থ একই। প্রতিটি অংশের মানে:

লাইনমানে
MEMORY { ... }chip-এর আসল মেমরির বর্ণনা: দুটি memory region, শুরু আর মাপ। (rx) মানে পড়া আর চালানো যায়, (rwx)-এ লেখাও। এটি স্থাপত্যের map-এর ভেতরে chip-এর ভরা অংশ।
_estack = ...নতুন একটি symbol: 0x20000000 + 20 KiB = 0x20005000. Vector table-এর প্রথম word এটিই, তাই এখান থেকে stack শুরু।
_min_stack = 2Kstack-এর জন্য অন্তত 2 KiB রাখার নিয়ম, শেষের ASSERT-এ যাচাই হয়।
ENTRY(Reset_Handler)ELF-এর entry point. Cortex-M নিজে vector table থেকে শুরু করে, তবু debugger আর --gc-sections-এর জন্য এটি কাজে লাগে: entry থেকে পৌঁছানো যায় না এমন section ফেলে দেওয়া হয়।
KEEP(*(.isr_vector))সব ফাইলের .isr_vector flash-এর শুরুতে। কোনো কোড vector table-কে “ডাকে” না, তাই KEEP না দিলে --gc-sections একে মুছে দিত।
*(.text*) *(.rodata*)সব code আর read-only ডেটা একসাথে একটি output section .text-এ। এজন্যই map-এ আলাদা .rodata output section নেই; .rodata.shop বসেছে .text-এর ভেতরে।
. = ALIGN(4). হলো location counter, অর্থাৎ “এখন কোন ঠিকানায় আছি”। একে 4-এর গুণিতকে তোলা হলো, যাতে পরের word ঠিক alignment-এ বসে আর কপি-loop word ধরে চলতে পারে।
/DISCARD/exception-unwinding টেবিল আর compiler-এর মন্তব্য ফেলে দেওয়া; bare-metal C-তে এগুলো লাগে না।
_sidata = LOADADDR(.data).data-র LMA, অর্থাৎ flash-এ শুরুর মানগুলো কোথায়: 0x080007F0.
> RAM AT > FLASHপুরো পর্বের মূল লাইন: VMA বসবে RAM-এ, LMA বসবে FLASH-এ। _sdata/_edata ভেতরের . থেকে, তাই এরা VMA.
(NOLOAD).bss আর .noinit-এর জন্য ফাইলে কোনো byte নয়, flash-এ কিছু লেখা হবে না। *(COMMON) পুরোনো ধাঁচের “common” symbol-কেও .bss-এ আনে।
ASSERT(...)সব বসানোর পরে . যেখানে থামল, তার থেকে _estack পর্যন্ত জায়গা 2 KiB-এর কম হলে link ব্যর্থ। Stack-এর জায়গা না থাকলে ভুলটি run-এর সময় নয়, build-এর সময়েই ধরা পড়ে।

লক্ষ করুন, এই script-এ আলাদা .stack বা .heap section নেই। Stack হলো সব section-এর পরে বাকি থাকা SRAM, ওপর থেকে নিচে বাড়ে, আর ASSERT শুধু ন্যূনতম মাপটি পাহারা দেয়। অনেক vendor-এর তৈরি linker script-এ এর বদলে একটি খালি section রাখা হয় (যেমন STM32-এর কিছু generated script-এ ._user_heap_stack নামে), যার মাপ ন্যূনতম heap আর stack-এর যোগফল; উদ্দেশ্য একই। Bare-metal firmware-এ heap প্রায়ই একেবারে বাদ দেওয়া হয়, কেন, তা পর্ব ৩৯-এ (এমবেডেড memory).

আরও গভীরে: MEMORY, SECTIONS, AT > আর LOADADDR হলো GNU ld-এর linker script ভাষার অংশ, আর LLVM-এর LLD বেশিরভাগ বাক্য একই অর্থে মানে; তাই একই bazarghar.ld দুটি linker-এ চলার কথা, যদিও খুঁটিনাটি আচরণে পার্থক্য থাকতে পারে বলে LLD-র নিজের নথি সতর্ক করে। ARM-এর নিজস্ব toolchain (armlink) একই কাজ করে আলাদা ভাষার “scatter file” দিয়ে, যেখানে load region আর execution region সরাসরি LMA আর VMA-র নাম। Desktop-এ Linux-এর loader প্রোগ্রাম মেমরিতে তোলার সময় যে কাজ করে (Programming Languages & Compilers কোর্সের পর্ব ৭৪), microcontroller-এ তার একটি ছোট অংশ startup code নিজেই করে: .data কপি আর .bss শূন্য।

৬ · Map file পড়া — flash, SRAM আর stack-এর হিসাব

Linker যা করল তার পুরো হিসাব রাখে map file. Reference lab-এর build সবসময় -Map=NAME.map দেয়, তাই where.elf-এর পাশে where.map তৈরি হয়েছে। LLD-র map-এর প্রথম লাইনে কলামের নাম, আর সব সংখ্যা hex, কিন্তু 0x ছাড়া। আসল ফাইলের বাছাই করা লাইন (সত্যিকারের run, LLD 22.1.8; মোট ৮০টির মতো লাইন):

     VMA      LMA     Size Align Out     In      Symbol
       0        0        0     1 _estack = ORIGIN(RAM) + LENGTH(RAM)
 8000000  8000000       60     4 .isr_vector
 8000000  8000000       60     1                 g_vectors
 8000060  8000060      790     4 .text
 8000060  8000060      166     4         where.where.o:(.text.main)
 8000061  8000061      166     1                 main
 800025c  800025c       82     4         where.startup.o:(.text.Reset_Handler)
 8000358  8000358      1fe     4         where.bglib.o:(.text.uart_put_i32)
 8000708  8000708        a     1         where.where.o:(.rodata.shop)
 8000712  8000712       da     1         <internal>:(.rodata.str1.1)
 80007ec  80007ec        4     2         where.where.o:(.rodata.cal)
 80007f0  80007f0        0     1 _sidata = LOADADDR(.data)
20000000  80007f0        8     4 .data
20000000  80007f0        4     1                 rate_paisa
20000004  80007f4        4     1                 tare_g
20000008 20000008        8     4 .bss
20000010 20000010        4     4 .noinit
20000010 20000010        4     1                 boot_count
1VMA LMA Size Align Out In Symbol28000000 8000000 60 .isr_vector38000060 8000060 790 .text4  166 (.text.main)5  a (.rodata.shop)6  da (.rodata.str1.1)720000000 80007f0 8 .data820000008 20000008 8 .bss920000010 20000010 4 .noinit
পড়ে যা পাওয়া গেল
লাইন
দশমিকে
flash খরচ
SRAM খরচ
  1. কলাম. VMA আর LMA দুটি ঠিকানা, Size মাপ, Align alignment. যে লাইনে নাম Out কলামে, সেটি output section; যার নাম In কলামে, সেটি কোনো object file-এর input section; আরও ডানে Symbol. সব সংখ্যা hex, 0x লেখা নেই।
  2. .isr_vector. 0x60 = 96 byte = ২৪টি ৪-byte entry: ১৬টি system exception আর ৮টি IRQ slot, যেমন startup.c-এর g_vectors[16 + 8]. VMA আর LMA দুটিই 8000000: flash-এর শুরু।
  3. .text. 0x790 = 1936 byte, 0x8000060 থেকে। নিচের In-লাইনগুলো বলে কে কতটা নিল: main 0x166 = 358 byte. flash খরচ এ পর্যন্ত 96 + 1936 = 2032 byte.
  4. Read-only ডেটা .text-এর ভেতরে. .rodata.shop 0xa = 10 byte: “BazarGhar”-এর ৯টি অক্ষর আর শেষের শূন্য। .rodata.str1.1 0xda = 218 byte: সব string literal, linker মিলিয়ে এক জায়গায় রেখেছে (<internal>).
  5. .data. এখানেই দুই কলাম আলাদা: VMA 20000000, LMA 80007f0. 8 byte flash-এ মানের জন্য, 8 byte SRAM-এ চলার জন্য। flash খরচ এখন 2032 + 8 = 2040 byte, SRAM 8 byte.
  6. .bss আর .noinit. VMA আর LMA একই, কারণ এরা NOLOAD; flash-এ কিছু নেই। SRAM-এ আরও 8 + 4 byte, মোট 20 byte; শেষ ঠিকানা 0x20000014.
  7. যোগফল. flash 2040 byte, 128 KiB-এর 1.56%. স্থির SRAM 20 byte, তাই stack পায় 0x20005000 − 0x20000014 = 0x4FEC = 20460 byte. এই সংখ্যা stack-এর জন্য বরাদ্দ জায়গা, stack কতটা সত্যি লাগবে তা নয়।

একই হিসাব হাতে না করে program দিয়ে করানো যায়। নিচের program আসল map-এর কয়েকটি লাইন পড়ে, output আর input section আলাদা করে, আর মোট খরচ ও সবচেয়ে বড় তিনটি অংশ বের করে:

# where.map-এর আসল লাইন (ld.lld 22, সংখ্যা hex, 0x ছাড়া) থেকে flash আর SRAM-এর হিসাব
MAP = """\
 8000000  8000000       60     4 .isr_vector
 8000060  8000060      790     4 .text
 8000060  8000060      166     4         where.where.o:(.text.main)
 80001c8  80001c8       8e     4         where.where.o:(.text.show)
 800025c  800025c       82     4         where.startup.o:(.text.Reset_Handler)
 8000358  8000358      1fe     4         where.bglib.o:(.text.uart_put_i32)
 8000558  8000558      1b0     4         where.bglib.o:(.text.uart_put_fixed2)
 8000712  8000712       da     1         <internal>:(.rodata.str1.1)
20000000  80007f0        8     4 .data
20000008 20000008        8     4 .bss
20000010 20000010        4     4 .noinit"""

out, parts = {}, []
for line in MAP.splitlines():
    vma, lma, size, _align, name = line.split(None, 4)
    vma, lma, size = int(vma, 16), int(lma, 16), int(size, 16)
    if name.startswith("."):
        out[name] = (vma, lma, size)          # output section
    else:
        parts.append((size, name.strip()))    # input section

FLASH, SRAM, ESTACK = 128 * 1024, 20 * 1024, 0x20005000
flash = out[".isr_vector"][2] + out[".text"][2] + out[".data"][2]
sram = out[".data"][2] + out[".bss"][2] + out[".noinit"][2]
end = out[".noinit"][0] + out[".noinit"][2]
print(f"flash: {flash} B = {100 * flash / FLASH:.2f}% of 128 KiB")
print(f"SRAM (static): {sram} B, stack gets 0x{end:08X}..0x{ESTACK:08X}"
      f" = {ESTACK - end} B")
v, l, s = out[".data"]
print(f".data runs at 0x{v:08X} but is stored at 0x{l:08X} ({s} B)")
for size, name in sorted(parts, reverse=True)[:3]:
    print(f"  largest: {size:4} B  {name}")

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

flash: 2040 B = 1.56% of 128 KiB
SRAM (static): 20 B, stack gets 0x20000014..0x20005000 = 20460 B
.data runs at 0x20000000 but is stored at 0x080007F0 (8 B)
  largest:  510 B  where.bglib.o:(.text.uart_put_i32)
  largest:  432 B  where.bglib.o:(.text.uart_put_fixed2)
  largest:  358 B  where.where.o:(.text.main)

সংখ্যাগুলো ELF reader-এর flash=2040 sram(static)=20-এর সঙ্গে হুবহু মেলে, দুটি আলাদা পথে একই উত্তর। সবচেয়ে বড় খরচ আমাদের কোড নয়, সংখ্যা ছাপার helper: uart_put_i32 510 byte. এই build-এর map-এ uart_put_u32-এর আলাদা লাইন নেই; compiler সম্ভবত দশমিক রূপান্তরের পুরো কোড uart_put_i32-এর ভেতরেই বসিয়ে (inline করে) দিয়েছে। Code size কমাতে চাইলে map file আগে বলে দেয় কোথায় হাত দিতে হবে।

Map file-এর একটি ফাঁদ: _sidata = LOADADDR(.data)-এর মতো section-এর বাইরের assignment লাইনে প্রথম কলাম symbol-এর মান নয়, সেই মুহূর্তের location counter. where.map-এ দুটি কাকতালীয়ভাবে মিলে গেছে (80007f0). নিজের lab-এ linker script-এ .text-এর পরে আরেকটি flash region-এর section যোগ করে build করতেই (পরের অংশের .calib) map দেখাল 801fc08 _sidata = LOADADDR(.data), অথচ ELF-এর symbol table বলল আসল মান _sidata 0x08000290, যা .data লাইনের LMA কলামের সঙ্গে মেলে। এ ধরনের symbol-এর মান পড়তে output section-এর LMA কলাম বা symbol table দেখুন। (_estack-এর লাইনেও প্রথম কলাম 0, অথচ মান 0x20005000.)

৭ · নিজের পছন্দের section আর ঠিকানায় variable বসানো

কখনো কখনো compiler-এর বাছাই যথেষ্ট নয়। বাজারঘরের smart scale-এর calibration (খালি পাল্লায় 400 count, 2000 g-এ 1800 count) কারখানায় একবার মাপা হয়। আপনি চান এটি flash-এর শেষ 1 KiB-এ আলাদা থাকুক, যাতে পরে নতুন firmware লিখলেও ওই অংশ না মোছে, আর কারখানার যন্ত্র নির্দিষ্ট ঠিকানায় মানগুলো লিখতে পারে। দুটি কাজ লাগে: C-তে variable-কে নতুন section-এ পাঠানো, আর linker script-এ সেই section-কে নির্দিষ্ট region-এ বসানো।

/* calib.c - scale calibration kept in its own flash page (.calib) */
#include "bazarghar.h"
#include "bglib.h"

struct scale_cal {
    uint16_t zero_counts;     /* ADC counts, empty platform   */
    uint16_t ref_counts;      /* ADC counts at the reference  */
    uint16_t ref_g;           /* reference weight in grams    */
    uint16_t version;
};

__attribute__((section(".calib"), used))
const struct scale_cal g_cal = {400, 1800, 2000, 1};

int main(void)
{
    const volatile struct scale_cal *c = &g_cal;   /* read it from flash */
    int32_t raw = 1380;
    int32_t span = (int32_t)c->ref_counts - (int32_t)c->zero_counts;
    uart_init();
    /* ... print the address of g_cal and its fields ... */
    uart_put_i32(div_round((raw - (int32_t)c->zero_counts) * (int32_t)c->ref_g, span));
    uart_puts(" g\r\n");
    board_exit(0);
}

Linker script-এ (নিজের lab-এর কপিতে) দুটি পরিবর্তন: MEMORY-তে FLASH 127 KiB-এ ছোট করে শেষ 1 KiB আলাদা region করা, আর .text-এর পরে একটি নতুন output section:

    FLASH (rx)  : ORIGIN = 0x08000000, LENGTH = 127K
    CALIB (r)   : ORIGIN = 0x0801FC00, LENGTH = 1K    /* last 1 KiB of flash */
    ...
    .calib : { KEEP(*(.calib)) } > CALIB

0x08000000 + 127 × 1024 = 0x0801FC00. KEEP আর C-র used দুটিই দরকার: কোড g_cal-কে শুধু একবার পড়ে, কিন্তু --gc-sections বা optimizer যেন কোনোভাবে একে বাদ না দেয়। Build আর run (সত্যিকারের run; reference board.build() নিজের lab-এর ফোল্ডার দিয়ে ডাকা):

~/lab/mmap $ python -B mk.py fw_calib build/calib.elf calib.c
built calib.elf
~/lab/mmap $ python -B ../_ref/board.py run build/calib.elf
[     0.0000 ms] power-on reset (বাজারঘর board BG-M3, 8 MHz)
[     0.0770 ms] UART: g_cal @ 0x0801FC00: zero=400 span=1400 ref=2000 g
[     0.1041 ms] UART: raw=1380 -> 1400 g
[     0.1050 ms] exit(0) after 840 cycles
~/lab/mmap $ grep -n -e "(.calib)" -e " .calib$" build/calib.map
48: 801fc00  801fc00        8     2 .calib
49: 801fc00  801fc00        8     2         calib.calib.o:(.calib)
~/lab/mmap $ python -B peek.py build/calib.elf 0x0801FC00 8
flash 0x0801FC00: 90 01 08 07 D0 07 01 00
  word 0x0801FC00 = 0x07080190 = 117965200
  word 0x0801FC04 = 0x000107D0 = 67536

g_cal ঠিক 0x0801FC00-এ। Byte-গুলো little-endian-এ চারটি ১৬-bit সংখ্যা: 0x0190 = 400, 0x0708 = 1800, 0x07D0 = 2000, 1. আর raw 1380 থেকে ওজন (1380 − 400) × 2000 ÷ 1400 = 1400 g, README-র scale run-এর “raw=1380 gross=1400 g”-এর সঙ্গে মেলে। আসল chip-এ এমন আলাদা জায়গা বাছার সময় flash-এর page বা sector-এর মাপ reference manual থেকে মিলিয়ে নিতে হয়, কারণ মোছা যায় পুরো page ধরে; এখানে 1 KiB board-এর জন্য বেছে নেওয়া মাপ।

তিনটি পরিচিত কৌশল এক ছকে:

  • section(".noinit"): reset পার হয়ে টিকে থাকা ডেটা, reference lab-এর watchdog.c এভাবেই boot-এর সংখ্যা গোনে (“boot #2, reset cause: WATCHDOG”).
  • নিজের section + নিজের region: calibration, serial number, বা bootloader আর application-এর মাঝে ভাগ করা জায়গা।
  • const বা const বাদ: section বদলানোর সবচেয়ে সহজ উপায়। tare_g-কে const করলে আসল build-এ তা চলে গেল 0x08000710-এ (flash), .data 8 থেকে 4 byte, স্থির SRAM 20 থেকে 16 byte.

Linker script-এর আসল মূল্য বোঝা যায় যখন জায়গা ফুরায়। দুটি ইচ্ছাকৃত ভুল build করা হলো। প্রথমটিতে 4700টি int32_t-এর একটি ওজন-log (18800 byte, .bss), দ্বিতীয়টিতে 33000টি uint32_t-এর একটি টেবিল (132000 byte, .rodata) (সত্যিকারের run):

~/lab/_ref $ python -B board.py build ../mmap/big_ram2.c -o ../mmap/build/big_ram2.elf
error: link failed:
ld.lld: error: not enough SRAM left for the stack
~/lab/_ref $ python -B board.py build ../mmap/big_flash.c -o ../mmap/build/big_flash.elf
error: link failed:
ld.lld: error: section '.text' will not fit in region 'FLASH': overflowed by 1492 bytes
ld.lld: error: section '.data' will not fit in region 'FLASH': overflowed by 1496 bytes

প্রথমটি আমাদের ASSERT-এর বার্তা: 18800 byte বসানোর পরে stack-এর জন্য থাকে 20480 − 18800 = 1680 byte, যা 2048-এর কম। একই firmware 4500টি entry (18000 byte) দিয়ে link হয়, _ebss = 0x20004650, stack পায় 2480 byte, আর board-এ চলে “log ok” ছাপে। দ্বিতীয়টি LLD নিজেই ধরে: MEMORY-তে FLASH-এর মাপ 128K লেখা বলে সীমা জানে। .data-র লাইনটিও এসেছে, কারণ তার LMA-ও FLASH-এ। এই দুই ভুল যদি link-এ না ধরা পড়ত, প্রথমটি run-এর সময় stack-কে .bss-এর ওপর চাপিয়ে দিত, যা খুঁজে বের করা অনেক কঠিন।

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

  • Cortex-M3-এ SRAM আর peripheral region কোথা থেকে শুরু? SRAM 0x20000000, peripheral 0x40000000; NVIC আর SysTick PPB-তে, 0xE000E000-এর SCS-এ।
  • .data আর .bss-এর পার্থক্য? .data-তে শুরুর মানসহ global, মান flash-এ রেখে reset-এ কপি; .bss-এ মানহীন বা শূন্য, reset-এ শুধু শূন্য করা হয়, flash-এ জায়গা নেয় না।
  • LMA আর VMA কী? LMA যেখানে image-এ রাখা (flash), VMA যেখানে চলার সময় থাকে (SRAM); .data-তে দুটি আলাদা, .text-এ একই।
  • Flash খরচ কীভাবে মাপবেন? .isr_vector + .text (rodata সহ) + .data-র মাপ; SRAM = .data + .bss (+ .noinit) + stack আর heap.
  • const int table[256] কোথায় যায়? Cortex-M-এ সাধারণত .rodata, তাই flash-এ; const না দিলে .data, তখন flash আর SRAM দুটিতেই জায়গা নেয়।

৮ · AI-এর যুগে — memory map আর linker script যাচাই

AI assistant linker script-এর সাধারণ কাঠামো ভালোই লেখে, কারণ এমন হাজারো script ইন্টারনেটে আছে। কিন্তু নির্দিষ্ট chip-এর ঠিকানা আর মাপ, আর ছোট একটি শব্দের তাৎপর্যে (AT >, KEEP, NOLOAD) সে প্রায়ই আত্মবিশ্বাসের সঙ্গে ভুল করে। এই পর্বের বিষয়ে চোখে পড়ার মতো ভুল:

AI-এর সাধারণ ভুলকীভাবে ধরবেন
এক chip-এর flash বা SRAM-এর মাপ অন্য variant-এ বসানো (যেমন 64 KB-এর chip-এ 128K)নির্দিষ্ট অংশ-নম্বরের datasheet; link-এর পরে map-এ region-এর মাপ
.data-র জন্য > RAM লিখে AT > FLASH ভুলে যাওয়াELF-এর LOAD segment-এ PhysAddr দেখা; BG-M3 এমন ELF লোডই করে না
Vector table-এ KEEP না দেওয়া, ফলে --gc-sections-এ টেবিল উধাওmap-এ .isr_vector-এর মাপ আর flash-এর প্রথম দুটি word পড়া
peripheral বা NVIC-এর ঠিকানা বানিয়ে দেওয়া, বা STM32-এর ঠিকানা অন্য chip-এ চালানোcore-এর অংশ ARMv7-M ARM থেকে, বাকিটা নিজের chip-এর reference manual থেকে
“const দিলেও SRAM লাগে” বা উল্টোটা, চিন্তা না করে সব platform-এ খাটানোনিজের build-এর map-এ variable কোন section-এ বসল দেখা
Startup code-এ .bss শূন্য বা .data কপির loop বাদ, বা ভুল symbol ব্যবহারsimulator-এ চালিয়ে মানসহ global-এর মান ছাপা
Map file-এর assignment লাইনের প্রথম কলামকে symbol-এর মান ধরাsymbol table বা output section-এর LMA কলামের সঙ্গে মেলানো

AI-কে দিয়ে linker script লেখাতে বা বোঝাতে চাইলে chip-এর তথ্য নিজে দিন, আর প্রতিটি দাবির উৎস চেয়ে নিন:

আমার microcontroller Cortex-M3. Flash 0x08000000 থেকে 128 KiB, SRAM 0x20000000 থেকে 20 KiB (এই সংখ্যা আমি datasheet থেকে নিয়েছি, তুমি বদলাবে না)। Toolchain: Clang + LLD. ১. একটি linker script লেখো যাতে vector table flash-এর শুরুতে থাকে, .data-র VMA SRAM-এ আর LMA flash-এ, .bss আর একটি .noinit section থাকে, আর stack-এর জন্য অন্তত 2 KiB না থাকলে link ব্যর্থ হয়। ২. প্রতিটি লাইনের পাশে এক লাইনে মানে লেখো, বিশেষ করে KEEP, AT >, NOLOAD আর LOADADDR কেন লাগে। ৩. Startup code-এর কোন symbol (_sidata, _sdata, _edata, _sbss, _ebss, _estack) কোথা থেকে আসে বলো। ৪. কোনো peripheral register-এর ঠিকানা অনুমান করে লিখবে না; নিশ্চিত না হলে “নিশ্চিত নই” লেখো। ৫. শেষে বলো, map file আর ELF-এর কোন লাইন দেখে আমি ফলাফল যাচাই করব।

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

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

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

প্র ০১8085 বা 8086-এর যুগে memory map ঠিক করতেন board-এর নকশাকার। ARM কেন Cortex-M-এর জন্য memory map স্থাপত্যেই বেঁধে দিল?

8085 বা 8086 নিজে জানত না তার ঠিকানার কোন অংশে ROM আর কোন অংশে RAM. CPU কেবল address bus-এ ঠিকানা পাঠাত; কোন chip সাড়া দেবে, তা ঠিক করত board-এর decoder-এর তার। ফলে একটি board-এর জন্য লেখা program অন্য board-এ নিলে অনেক সময় ঠিকানা বদলাতে হতো। পার্সোনাল কম্পিউটারের যুগে IBM PC-র মতো একটি জনপ্রিয় নকশা কার্যত মান হয়ে গিয়েছিল বলে সমস্যা কিছুটা ঢাকা পড়ে, কিন্তু embedded জগতে হাজারো আলাদা board ছিল।

ARM-এর ব্যবসার ধরন এই সমস্যাকে আরও বড় করত। ARM নিজে chip বানায় না; সে core-এর নকশা license দেয়, আর বহু নির্মাতা তার চারপাশে নিজের peripheral জোড়েন। প্রত্যেকে যদি NVIC বা SysTick নিজের পছন্দের ঠিকানায় রাখতেন, তাহলে একটি RTOS-এর context switch, একটি interrupt-এর কোড বা debugger-এর সহায়তা প্রতিটি chip-এর জন্য নতুন করে লিখতে হতো। Cortex-M-এ core-এর অংশগুলো PPB-তে স্থির: SysTick-এর LOAD সব ARMv7-M chip-এ 0xE000E014. এই স্থিরতার ওপরেই ARM-এর CMSIS-এর মতো সাধারণ header দাঁড়িয়ে আছে, যা দিয়ে SysTick->LOAD সব নির্মাতার chip-এ একই নামে লেখা যায়।

দ্বিতীয় কারণ আচরণ। ARMv7-M প্রতিটি region-এর জন্য default আচরণ ঠিক করে দেয়: কোথা থেকে instruction চালানো যাবে, কোথায় access-এর ক্রম কঠোরভাবে রাখতে হবে। যেমন ARMv7-M-এর default map অনুযায়ী peripheral আর device region-এ instruction চালানো নিষেধ (execute-never), তাই ভুল pointer-এ লাফ দিলে CPU একটি UART register-কে instruction ভেবে চালায় না, fault দেয়। Core নিজে এই নিয়ম জানে বলে MPU না সাজালেও একটি ন্যূনতম সুরক্ষা থাকে।

তবে স্থাপত্য শুধু কাঠামো দেয়; region-এর ভেতরে কতটা ভরা, তা chip-এর ব্যাপার। STM32F103 flash রাখে 0x08000000-এ আর boot pin অনুযায়ী 0x00000000-এ তার ছায়া দেখায়; অন্য নির্মাতা flash সরাসরি 0x00000000-এ রাখতে পারেন। বাজারঘর board-এ শুধু 128 KiB flash আর 20 KiB SRAM, বাকি সব “কিছু নেই”, আর এই পর্বের run-এ 0x20005000 পড়তেই HardFault এল। তাই linker script এখনো লাগে: স্থাপত্য বলে কোন পাড়া, linker script বলে কোন বাড়ি।

মূল উপলব্ধি: core-এর ঠিকানা স্থির করে ARM বহু নির্মাতার chip-এ একই firmware-অভ্যাস, একই RTOS আর একই debugger সম্ভব করেছে; chip-ভেদের পার্থক্য সীমিত থাকে MEMORY-র কয়েকটি লাইন আর peripheral-এর ঠিকানায়।

প্র ০২Cortex-M-এ const টেবিল flash-এ থেকেই পড়া যায়। কিন্তু AVR-এর মতো Harvard ধাঁচের chip-এ const দিলেও টেবিল কেন SRAM খেয়ে ফেলতে পারে?

Cortex-M-এর সব মেমরি একটি ঠিকানা-জগতে: flash, SRAM আর peripheral সবই ৩২-bit ঠিকানার আলাদা পাড়া। ভেতরে Cortex-M3 instruction আর ডেটার জন্য আলাদা bus ব্যবহার করে, কিন্তু program-এর চোখে ঠিকানা একটিই। তাই একটি সাধারণ ldr instruction flash-এর 0x080007EC থেকে cal[1] পড়তে পারে, যেমন SRAM থেকে পড়ে। ফলে const ডেটা .rodata-তে, অর্থাৎ flash-এ রেখে দেওয়া যায়, SRAM-এ কপি লাগে না। এই পর্বের build-এ tare_g-কে const করতেই .data 4 byte কমল।

ATmega328P-এর মতো AVR-এ program memory আর data memory দুটি আলাদা ঠিকানা-জগৎ, পুরোনো অর্থে Harvard নকশা। Data memory থেকে পড়ার instruction (ld) আর program flash থেকে পড়ার instruction (lpm) আলাদা। একটি C pointer কোন জগতের দিকে তাকাচ্ছে, তা সাধারণ pointer-এ লেখা থাকে না। তাই avr-gcc-এর প্রচলিত ব্যবস্থায় সাধারণ const ডেটাও data memory-তে রাখা হয়, আর startup code reset-এ তাকে flash থেকে SRAM-এ কপি করে, ঠিক .data-র মতো। ফ্ল্যাশে রেখে পড়তে চাইলে প্রোগ্রামারকে আলাদা করে বলতে হয়, যেমন avr-libc-র PROGMEM আর pgm_read_byte(), বা নতুন GCC-র __flash qualifier.

এর ব্যবহারিক মূল্য বিশাল। ATmega328P-এ মাত্র 2 KB SRAM. একটি 256-entry-র ১৬-bit টেবিল (512 byte) সাধারণ const দিয়ে লিখলে চার ভাগের এক ভাগ SRAM চলে যায়, আর stack-এর জায়গা কমে। Arduino-তে লম্বা string-এর জন্য F("...") macro এজন্যই জনপ্রিয়: string flash-এ রেখে সরাসরি সেখান থেকে ছাপে।

শিক্ষাটি হলো, “const মানে flash” একটি platform-নির্ভর সত্য। Cortex-M, RISC-V MCU বা ESP32-এর মতো একক ঠিকানা-জগতের chip-এ তা সাধারণত খাটে; আলাদা ঠিকানা-জগতের chip-এ খাটে না। আর আপনার নিজের toolchain কী করছে, তা অনুমান না করে map file-এ variable-টির section আর ঠিকানা দেখে নিশ্চিত হওয়া যায়, যেমন এই পর্বে cal 0x080007EC-এ বসতে দেখা গেল।

মূল উপলব্ধি: ডেটা কোথায় থাকে, তা ঠিক করে ভাষার keyword, chip-এর ঠিকানা-জগৎ আর linker script তিনটি মিলে; একক ঠিকানা-জগতে const SRAM বাঁচায়, আলাদা জগতে তার জন্য আলাদা নির্দেশ লাগে।

প্র ০৩Linker script-এর ASSERT stack-এর জন্য 2 KiB নিশ্চিত করে। তাহলে কি stack overflow আর হবে না? না হলে bare-metal firmware-এ এটি কীভাবে ধরা হয়?

ASSERT একটি স্থির পরীক্ষা: link-এর সময় শুধু দেখে, .bss আর .noinit-এর পরে কমপক্ষে 2 KiB খালি আছে কি না। কিন্তু program চলার সময় stack কতটা নামবে, তা নির্ভর করে function-এর ডাকের গভীরতা, local array-এর মাপ আর interrupt-এর ওপর। একটি interrupt এলে Cortex-M আট word-এর frame (৩২ byte) stack-এ রাখে, আর nested interrupt হলে আরও। একটি recursive function বা ভুলে লেখা 4 KiB-এর local buffer এক ধাক্কায় সীমা পার করতে পারে, অথচ link তখনো সফল।

এই পর্বের বিন্যাসে stack নামে _estack 0x20005000 থেকে নিচের দিকে, আর তার নিচে .noinit, .bss, .data. তাই overflow হলে stack চুপচাপ এই variable-গুলোর ওপর লিখতে শুরু করে। কোনো fault নেই, শুধু হঠাৎ কোনো global-এর মান বদলে যায়, যেমন বাজারঘরের rate_paisa, আর দাম ভুল আসে। এমন bug খোঁজা খুব কঠিন, কারণ যেখানে ভুল দেখা যায় আর যেখানে ভুল ঘটে, দুটি সম্পূর্ণ আলাদা কোড।

তাই বাস্তবে কয়েকটি স্তর একসাথে নেওয়া হয়। এক, stack-কে SRAM-এর নিচের দিকে রেখে তার নিচে কিছু না রাখা: তখন overflow হলে stack SRAM-এর শুরুর নিচে, ম্যাপ-না-করা ঠিকানায় নামে আর fault দেয়, চুপচাপ ডেটা নষ্ট করে না। কিছু প্রকল্প এই কারণে বিন্যাস উল্টে নেয়। দুই, MPU থাকলে stack-এর নিচে একটি ছোট “পাহারা” region রাখা, যেখানে লিখলেই MemManage fault. তিন, “stack painting”: শুরুতে পুরো stack এলাকা একটি জানা নকশা দিয়ে ভরে, পরে দেখা কতটা নকশা মুছে গেছে, অর্থাৎ সর্বোচ্চ ব্যবহার। চার, compiler-এর সাহায্য: GCC আর Clang প্রতিটি function-এর stack frame-এর মাপ জানাতে পারে, যা যোগ করে call graph ধরে সবচেয়ে খারাপ গভীরতা হিসাব করা যায়। BG-M3-এ MPU আর আলাদা fault-status নেই (Spec decision 19), তাই এখানে প্রথম আর তৃতীয় পদ্ধতি সহজে পরীক্ষা করা যায়।

Stack-এর মাপ, heap এড়ানো আর static allocation নিয়ে পুরো আলোচনা পর্ব ৩৯-এ (এমবেডেড memory). এখানে শুধু মনে রাখুন, map file যে 20460 byte “stack পায়” বলল, তা বরাদ্দ, প্রয়োজন নয়।

মূল উপলব্ধি: ASSERT শুধু নিশ্চিত করে যে জায়গা আছে; জায়গা যথেষ্ট কি না, তা চলার সময়ের মাপ, বিন্যাস আর hardware পাহারা মিলিয়ে ঠিক করতে হয়।

প্র ০৪Map file-কে অনেক দল শুধু ভুল খোঁজার সময় খোলে। Firmware-এর দীর্ঘ জীবনে map file নিয়মিত পড়ার কী লাভ, আর পড়ার সময় কোন ফাঁদ এড়াতে হয়?

একটি firmware বছরের পর বছর বাড়ে। প্রতি release-এ কয়েকশো byte যোগ হয়, আর একদিন হঠাৎ link ব্যর্থ হয়: “will not fit in region 'FLASH'”, এই পর্বের দ্বিতীয় ভুল-build-এর মতো। তখন সময় কম, আর কী বাদ দেবেন বোঝা কঠিন। যে দল প্রতি build-এ map থেকে flash আর SRAM-এর মোট আর সবচেয়ে বড় অংশগুলো একটি ছোট script দিয়ে বের করে রাখে, তারা বৃদ্ধির ধারা আগেই দেখে। এই পর্বের ছোট program-এর মতো কয়েক লাইনের reader-ই যথেষ্ট: এটি বলল সবচেয়ে বড় খরচ আমাদের নিজের কোড নয়, uart_put_i32-এর 510 byte. Continuous integration-এ এমন একটি সংখ্যা-সীমা রাখলে কেউ অজান্তে বড় library টানলে সঙ্গে সঙ্গে ধরা পড়ে।

Map file নিরাপত্তা আর নির্ভরযোগ্যতার প্রশ্নেও কাজে লাগে। কোন function কোন ঠিকানায়, কোন variable .noinit-এ, vector table ঠিক শুরুতে কি না, bootloader আর application-এর সীমায় কিছু উপচে পড়ল কি না, সবই এখানে দেখা যায়। HardFault-এর stacked PC (যেমন reference lab-এর hardfault উদাহরণে 0x08000154) পেলে map বা symbol table দিয়েই বোঝা যায় কোন function-এ ভুল।

ফাঁদও আছে। প্রথমত ফরম্যাট toolchain-ভেদে আলাদা: GNU ld-এর map দেখতে একরকম, LLD-রটি আরেক রকম, আর ARM-এর armlink-এর আরেক। LLD-র map-এ সংখ্যা hex কিন্তু 0x লেখা থাকে না, ফলে “790” দেখে 790 byte ভাবা খুব সহজ ভুল, আসলে 1936. দ্বিতীয়ত, এই পর্বের নিজের পরীক্ষায় দেখা গেল, section-এর বাইরের assignment লাইনের প্রথম কলাম symbol-এর মান নয়, location counter: .calib যোগ করার পরে map দেখাল 801fc08 _sidata = ..., অথচ আসল মান 0x08000290. তৃতীয়ত, --gc-sections-এ মুছে যাওয়া অংশ map-এর মূল তালিকায় থাকে না; কোনো function “হারিয়ে গেলে” সেটি হয়তো কেউ ডাকেনি বলে বাদ পড়েছে।

তাই নিয়ম হলো দুটি আলাদা উৎস মেলানো: map-এর হিসাব আর ELF-এর section header বা symbol table. এই পর্বে দুটি পথই একই উত্তর দিল, flash 2040 আর SRAM 20 byte.

মূল উপলব্ধি: map file firmware-এর হিসাবের খাতা; নিয়মিত পড়লে জায়গার সংকট আগেই দেখা যায়, আর ফরম্যাটের খুঁটিনাটি জেনে দ্বিতীয় উৎস দিয়ে মেলালে ভুল পড়া এড়ানো যায়।

প্র ০৫.noinit reset পার হয়ে টিকে থাকে। একে কীভাবে নিরাপদে ব্যবহার করবেন, আর bootloader ও application একই chip-এ থাকলে memory map কেমন হয়?

.noinit-এর ভিত্তি একটি hardware সত্য: watchdog বা software reset-এ সাধারণত বিদ্যুৎ যায় না, তাই SRAM-এর মান থেকে যায়। BG-M3 এটি মেনে চলে (Spec decision 18), আর reference lab-এর watchdog.c এভাবে boot গুনে দেখায় “boot #2, reset cause: WATCHDOG”. কিন্তু প্রথম power-on-এ SRAM-এ কী থাকবে, তা অনির্দিষ্ট (board-এ শূন্য, আসল chip-এ আবর্জনা)। তাই নিরাপদ ব্যবহারের প্রথম নিয়ম একটি “জাদু সংখ্যা”: watchdog.c-তে boot_magic 0xB00710AD না হলে ধরে নেওয়া হয় এটি প্রথম চালু, আর সব মান নতুন করে বসানো হয়। আরও সতর্ক নকশায় একটি checksum বা CRC যোগ করা হয়, যাতে আধা-লেখা বা নষ্ট মান ধরা পড়ে।

দ্বিতীয় নিয়ম, .noinit-এর ঠিকানা স্থির রাখা। Firmware বদলালে .bss বড় হতে পারে, আর .noinit সরে যেতে পারে; তখন নতুন firmware পুরোনো ঠিকানার মান ভুল জায়গায় খুঁজবে। যদি একই firmware নিজের জন্য ব্যবহার করে, সমস্যা কম; কিন্তু দুটি আলাদা program ভাগাভাগি করলে স্থির ঠিকানা জরুরি।

সেই ভাগাভাগির সবচেয়ে চেনা উদাহরণ bootloader. একটি সাধারণ বিন্যাসে flash-এর শুরুতে ছোট bootloader থাকে, যেমন প্রথম কয়েক KiB, আর application শুরু হয় পরের কোনো page-সীমা থেকে। দুটির নিজস্ব linker script: bootloader-এর FLASH region ছোট, application-এর ORIGIN সরানো। Bootloader application-এর vector table-এর প্রথম দুটি word পড়ে, VTOR-কে সেই ঠিকানায় দেয় আর MSP সাজিয়ে reset handler-এ লাফ দেয়। “Firmware update চাই” এমন বার্তা পাঠাতে application প্রায়ই .noinit-এর একটি স্থির ঠিকানায় একটি flag লিখে software reset দেয়; bootloader সেই flag দেখে update mode-এ থাকে। এখানে দুই script-এর মধ্যে একটি ভুল ঠিকানা মানে update কখনো শুরু না হওয়া, বা উল্টো, প্রতি reset-এ update mode-এ আটকে থাকা।

Reset-এর পুরো ক্রম আর bootloader-এর লাফ পর্ব ৩২-এর stepper-এ ধাপে ধাপে আসবে, আর signature-সহ নিরাপদ update পর্ব ৭৭-এ। এখানে মূল কথা memory map-এর: একই chip-এ দুটি program থাকলে দুজনের ঠিকানা-বই একে অপরের সঙ্গে চুক্তির মতো মিলে থাকতে হয়।

মূল উপলব্ধি: .noinit একটি ক্ষমতা, কিন্তু অনির্দিষ্ট শুরুর মানের জন্য জাদু সংখ্যা আর checksum, আর ভাগাভাগির জন্য স্থির ঠিকানা ছাড়া তা বিপজ্জনক।

অনুশীলন

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

  1. নকশা: reset পার হয়ে টিকে থাকা তাপমাত্রার log. বাজারঘরের cold-storage monitor-এ watchdog reset-এর পরেও শেষ ৬৪টি তাপমাত্রা (প্রতিটি int16_t, sensor-এর ১৬-bit মান) পড়া যেতে হবে, যাতে কেন reset হলো বোঝা যায়। where.c-এর সব variable রেখে এই log-টি যোগ করুন: C ঘোষণা লিখুন, বলুন linker script-এর কোন লাইন একে সামলাবে, এটি কোন ঠিকানায় বসবে, আর stack-এর জন্য কত byte থাকবে।

    ঘোষণা: __attribute__((section(".noinit"))) int16_t temp_log[64];. শুরুর মান দেওয়া চলবে না, কারণ তাহলে তা .data হতে চাইবে; আর .bss-এ রাখলে startup প্রতি reset-এ শূন্য করবে, log হারাবে।

    Linker script: reference-এর .noinit (NOLOAD) : { *(.noinit*) . = ALIGN(4); } > RAM লাইনটিই যথেষ্ট, নতুন কিছু লাগবে না। NOLOAD বলে flash-এ কিছু লেখা হবে না।

    ঠিকানা আর জায়গা (আসল build): .noinit শুরু 0x20000010; সেখানে আগে boot_count (4 byte), তারপর temp_log 0x20000014-এ, মাপ 64 × 2 = 128 byte (map: 20000014 ... 80 ... temp_log, 0x80 = 128). .noinit মোট 0x84 = 132 byte, শেষ 0x20000094. Stack পায় 0x20005000 − 0x20000094 = 0x4F6C = 20332 byte; ELF reader বলল sram(static)=148 (20 + 128). ASSERT-এর 2048 সীমার অনেক ওপরে।

    নিরাপত্তা: প্রথম power-on-এ log আবর্জনা হতে পারে, তাই watchdog.c-এর মতো একটি জাদু সংখ্যা আর লেখার সূচক রাখুন, আর জাদু সংখ্যা না মিললে log খালি করুন।

  2. ভুল খুঁজুন। একজন linker script সংক্ষিপ্ত করতে গিয়ে .data-র লাইন লিখেছেন } > RAM, অর্থাৎ AT > FLASH বাদ। তাঁর যুক্তি: “variable তো SRAM-এ থাকে, তাই RAM লিখলেই হলো।” Build সফল হলো। ভুলটি কী, ELF-এ কোথায় দেখা যাবে, আর বাজারঘর board আর আসল chip-এ কী ঘটবে?

    ভুল: AT > FLASH না থাকলে .data-র LMA আর VMA দুটিই RAM-এ। অর্থাৎ শুরুর মান 6550 আর 150 রাখার জায়গাও SRAM, যা বিদ্যুৎ গেলে মোছে আর flash programmer লিখতেই পারে না।

    ELF-এ (আসল build): LOAD segment 0x20000000 0x20000000 8 20: PhysAddr (LMA) 0x20000000, flash-এ নয়। আর symbol _sidata 0x20000000, তাই startup-এর কপি-loop SRAM থেকে SRAM-এ, নিজের ওপরেই কপি করে, কোনো কাজ হয় না।

    BG-M3-এ: board ELF লোড করতেই অস্বীকার করে: error: segment at 0x20000000 is outside flash. আসল chip-এ: programmer সাধারণত SRAM-এর segment ফেলে দেয় বা ত্রুটি দেখায়; ফলে rate_paisa হয় power-on-এর আবর্জনা, দাম অর্থহীন। Debugger দিয়ে সরাসরি RAM-এ load করে পরীক্ষা করলে আবার সব ঠিক দেখায়, তাই ভুলটি প্রথম ধরা পড়ে কারখানায়।

    সঠিক: } > RAM AT > FLASH, আর _sidata = LOADADDR(.data).

  3. হিসাব: link হবে কি না। BG-M3-এর linker script (SRAM 20 KiB, _min_stack = 2K)-এ একটি firmware-এর একমাত্র স্থির SRAM-এর variable int32_t weight_log[N] (.bss). N = 4500 আর N = 4700-এর জন্য _ebss, stack-এর জায়গা হিসাব করুন আর বলুন link সফল হবে কি না।
    1. SRAM = 20 × 1024 = 20480 byte, _estack = 0x20005000, সীমা 2048 byte.
    2. N = 4500: 4500 × 4 = 18000 byte = 0x4650, তাই _ebss = 0x20004650. Stack = 20480 − 18000 = 2480 byte ≥ 2048 → link সফল। আসল build-এর map-এও 20004650 ... _ebss = ., আর board-এ চলে “log ok” ছাপল।
    3. N = 4700: 4700 × 4 = 18800 byte = 0x4970, _ebss = 0x20004970. Stack = 20480 − 18800 = 1680 byte < 2048 → ASSERT ব্যর্থ: ld.lld: error: not enough SRAM left for the stack.
    4. সীমায় ঠিক কত? (20480 − 2048) ÷ 4 = 4608, তাই N ≤ 4608 পর্যন্ত link হবে (যদি অন্য কোনো .data/.bss না থাকে)।
  4. ফল আগে থেকে বলুন। where.c-তে শুধু একটি শব্দ বদলানো হলো: int32_t tare_g = 150; হলো const int32_t tare_g = 150;. বাকি সব একই। Run-এর আউটপুটে tare_g-এর ঠিকানা কোন region-এ যাবে, _sdata..edata লাইন কত দেখাবে, দাম কত হবে, আর flash ও স্থির SRAM-এর খরচ কীভাবে বদলাবে?

    আসল run-এর উত্তর: tare_g @ 0x08000710 = 150: const হওয়ায় .rodata-তে, flash-এ। _sdata..edata 0x20000000 = 4: .data-তে এখন শুধু rate_paisa. দাম অপরিবর্তিত, price = 81.88 Tk, কারণ মান একই।

    খরচ: ELF reader: flash=2040 sram(static)=16. Flash একই, কারণ 4 byte .data-র LMA থেকে .rodata-তে সরল মাত্র; SRAM 20 থেকে 16 byte, 4 byte বাঁচল। .bss-এর variable-গুলো 4 byte করে নিচে নামল: sample_count 0x20000004-এ।

    শিক্ষা: একটি const section, ঠিকানা আর SRAM-এর হিসাব তিনটিই বদলায়; ফল যাচাই করতে map বা ELF reader দেখুন।

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

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

ক্রমএকটি মানসহ global variable (যেমন uint32_t rate_paisa = 6550;) C ফাইল থেকে চলমান program-এ পৌঁছানোর ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. Compiler variable-টিকে .data.rate_paisa section-এ রাখে
  2. Linker script-এর > RAM AT > FLASH অনুযায়ী linker VMA SRAM-এ আর LMA flash-এ ঠিক করে
  3. Flash programmer মান 6550 flash-এর LMA-তে লেখে
  4. Reset-এর পরে startup code flash থেকে মানটি SRAM-এর VMA-তে কপি করে
  5. main() SRAM থেকে rate_paisa পড়ে দাম হিসাব করে

ARMv7-M-এর default memory map-এ (Cortex-M3/M4) SysTick আর NVIC কোন region-এ থাকে?

  • Peripheral region, 0x40000000 থেকে
  • Private Peripheral Bus, 0xE0000000 থেকে
  • SRAM region, 0x20000000 থেকে
  • Vendor-specific region, 0xE0100000 থেকে

একটি Cortex-M firmware-এ global ঘোষণা আছে: uint32_t sample_count; (কোনো শুরুর মান নেই)। এটি কোন section-এ যায়, আর reset-এর পরে কী মান পায়?

  • .data, flash থেকে কপি হয়ে 0
  • .rodata, flash-এ 0
  • .bss, startup code শূন্য করে বলে 0
  • .noinit, মান অনির্দিষ্ট

একটি LLD map file-এ লাইন আছে: 20000000 80007f0 8 4 .data. এর সঠিক অর্থ কোনটি?

  • .data চলে SRAM-এর 0x20000000-এ, শুরুর মান রাখা flash-এর 0x080007F0-এ, মাপ 8 byte
  • .data চলে flash-এ, কপি রাখা SRAM-এ
  • মাপ 4 byte, alignment 8
  • দুটি ঠিকানা আলাদা, তাই linker script-এ ভুল আছে

একটি Cortex-M linker script-এ vector table-এর লাইন .isr_vector : { *(.isr_vector) } > FLASH লেখা হলো, KEEP ছাড়া, আর link-এ --gc-sections দেওয়া। কী ঝুঁকি?

  • Vector table SRAM-এ চলে যাবে
  • Vector table-এর মাপ দ্বিগুণ হবে
  • Link ব্যর্থ হবে, তাই ঝুঁকি নেই
  • Linker টেবিলটিকে অব্যবহৃত ভেবে মুছে দিতে পারে

একটি Cortex-M3 board-এ SRAM 0x20000000 থেকে 20 KiB. একটি pointer 0x20005000 থেকে একটি word পড়লে কী হবে?

  • SRAM-এর শেষ word পড়া হবে
  • সেখানে কোনো মেমরি নেই, তাই fault হবে
  • মোড়ানো হয়ে 0x20000000 পড়া হবে
  • একটি peripheral register পড়া হবে

Cortex-M firmware-এ const uint16_t cal[2] = {400, 1800}; কে const ছাড়া uint16_t cal[2] = {400, 1800}; করলে মেমরির খরচে কী বদলায়?

  • কিছুই বদলায় না
  • শুধু SRAM-এ 4 byte লাগে, flash-এ কিছু না
  • .rodata থেকে .data-তে যায়: flash-এ মান থাকে, আর SRAM-এ আরও 4 byte লাগে
  • .bss-এ চলে যায়, flash-এর খরচ কমে

শব্দকোষ

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

মনে রাখুন

  1. সাত region: Code 0x00000000, SRAM 0x20000000, Peripheral 0x40000000, External RAM, External device, PPB 0xE0000000 (SysTick 0xE000E010, NVIC 0xE000E100), Vendor; region মানেই মেমরি নয়।
  2. BG-M3: flash 0x08000000 (128 KiB), SRAM 0x20000000 (20 KiB), _estack 0x20005000; বাইরে access করলে HardFault.
  3. Section: code আর const flash-এ; মানসহ global .data (VMA SRAM, LMA flash); মানহীন .bss (শূন্য করা); .noinit কেউ ছোঁয় না; local stack-এ।
  4. Startup-এর চুক্তি: _sidata থেকে _sdata.._edata-তে কপি, _sbss.._ebss শূন্য; কপি না হলে বাজারঘরের দাম 81.88 থেকে 0.00 টাকা।
  5. Map file: LLD-তে সব সংখ্যা hex, 0x ছাড়া; where.elf-এ flash 2040 B, SRAM 20 B, stack পায় 20460 B; assignment লাইনের প্রথম কলাম location counter.

পরের পর্বে: এই পর্বে startup code-কে বাইরে থেকে দেখেছেন। এবার ভেতরে: reset-এর মুহূর্তে CPU কীভাবে 0x08000000 থেকে MSP আর reset vector তোলে, startup.c লাইন ধরে, main ফিরে এলে কী হয়, আর bootloader কীভাবে application-এ লাফ দেয়, সেটি পর্ব ৩২-এ (Boot আর startup code — reset vector থেকে main পর্যন্ত)।

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

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