Stack overflow detection in Embedded C - Step-by-Step Execution

Concept Flow - Stack overflow detection

Start Program

↓

Function Call

↓

Push Stack Frame

↓

Check Stack Pointer

↓

Continue

↓

Return

↓

End

When a function is called, a new stack frame is pushed. The system checks if the stack pointer exceeds the limit. If yes, overflow is detected and handled.

Execution Sample

Embedded C

void func() {
  char buffer[10];
  // simulate overflow
  for(int i=0; i<20; i++) {
    buffer[i] = i;
  }
}

This code simulates a stack overflow by writing beyond the buffer size.

Execution Table

Step	Action	Stack Pointer (SP)	Condition	Result	Output/Effect
1	Enter func(), push stack frame	SP=1000	SP < STACK_LIMIT(1024)?	True	Continue execution
2	Write buffer[0] = 0	SP=1000	SP < STACK_LIMIT	True	No overflow
3	Write buffer[9] = 9	SP=1000	SP < STACK_LIMIT	True	No overflow
4	Write buffer[10] = 10 (overflow)	SP=1000	SP < STACK_LIMIT	False	Stack overflow detected!
5	Trigger overflow handler	SP=1000	-	-	Handle error, stop or reset
6	Exit func() due to error	SP=1000	-	-	Program halted or recovered

💡 At step 4, writing beyond buffer size causes stack pointer to exceed limit, triggering overflow detection.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
SP	1000	1000	1000	1000	1000
buffer index	-	0	9	10	-
Overflow Flag	False	False	False	True	True

Key Moments - 3 Insights

Why does the stack pointer (SP) not change even when writing beyond buffer?

In this example, SP is fixed for simplicity; actual overflow is detected by comparing write index to buffer size, as shown in execution_table step 4.

What happens when overflow is detected at step 4?

The program triggers an overflow handler to prevent corruption or crash, as shown in step 5 and 6.

Why do we check SP against STACK_LIMIT before continuing?

To ensure the stack does not grow beyond its allocated memory, preventing data corruption or crashes.

Visual Quiz - 3 Questions

Look at the execution table, at which step is the stack overflow detected?

A Step 5

B Step 2

C Step 4

D Step 3

💡 Hint

Check the 'Result' column for 'Stack overflow detected!' in the execution_table.

According to variable_tracker, what is the value of Overflow Flag after step 3?

A False

B Undefined

C True

D 1

💡 Hint

Look at the Overflow Flag row under 'After Step 3' in variable_tracker.

If the STACK_LIMIT was increased, how would the execution_table change?

A Overflow detected earlier

B Overflow detected later or not at all

C No change in overflow detection

D Program crashes immediately

💡 Hint

Consider the 'Condition' and 'Result' columns in execution_table and how STACK_LIMIT affects them.

Concept Snapshot

Stack overflow detection:
- Stack frames push on function calls
- Stack pointer (SP) tracks usage
- Check SP against STACK_LIMIT
- If SP exceeds limit, trigger overflow handler
- Prevents memory corruption and crashes

Full Transcript

Stack overflow detection happens when a program uses more stack memory than allowed. Each function call pushes a frame on the stack, increasing the stack pointer (SP). Before continuing, the program checks if SP is below a set limit. If SP exceeds this limit, an overflow is detected. The program then triggers an overflow handler to stop or recover safely. In the example, writing beyond a buffer simulates overflow, detected at step 4. The overflow flag changes from false to true, and the handler runs to prevent damage.