Function Call Stack in C

C is a procedural programming language where functions are key to the structure and flow of the program. When a function is called, the program control temporarily jumps to that function, executes its code, and then returns to the point where it was called. To efficiently manage this flow, C uses a stack data structure known as the call stack.

What is the Call Stack?

The call stack is a data structure used by the program during runtime to manage function calls and local variables. It operates in a Last-In-First-Out (LIFO) manner, meaning the last function called is the first one to complete and exit.

How are Functions Executed?

A function in C needs memory for the following components:

• Function Arguments: Values passed to the function.
• Local Variables: Variables declared inside the function.
• Compiler also saves the address to return to after the function's execution, referred to as the return address.

All the data related to a single function call is grouped together and stored in the call stack as a stack frame or activation record.

The stack pointer (SP) points to the top of the call stack, which is the most recently added stack frame. This allows the program to efficiently track the stack size and manage memory during function calls.

When a function is called, a new stack frame is pushed onto the call stack. Upon returning from a function, the stack frame is removed (popped), and control goes back to the previous execution point using the return address stored in the popped stack frame.

Example

Let's take a code example:

#include <stdio.h>

// Definition of function D
void D() {
    float d = 40.5f;
    printf("In function D");
}

// Definition of function C
void C() {
    double c = 30.5;
  
    printf("In function C\n");
}

// Definition of function B
void B() {
    int b = 20;
  
  	// Calling function C
  	C();
  
  	// This will be printed after C() is executed
    printf("In function B\n");
}

// Definition of function A
void A() {
    int a = 10;
  
  	// Calling function B
  	B();
    
  	// This will be printed after B() is executed
    printf("In function A\n");
}

int main() {
  
    // Calling function A from main
    A();
  
  	// Calling function D from main, it will be called
  	// after A, B and C's execution
  	D();

    return 0;
}

In function C
In function B
In function A
In function D

The below images shows how this program is stored in the call stack and how it is executed.

Call Stack for Recursion

Recursion is a technique where a function calls itself in order to solve smaller instances of the same problem. Each recursive call creates a new stack frame, which is pushed into the call stack. Once the base case is reached, the function returns, and its stack frame is removed, allowing the previous call to resume.This process continues until all recursive calls are completed.

Note: While recursion provides an easy solution to certain problems, excessive recursion depth can cause a stack overflow due to the limited size of the call stack.

Example

#include <stdio.h>

// Recursive function that prints current n
// and call itself two times for n - 1 till
// n is greater than 1
void f(int n) {
  	printf("F(%d)'s Stack Frame Pushed\n", n);
  	
  	// Recursive calls
  	if (n > 1) {
  		f(n - 1);
  		f(n - 1);
    }
  
  	printf("F(%d)'s Stack Frame Removed\n", n);
}

int main() {
  
  	// Calling recursive function from main()
    f(3);
    return 0;
}

Output

F(3)'s Stack Frame Pushed
F(2)'s Stack Frame Pushed
F(1)'s Stack Frame Pushed
F(1)'s Stack Frame Removed
F(1)'s Stack Frame Pushed
F(1)'s Stack Frame Removed
F(2)'s Stack Frame Removed
F(2)'s Stack Frame Pushed
F(1)'s Stack Frame Pushed
F(1)'s Stack Frame Removed
F(1)'s Stack Frame Pushed
F(1)'s Stack Frame Removed
F(2)'s Stack Frame Removed
F(3)'s Stack Frame Removed

From the above output, we can deduce which function's stack frame is first created and removed. The below diagram helps us to visualize this in call stack memory.