Stack frames — how function calls work at the memory level

5.1.16 · Coding › C Programming

WHY does this mechanism exist?

HOW a frame is built — step by step (the calling convention)

Exact steps platform par depend karte hain, lekin conceptually har call yeh karta hai:

CALLER:                          CALLEE (the called function):
  1. push arguments              4. push old BP (save caller's frame ref)
     (or load into registers)    5. BP = SP  (BP now marks this frame's base)
  2. CALL f  -> saves the         6. SP -= N  (carve N bytes for local vars)
     return address               7. ... do work, locals at [BP - offset] ...
  3. (execution jumps to f)       8. SP = BP        (drop locals)
                                  9. pop old BP     (restore caller's BP)
                                 10. RET -> uses return address, jumps back

Worked Example 1 — tracing nested calls

int add(int a, int b) {   // frame: a, b, return addr, saved BP
    int s = a + b;        // local s
    return s;
}
int main(void) {
    int x = add(2, 3);    // main's frame holds x
    return 0;
}

Trace (downward stack, x86-style where return addr is pushed):

Worked Example 2 — recursion piles frames

int fact(int n) {
    if (n <= 1) return 1;        // base case
    return n * fact(n - 1);      // each call = a NEW frame
}

fact(3) call karne par sabse gehri point par teen live frames bante hain:

fact(3): n=3, waiting on fact(2)
fact(2): n=2, waiting on fact(1)
fact(1): n=1  -> returns 1   (deepest, returns FIRST)

Worked Example 3 — the classic dangling-pointer bug

int *bad(void) {
    int local = 42;
    return &local;   // BUG: returns address of a local
}

Flashcards

Connections

• Pointers and addresses in C — &local kyun dangerous hai yeh directly frame lifetime se juda hai.
• Recursion — har recursive call = ek naya frame; base case pile ko grow hone se rokta hai.
• Heap vs Stack memory — heap (malloc) calls se zyaada jeeta hai; stack return par auto-free ho jaata hai.
• Calling conventions (cdecl, stdcall) — args kaun push/clean karta hai, register vs stack passing.
• Buffer overflow & return-address smashing — security exploits jo saved return address overwrite karte hain.
• Assembly: push, pop, call, ret, BL — actual instructions jo frames manage karte hain.

Concept Map