Stack overflow detection in Embedded C - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a stack overflow in embedded C?

A stack overflow happens when a program uses more stack memory than is allocated, causing data to overwrite adjacent memory and potentially crash the system.

intermediate

How can you detect a stack overflow in embedded systems?

You can detect stack overflow by placing a known pattern (a 'canary') at the stack boundary and checking if it changes, or by monitoring the stack pointer to ensure it stays within limits.

intermediate

What is a 'stack canary' and how does it help?

A stack canary is a special value placed at the edge of the stack. If this value changes, it means the stack has overflowed and overwritten memory, signaling an error.

beginner

Why is stack overflow detection important in embedded systems?

Because embedded systems often have limited memory and run critical tasks, detecting stack overflow prevents crashes and unpredictable behavior that can cause system failure.

intermediate

What role does the stack pointer play in stack overflow detection?

The stack pointer shows the current top of the stack. Monitoring it helps ensure it does not go beyond the allocated stack memory, which would indicate overflow.

What happens when a stack overflow occurs in embedded C?

A The stack pointer resets automatically

B The program runs faster

C Memory outside the stack is overwritten

D The CPU temperature decreases

Stack overflow causes the program to overwrite memory outside the stack, which can corrupt data or crash the system.

Which method is commonly used to detect stack overflow?

A Using a stack canary value

B Increasing CPU clock speed

C Disabling interrupts

D Using global variables only

A stack canary is a known value placed at the stack boundary to detect overflow if it changes.

What does the stack pointer indicate in embedded systems?

A The CPU temperature

B The size of the heap

C The number of running tasks

D The current top of the stack

The stack pointer points to the current top of the stack in memory.

Why is stack overflow detection critical in embedded systems?

A Because stack overflow improves performance

B Because embedded systems have limited memory and critical tasks

C Because embedded systems have unlimited memory

D Because embedded systems never use the stack

Embedded systems have limited memory and often run important tasks, so detecting overflow prevents failures.

What is a sign that a stack overflow has occurred?

A The stack canary value is changed

B The CPU clock speed increases

C The program uses less memory

D The stack pointer moves down

If the stack canary value is altered, it means the stack overflowed and overwrote that memory.

Explain how a stack canary helps detect stack overflow in embedded C.

Think about a special marker that warns if memory is overwritten.

Describe why monitoring the stack pointer is useful for detecting stack overflow.

Consider what the stack pointer tells us about memory usage.

Practice

1.

What is the main purpose of stack overflow detection in embedded C?

easy

A. To increase the stack size dynamically

B. To prevent writing data beyond the stack's fixed size

C. To optimize CPU speed

D. To clear the stack memory automatically

Solution

1. Step 1: Understand stack overflow concept

   Stack overflow occurs when data is pushed beyond the stack's allocated size.

2. Step 2: Identify purpose of detection

   Detection helps prevent writing beyond stack limits, avoiding crashes and corruption.

3. Final Answer:

   To prevent writing data beyond the stack's fixed size -> Option B

4. Quick Check:

   Stack overflow detection = prevent overflow [OK]

Hint: Stack overflow detection stops writes beyond stack size [OK]

Common Mistakes:

• Thinking stack size can grow automatically
• Confusing overflow detection with CPU optimization
• Assuming stack clears itself on overflow

2.

Which of the following code snippets correctly checks for stack overflow before pushing a value?

int stack[10];
int sp = 0; // stack pointer
int value = 5;

// Check before push
if (____) {
    stack[sp++] = value;
}

easy

A. sp < 10

B. sp > 10

C. sp == 10

D. sp >= 10

Solution

1. Step 1: Understand stack pointer and size

   Stack size is 10, valid indices are 0 to 9, so sp must be less than 10 to push.

2. Step 2: Choose correct condition

   Condition 'sp < 10' ensures we don't write beyond array bounds.

3. Final Answer:

   sp < 10 -> Option A

4. Quick Check:

   Push only if sp less than stack size [OK]

Hint: Check sp < stack size before push [OK]

Common Mistakes:

• Using sp >= 10 allows overflow
• Using sp == 10 pushes out of bounds
• Using sp > 10 misses last valid index

3.

What will be the output of the following code snippet?

int stack[3];
int sp = 0;

void push(int val) {
    if (sp < 3) {
        stack[sp++] = val;
        printf("Pushed %d\n", val);
    } else {
        printf("Stack Overflow!\n");
    }
}

int main() {
    push(1);
    push(2);
    push(3);
    push(4);
    return 0;
}

medium

A. Pushed 1
Pushed 2
Pushed 3
Stack Overflow!

B. Pushed 1
Pushed 2
Pushed 3
Pushed 4

C. Stack Overflow!
Stack Overflow!
Stack Overflow!
Stack Overflow!

D. Pushed 1
Pushed 2
Stack Overflow!
Stack Overflow!

Solution

1. Step 1: Trace push calls and stack pointer

   First three pushes succeed because sp < 3; fourth push fails as sp == 3.

2. Step 2: Check output for each push

   Outputs "Pushed 1", "Pushed 2", "Pushed 3", then "Stack Overflow!" on last push.

3. Final Answer:

   Pushed 1 Pushed 2 Pushed 3 Stack Overflow! -> Option A

4. Quick Check:

   Pushes succeed until sp == 3, then overflow [OK]

Hint: Pushes stop when sp reaches stack size [OK]

Common Mistakes:

• Assuming push always succeeds
• Ignoring else branch output
• Confusing sp increment timing

4.

Identify the bug in the following stack push function that causes stack overflow detection to fail:

void push(int val) {
    if (sp <= 3) {
        stack[sp++] = val;
    } else {
        printf("Overflow detected\n");
    }
}

medium

A. sp is not incremented after push

B. Stack size is not checked at all

C. Condition should be sp < 3, not sp <= 3

D. printf statement is inside if block

Solution

1. Step 1: Analyze condition sp <= 3 with stack size 3

   sp can be 3, but valid indices are 0,1,2; sp=3 causes out-of-bounds write.

2. Step 2: Correct condition to prevent overflow

   Use sp < 3 to allow only valid indices 0 to 2.

3. Final Answer:

   Condition should be sp < 3, not sp <= 3 -> Option C

4. Quick Check:

   Use strict less than to avoid overflow [OK]

Hint: Use sp < stack size, not <=, to avoid overflow [OK]

Common Mistakes:

• Allowing sp == stack size causes overflow
• Not incrementing sp after push
• Misplacing overflow message

5.

You have a stack of size 5 and want to implement a safe push function that returns 0 on success and -1 on overflow. Which code snippet correctly implements this?

int stack[5];
int sp = 0;

int push(int val) {
    // Fill in condition
    if (__________) {
        stack[sp++] = val;
        return 0;
    } else {
        return -1;
    }
}

hard

A. sp > 5

B. sp <= 5

C. sp == 5

D. sp < 5

Solution

1. Step 1: Understand stack size and valid indices

   Stack size is 5, so valid indices are 0 to 4; sp must be less than 5 to push safely.

2. Step 2: Choose condition that prevents overflow

   Condition 'sp < 5' ensures no out-of-bounds write and returns 0 on success.

3. Final Answer:

   sp < 5 -> Option D

4. Quick Check:

   Push only if sp less than stack size [OK]

Hint: Return error if sp not less than stack size [OK]

Common Mistakes:

• Using sp <= 5 allows overflow
• Returning success on overflow
• Checking sp == 5 instead of less than