Startup code — vector table, reset handler, stack initialization

5.5.16 · Coding › Embedded Systems & Real-Time Software

WHY does startup code even exist?

WHAT happens physically at reset (ARM Cortex-M example):

CPU memory ka pehla word padhta hai → use Main Stack Pointer (MSP) mein load karta hai.
CPU doosra word padhta hai → use Program Counter (PC) mein load karta hai — yeh Reset Handler ka address hai.
Execution Reset Handler par shuru ho jaati hai.

The Vector Table

Offset   Contents
0x00     Initial MSP value        (top of stack)
0x04     Reset_Handler            (entry point)
0x08     NMI_Handler
0x0C     HardFault_Handler
...      ...
0x40+    IRQ0, IRQ1, ... (peripheral interrupts)

C mein, table bas const function pointers ka ek array hai jo ek special linker section mein rakha jaata hai:

__attribute__((section(".isr_vector")))
void (* const vector_table[])(void) = {
    (void (*)(void)) &_estack,   // 0x00: top of stack (NOT a function!)
    Reset_Handler,               // 0x04
    NMI_Handler,                 // 0x08
    HardFault_Handler,           // 0x0C
    /* ... */
};

The Reset Handler — manufacturing the C environment

Reset Handler main() se pehle run karta hai. Iska kaam yeh C facts sach banana hai:

C source	Needs at runtime
`int g = 42;` (initialized global)	Value `42` Flash se variable ke RAM address par copy honi chahiye
`int z;` (uninitialized global)	Zero hona chahiye
`main()` functions call karta hai	Stack kaam karna chahiye

extern uint32_t _sidata, _sdata, _edata, _sbss, _ebss, _estack;
 
void Reset_Handler(void) {
    uint32_t *src = &_sidata;
    uint32_t *dst = &_sdata;
    while (dst < &_edata) *dst++ = *src++;   // copy .data
    for (dst = &_sbss; dst < &_ebss; ) *dst++ = 0;  // zero .bss
    __libc_init_array();   // C++/static constructors
    main();
    while (1) { }          // trap: main must never return
}

Stack Initialization

Isliye _estack linker dwara highest RAM address + 1 (the end) set kiya jaata hai. Reset par MSP mein load hone ke baad, pehla push uske just below land karta hai.

Worked example Tracing the very first instructions

Power-on, RAM = 0x2000_0000…0x2000_4FFF (20 KB), toh _estack = 0x2000_5000.

Hardware 0x0000_0000 par word padhta hai = 0x2000_5000 → MSP. Kyun? kuch bhi hone se pehle stack exist karna chahiye.
Hardware 0x0000_0004 par word padhta hai = Reset_Handler ka address → PC. Kyun? yahi woh jagah hai jahan hamaara code hai.
Reset_Handler .data copy karta hai. Maano int g=42 RAM 0x2000_0000 par hai, aur 42 Flash mein _sidata par stored hai. Loop 42 ko 0x2000_0000 par likhta hai. Kyun? taaki g main mein 42 read back kare.
.bss zero karo: 0x2000_0004 par int z; 0 set ho jaata hai. Kyun? C guarantee karta hai ki uninitialized globals 0 hain.
main() ek normal branch-with-link se call hoti hai; return address 0x2000_4FFC par push hota hai (_estack ke just below). Kyun? full-descending stack.

Flashcards

Startup code bare metal par ek C program enable karne ke liye kya teen cheezein provide karta hai?

Ek valid stack (SP), initialized .data (copied Flash→RAM) aur zeroed .bss, aur main ke liye ek entry vector.

Cortex-M par, reset par hardware vector table ke pehle do words se kya load karta hai?

Word 0 → initial Main Stack Pointer (MSP); Word 1 → Program Counter (Reset_Handler ka address).

Vector table entry 0 ek real function pointer kyun NAHI hai?

Yeh initial stack-top value hai; ise function-pointer type mein sirf array mein fit hone ke liye cast kiya jaata hai. Hardware ise MSP ki tarah use karta hai, kabhi us par jump nahi karta.

.data aur .bss mein kya fark hai?

.data = initialized globals (values Flash mein stored, reset par RAM mein copy). .bss = zero-initialized globals (Flash storage nahi; reset par 0 par clear).

.data copy ko kaunse linker symbols drive karte hain aur kyun?

_sidata (Flash source), _sdata/_edata (RAM dest range). Copy har RAM offset ko _sidata se same Flash offset par map karta hai.

Reset handler ko forever loop kyun karna chahiye agar main() return kare?

Return karne ke liye koi OS nahi hai; returning PC mein garbage pop kar dega. Infinite loop use safely trap karta hai.

Cortex-M par stack kis direction mein grow karta hai aur _estack kahan point karta hai?

Full-descending: neeche ki taraf grow karta hai. _estack = RAM ka top (highest address + 1), MSP mein load hota hai.

Agar aap .bss zero karna bhool jaao toh real-world bug kya aata hai?

Uninitialized globals random power-up RAM garbage se start hoti hain; kuch boards par kaam karta hai, doosron par fail karta hai — ek heisenbug.

Stack pointer sabse pehli cheez kyun initialize hoti hai?

Hardware interrupt entry ko bhi registers push karne ke liye valid stack chahiye; functions ko return addresses/locals store karne ke liye chahiye.

Recall Feynman: explain to a 12-year-old

Socho tumne ek robot banaya aur switch on kiya. Robot ka brain bilkul blank jaagta hai — use yeh bhi nahi pata ki uska notebook (memory) kahan hai. Startup code ek chhoti si checklist hai jo robot pehle run karta hai: "Mera notes likhne ka notebook kahan hai? → stack lo." "Apne starting facts permanent book (Flash) se scribble notebook (RAM) mein copy karo." "Khaali pages ko truly empty karo (zero karo), taaki woh purani smudges se bhari na hon." Sirf is tidy-up ke baad hi robot apna asli kaam (main) shuru karta hai. Checklist skip karo aur robot smudges ko facts ki tarah padhega aur haywire ho jaayega.

Connections

Linker scripts and memory sections (.text .data .bss)
ARM Cortex-M exception and interrupt model
Stack vs Heap memory layout
The C runtime and crt0
Bootloaders and VTOR relocation
Volatile, memory-mapped registers and hardware init