How ARM Handles Stack During Interrupts Explained Simply

When an interrupt occurs, ARM processors automatically save key registers on the current stack using a process called stacking. ARM uses separate banked stack pointers for different modes (like IRQ mode) to keep interrupt handling isolated and safe.

Syntax

ARM uses special processor modes and banked stack pointers to handle interrupts. The key syntax elements are:

• SP_irq: Stack Pointer used in IRQ mode.
• LR_irq: Link Register saved on interrupt entry.
• SRS (Store Return State) instruction: used in ARMv7-M to save registers automatically.
• Automatic stacking: hardware pushes registers R0-R3, R12, LR, PC, xPSR onto the stack.

This syntax is part of the ARM architecture's interrupt entry and exit mechanism.

armasm

IRQ_Handler:
    SUB SP_irq, SP_irq, #32   ; Make space on IRQ stack
    STMIA SP_irq!, {R0-R3, R12, LR} ; Save registers manually
    ; Interrupt handling code here
    LDMIA SP_irq!, {R0-R3, R12, LR} ; Restore registers
    SUBS PC, LR, #4          ; Return from interrupt

Example

This example shows how ARM Cortex-M automatically saves registers on the stack during an interrupt and restores them on return.

c

void IRQ_Handler(void) {
    // On interrupt entry, hardware pushes R0-R3, R12, LR, PC, xPSR on stack
    // Software can use these registers safely
    // Interrupt service routine code here
    // On exit, hardware pops these registers automatically
}

int main(void) {
    // Normal program code
    while(1) {
        // Wait for interrupt
    }
}

Output

No direct output; demonstrates automatic stacking during interrupt handling.

Common Pitfalls

Common mistakes when handling stack during ARM interrupts include:

• Using the wrong stack pointer (SP_main vs SP_irq) causing stack corruption.
• Not preserving banked registers properly when switching modes.
• Manually pushing/popping registers that hardware already saves, leading to double stacking.
• Ignoring stack alignment requirements, which can cause faults.

Always rely on ARM's automatic stacking when possible and use the correct stack pointer for the current mode.

armasm

/* Wrong: Using main stack pointer in IRQ mode */
IRQ_Handler:
    PUSH {R0-R3}      ; Incorrect: hardware already saves these
    ; ...
    POP {R0-R3}
    BX LR

/* Correct: Use IRQ stack pointer and rely on hardware stacking */
IRQ_Handler:
    ; Interrupt code here
    BX LR

Quick Reference

Concept	Description
Banked Stack Pointers	Separate SP for IRQ and other modes to isolate stacks.
Automatic Stacking	Hardware saves R0-R3, R12, LR, PC, xPSR on interrupt entry.
Stack Alignment	Stack must be 8-byte aligned to avoid faults.
Return from Interrupt	Uses special instructions (e.g., BX LR) to restore state.
Manual Stacking	Only needed if extra registers must be saved beyond hardware automatic.

Key Takeaways

ARM uses banked stack pointers to keep interrupt stacks separate and safe.

Hardware automatically saves key registers on the stack when an interrupt occurs.

Use the correct stack pointer for the current processor mode to avoid corruption.

Avoid manually saving registers that hardware already stacks automatically.

Maintain proper stack alignment to prevent faults during interrupt handling.