Memory layout — text, data, BSS, heap, stack segments

5.1.15 · Coding › C Programming

WHY does each segment exist? (first-principles reasoning)

Intuition Memorize mat karo, reason karo

Text read-only & shared hai — instructions run karte waqt kabhi change nahi hote. Agar vim ke 100 copies run ho rahe hain, toh code 100 baar store kyun karein? Ek read-only copy, shared. Read-only hone se bugs/viruses tumhara code rewrite bhi nahi kar sakte.
Data vs BSS split — Ek global int x = 42; ko literal 42 disk par file ke andar store karna padta hai. Ek global int y; (ya =0) mein koi information nahi hoti — sab zeros hain. Disk par ek million zeros store karna wasteful hai, isliye BSS sirf "N bytes reserve karo, 0 se fill karo" record karta hai. Isliye ek int big[1000000]; global tumhari .exe ko almost nahi badhata.
Heap upar barhta hai, stack neeche — dono beech wala gap share karte hain. Ek doosre ki taraf barhne se dono mein se koi bhi jitni free space chahiye use le sakta hai, bina pehle se hard boundary fix kiye. Ye sirf extreme cases mein collide karte hain (tab: heap-overflow / stack-overflow).
Stack automatic hai, heap manual — stack memory automatically free ho jaati hai jab function return karta hai (bas stack pointer ko wapas le jaao). Heap tumhein khud free karna padta hai (free) kyunki program nahi jaanta kab tumhara kaam khatam hua.

HOW is the address space arranged?

WORKED EXAMPLES — where does each variable live?

Worked example Example 1 — har variable ko classify karo

#include <stdlib.h>
int   g_init   = 5;      // (A)
int   g_zero   = 0;      // (B)
int   g_uninit;          // (C)
static int s_init = 7;   // (D)
 
int main(void) {
    int local = 3;       // (E)
    static int s = 0;    // (F)
    int *p = malloc(40); // (G) p itself? *p?
    return 0;
}

Var	Segment	Yeh step kyun?
A `g_init=5`	Data	global, non-zero init → value `5` disk par stored
B `g_zero=0`	BSS	global, zero init → zeros store karne ki zaroorat nahi
C `g_uninit`	BSS	global uninitialized = zero treat kiya jaata hai
D `s_init=7`	Data	`static` → static storage duration, non-zero
E `local=3`	Stack	`main` ke frame mein auto variable
F `s=0`	BSS	function ke andar `static` fir bhi static storage, zero
G `p`	Stack	pointer variable `p` ek local hai
G `*p` (40 bytes)	Heap	`malloc` heap memory return karta hai

Worked example Example 2 — executable kyun chhoti hoti hai (Data→BSS)

int arr[1000000] = {1};   // version A: ek non-zero element
int arr[1000000];         // version B: sab default zero

Version A: array initialized hai (partly bhi) → represent karna zaroori hai, isliye Data mein jaata hai aur file ~4 MB badh jaati hai.
Version B: sab zeros → BSS mein rehta hai → file sirf kuch bytes badhti hai (bas "4 MB reserve karo, zero karo").
Yeh kyun matter karta hai: Forecast-then-Verify — dono compile karo, size a.out run karo, data vs bss columns ko swap hote dekho. Runtime par RAM same hoti hai; sirf disk par file alag hoti hai.

Worked example Example 3 — growth directions prove karna

void f(void) {
    int a, b;                 // dono stack par
    printf("%p %p\n", &a, &b);
    int *p = malloc(4), *q = malloc(4);
    printf("%p %p\n", p, q);  // heap
}

Typically &a > &b (ya vice versa order ke hisaab se) lekin stack addresses HIGH hoti hain; heap addresses stack se bahut LOWER hoti hain.
Successive mallocs usually increasing addresses dete hain (heap upar barhta hai); successive local-frame variables decreasing addresses par hote hain (stack neeche barhta hai). Kyun? Upar wali layout formula confirm hoti hai.

Common mistakes (Steel-man + fix)

Active recall

Recall Peeking se pehle try karo

Kaun sa segment read-only hota hai? Text.
int x; global kahaan rehta hai? BSS.
int x = 9; global kahaan rehta hai? Data.
Kya BSS disk space leta hai? Nahi (sirf ek size record hota hai).
Heap kis direction mein barhta hai? Upar (higher addresses).
Stack kis direction mein barhta hai? Neeche (lower addresses).
malloc ka block kahaan rehta hai? Heap.
Ek function ka local int kahaan rehta hai? Stack.

Recall Feynman: ek 12-saal ke bacche ko explain karo

Socho tumhare program ko ek bada bookshelf milta hai. Sabse neeche wali shelf mein instruction manual hota hai — tum padh sakte ho lekin uspar kuch likh nahi sakte (Text). Agle shelves mein pehle se bhari hui toys hoti hain (Data) aur "zeros se bharo" label wale khaali boxes (BSS) — khaali boxes ko shifting truck mein pack karne ki zaroorat nahi, tum bas ek sticky note par "10 khaali boxes" likh dete ho. Beech ke bade space mein, toy pile neeche se upar barhta hai jab bhi tum naya toy maangte ho (Heap = malloc), aur plates ka stack chhat se neeche barhta hai jab bhi tum naya kaam shuru karte ho aur ek plate rakhte ho (Stack = function calls). Jab kaam khatam ho, plate automatically wapas chali jaati hai. Agar toy pile aur plate stack kabhi aapas mein takra jaayein — room khatam!

Connections

malloc, calloc, realloc and free — heap kaise manage hota hai.
Stack frames and the calling convention — stack push ke andar kya hota hai.
Static and global variables — storage duration — Data vs BSS rules.
Pointers and dangling pointers — heap lifetime bugs.
Virtual memory and paging — segments physical RAM se kaise map hote hain.
Buffer overflow and stack smashing — stack ki security side.

Which segment stores compiled machine instructions and is read-only?

Text (code) segment.

Where do initialized non-zero global/static variables live?

Data segment mein.

Where do uninitialized or zero-initialized globals/statics live?

BSS segment mein.

Why does BSS take no space in the executable file?

Yeh sirf ek reserve karne wala size store karta hai; OS ise load time par zero-fill karta hai, isliye all-zero contents disk par save nahi karne padte.

What is the default value of an uninitialized GLOBAL variable in C?

Zero (BSS mein jaata hai, zero-initialize hona guaranteed hai).

What is the value of an uninitialized LOCAL (auto) variable?

Indeterminate/garbage — stack par hota hai aur auto-zeroed nahi hota.

Which direction does the heap grow?

Higher addresses ki taraf (program break upar jaata hai brk/sbrk se).

Which direction does the stack grow?

Lower addresses ki taraf (stack pointer push par decrease hota hai).

When you call malloc inside a function, where is the returned block, and where is the pointer?

Block heap par hota hai; pointer variable stack par hota hai.

What tracks the top of the heap?

Program break, brk/sbrk se adjust hota hai.

What tracks the top of the stack?

Stack pointer register (jaise rsp).

What causes a stack overflow vs heap exhaustion?

Stack overflow = bahut gehri recursion/bade locals (SP limit se aage); heap exhaustion = malloc NULL return karta hai.