Understanding Function Calls and Stack Frames in Memory

Function calls can be visualized like stacking boxes during a move: the first box placed ends up at the bottom and the most recent box on top, forming a first‑in‑last‑out (FIFO) structure known as a stack.

When a program runs, each invoked function receives its own stack frame—a block of memory that stores local variables and bookkeeping information. The bottom and top of each frame are tracked by the Base Pointer (BP) and Stack Pointer (SP) registers (e.g., rbp and rsp on x86_64).

Consider the following C code:

void D() {}
void C() { D(); }
void B() { C(); }
void A() { B(); }

Calling A triggers a chain of calls (A → B → C → D), and at runtime four stack frames are created, one for each function, stacked from high to low memory addresses.

To establish a new frame, the compiler emits two instructions at the start of each function:

push   %rbp
mov    %rsp,%rbp

The first saves the previous frame’s base pointer on the stack, and the second sets the new base pointer to the current stack top, effectively creating a fresh frame.

If a function defines local variables, such as:

void funcB() {
    int a = 1;
    int b = 2;
    int c = 3;
    // ...
}

the stack grows further to accommodate these variables within funcB ’s frame.

When a function returns, the leave instruction restores the previous frame by moving the stack pointer back to the saved base pointer and popping the old rbp :

leave

On x86 platforms, leave is typically followed by ret , which pops the return address from the stack into the instruction pointer ( rip ), allowing execution to continue in the caller.

Thus, function calls are realized through a disciplined push/pop of stack frames, managed by the BP and SP registers and a small set of assembly instructions.