Trace: A Function Call in C++

The Call Stack

High Address
┌─────────────────┐
│ bar() frame     │  ← SP (top of stack)
│   y = ?         │
├─────────────────┤
│ foo() frame     │
│   y = 10        │
│   return addr   │
├─────────────────┤
│ main() frame    │
│   x = 42        │
│   return addr   │
└─────────────────┘ Low Address

What Happens at Each Step

1. main() starts — the runtime creates the initial stack frame for main(). The stack pointer (RSP) points to the top of this frame.

2. Local variable x = 42 — x is allocated in main()'s stack frame. The compiler knows the offset from the stack pointer (e.g., x is at RSP + 4).

3. foo() is called — before transferring control, the CPU pushes the return address (the instruction after the call instruction) onto the stack. The call instruction also jumps to foo()'s code.

4. foo()'s prologue — foo()'s first instructions (the prologue) set up a new stack frame: it moves the old base pointer (RBP) and sets a new one.

5. Local variable y = 10 — y is allocated in foo()'s stack frame at a known offset.

6. bar(5) is called — the argument 5 is pushed, then the return address, then bar()'s frame is set up. This is stack growth — more frames are added on top.

7. bar() executes — bar() computes result = 5 * 2 = 10 and stores it.

8. bar() returns — the ret instruction pops the return address from the stack, jumps back to foo(), and bar()'s frame is effectively discarded (the stack pointer moves back).

9. foo() returns — same process. The stack pointer moves back, freeing foo()'s frame.

10. main() finishes — the runtime cleans up main()'s frame and the process exits.

Key Takeaways

• Each function call pushes a stack frame (also called an activation record).
• The stack grows downward in memory (from high addresses to low).
• Function arguments and return addresses are stored on the stack.
• When a function returns, its stack frame is popped — all its local variables become invalid.
• A stack overflow occurs when the stack grows too large (e.g., infinite recursion).