Stack overflow detection in Embedded C - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a stack pointer variable.

Embedded C

int [1] = -1;  // Stack pointer initialized

Drag options to blanks, or click blank then click option'

Astack_ptr

Btop

Csp

Dpointer

Attempts:

3 left

💡 Hint

Common Mistakes

Using a variable name that is not descriptive of the stack pointer.

Initializing the pointer with a wrong value.

The variable 'top' is commonly used as the stack pointer to track the top element index.

2fill in blank

medium

Complete the code to check if the stack is full.

Embedded C

if (top == [1] - 1) {
    // Stack is full
}

Drag options to blanks, or click blank then click option'

ASIZE

BMAX_SIZE

CSTACK_SIZE

DMAX_STACK

Attempts:

3 left

💡 Hint

Common Mistakes

Using the wrong constant name for stack size.

Checking for equality with the wrong value.

The stack is full when the top index equals STACK_SIZE - 1, the last valid index.

3fill in blank

hard

Fix the error in the stack overflow detection condition.

Embedded C

if (top [1] STACK_SIZE) {
    // Overflow detected
}

Drag options to blanks, or click blank then click option'

A>=

B==

C>

D<=

Attempts:

3 left

💡 Hint

Common Mistakes

Using '==' which misses cases where top is greater than STACK_SIZE.

Using '<=' which is incorrect for overflow detection.

The stack overflows if top is greater than or equal to STACK_SIZE, which is beyond the last valid index.

4fill in blank

hard

Fill both blanks to correctly update the stack pointer and detect overflow.

Embedded C

top [1] top + 1;
if (top [2] STACK_SIZE) {
    // Handle overflow
}

Drag options to blanks, or click blank then click option'

A=

B>=

C>

D==

Attempts:

3 left

💡 Hint

Common Mistakes

Using '+' instead of '=' for assignment.

Using '>' instead of '>=' for overflow check.

First, increment the top pointer with '=', then check if it is greater than or equal to STACK_SIZE to detect overflow.

5fill in blank

hard

Fill all three blanks to implement a safe push function with overflow detection.

Embedded C

void push(int stack[], int value) {
    if (top [1] STACK_SIZE - 1) {
        // Stack overflow error
        return;
    }
    top [2] top + 1;
    stack[[3]] = value;
}

Drag options to blanks, or click blank then click option'

A>=

B=

Ctop

D>

Attempts:

3 left

💡 Hint

Common Mistakes

Using '>' instead of '>=' in overflow check.

Using '+' instead of '=' for increment.

Using wrong index for stack assignment.

Check if top is greater or equal to STACK_SIZE - 1 to detect full stack, then increment top with '=', and assign value to stack[top].

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