Understanding MSP vs PSP in ARM Cortex-M

In ARM Cortex-M architectures such as Cortex-M3, Cortex-M4, Cortex-M7, and Cortex-M33, stack management is a fundamental mechanism that enables exception handling, context switching, and real-time operating system (RTOS) operation.

One of the unique features of the ARM Cortex-M core is its support for two independent stack pointers: the Main Stack Pointer (MSP) and the Process Stack Pointer (PSP). This dual-stack design provides a clean separation between privileged system code and unprivileged application tasks, significantly improving system reliability, security, and real-time behavior

In this blog post, we will explore the difference between MSP and PSP (MSP vs PSP), how the processor switches between them, and when to use each. We will also look at practical examples and common use cases like RTOS integration.

📌 What Is a Stack Pointer?

The Stack Pointer (SP) is a CPU register (typically R13 in ARM architecture) that tracks the top of the stack in memory. The stack memory is used to store return addresses, local variables, and CPU context during interrupts.

In ARM Cortex-M cores, there are two stack pointers:

• MSP (Main Stack Pointer): The default stack pointer used after reset and during exceptions.
• PSP (Process Stack Pointer): An alternate stack pointer used optionally in thread (normal) mode.

MSP (Main Stack Pointer):

✅ Characteristics:

• Used by default after reset.
• Automatically used during exceptions and interrupts.
• Stored in the MSP register.
• Suitable for applications not using RTOS.

How to read the current value of SP into a variable:

There are many ways to read stack pointers. Here are some examples.

🔧 Example 1:

uint32_t mspValue = __get_MSP();

🔍 What it does:

• Reads the Main Stack Pointer (MSP) register directly.
• Provided by CMSIS and works across all ARM Cortex-M cores.

✔ Pros:

• ✅ Portable
• ✅ Safe and clear
• ✅ Supported by all toolchains that use CMSIS

❗ Note:
This reads only MSP, regardless of whether the CPU is using PSP or MSP at that moment.

🔧 Example 2:

register uint32_t sp;

asm volatile ("MOV %0, SP" : "=r" (sp));

🔍 What it does:

• Reads the currently active stack pointer (could be MSP or PSP depending on CONTROL.SPSEL).
• Uses GCC-style inline assembly.

✔ Pros:

• ✅ Reads the active SP (not just MSP)
• ✅ Useful in debugging, low-level runtime code

❌ Cons:

• ❌ Not portable to compilers like IAR/Keil (syntax is GCC-specific)
• ❌ Less readable for beginners
• ❌ Compiler may optimize unexpectedly without volatile

🔧 Example 2:

If you are using an RTOS or custom thread model and want to determine which SP is active:

uint32_t active_sp;
asm volatile ("MOV %0, SP" : "=r" (active_sp));

uint32_t control = __get_CONTROL();
if (control & (1 << 1)) 
{
    // Using PSP
} else 
{
    // Using MSP
}

How to set the current value of SP into a variable:

🔧 Example 1: (Recommended)

__set_MSP(app_sp)

✔ Pros:

• ✅ Portable across ARM compilers (GCC, IAR, Keil) using CMSIS
• ✅ Safe and well-documented
• ✅ Compiler understands its semantics (can optimize, prevent reordering)
• ✅ Readable and intention-clear to other developers

❗ Use Cases:

• Setting MSP at boot/startup
• Jumping to another image or firmware
• Context switch (if you’re building a scheduler)

🔧 Example 1:

asm volatile ("MOV SP, %0" :: "r" (sp_val));

✔ Pros:

• ✅ Works fine if you’re careful
• ✅ Gives you full control at the assembly level

❌ Cons:

• ❌ Not portable across compilers (inline assembly syntax differs between GCC, IAR, etc.)
• ❌ Harder to maintain and read
• ❌ Compiler might not fully understand side effects unless marked volatile
• ❌ Easy to misuse in timing-critical or ISR code

✅ Safe Use Cases for Setting MSP:

1. Early Startup (Bootloader / Reset Handler):

At the very beginning (e.g., in _start() or Reset_Handler), it’s safe to do:

__set_MSP(initial_stack_addr);

Often used in bootloaders or when jumping to a new image.

2. Before Jumping to Another Application:

If you load an application (e.g., from QSPI Flash) and want to hand over execution:

typedef void (*app_entry_t)(void);

void jump_to_app(uint32_t app_sp, uint32_t app_entry_addr)
{
    __disable_irq();             // Disable interrupts
    __set_MSP(app_sp);           // Set new stack pointer
    app_entry_t app = (app_entry_t)app_entry_addr;
    app();                       // Jump to application
}

3. Context Switch in Bare-Metal Task Scheduler:

If you’re writing your own context switcher:

__set_MSP(task->stack_top);

But be careful: you must save and restore full context manually.

🚫 When NOT to Set MSP:

• ❌ In an interrupt handler — use the existing stack
• ❌ While in Thread mode without switching away from MSP first
• ❌ If using RTOS — kernel manages it internally

PSP (Process Stack Pointer)

✅ Characteristics:

• Manually enabled via the CONTROL register.
• Used only in Thread mode (i.e., normal application execution).
• Commonly used in RTOS environments for per-task stacks.
• Stored in the PSP register.

🔧 Example Use Case:

// 1. Set the PSP (Process Stack Pointer) to point to the new task's stack
__set_PSP(new_task_stack_pointer);

// 2. Set CONTROL register to switch from MSP to PSP
// Bit 1 of CONTROL = 1 means use PSP instead of MSP
__set_CONTROL(__get_CONTROL() | (1 << 1));

// 3. Execute an Instruction Synchronization Barrier (ISB)
// Ensures the change to CONTROL takes effect immediately
__ISB();

🧠 Explanation of Each Line:

1.✅ __set_PSP(new_task_stack_pointer);

• • This sets the Process Stack Pointer (PSP) to the new task’s stack.
  • This is useful in multitasking or context switching where each task has its own stack.

2. ✅ __set_CONTROL(__get_CONTROL() | (1 << 1));

• • This reads the current CONTROL register, sets bit 1 to 1, and writes it back.
  • CONTROL[1] = 1 switches the stack pointer used by the processor from MSP (Main Stack Pointer) to PSP (Process Stack Pointer).
  • This is crucial for running unprivileged threads or tasks with their own stacks.

3. ✅ __ISB();

• • The Instruction Synchronization Barrier ensures that the processor flushes the pipeline and refetches instructions.
  • This is necessary because the processor may still execute instructions assuming the old stack pointer unless explicitly synchronized.

🔁 Switching Between MSP and PSP:

ARM Cortex-M uses the CONTROL register bit 1 to select the active stack pointer in Thread mode:

Note: In Handler mode (i.e., interrupts), the processor always uses MSP regardless of CONTROL register settings.

MSP vs PSP in ARM Cortex-M:

To clearly understand when and how to use MSP and PSP in Cortex-M architecture, the following table offers a deep technical comparison. It highlights operational behavior, usage in different modes, security implications, and typical use cases. Whether you’re working on a bare-metal system or designing an RTOS kernel, this breakdown will help you choose the right stack pointer for your needs.

Recommended Post:

• Reset an ARM Cortex-M with Software.
• IAR Linker Script for STM32: Complete Guide (Basic to Advanced).
• Understanding the Role of Start-Up Code in Microcontrollers.
• Embedded system interview Questions with Answers
• MCQ on ARM Processor Part 1.
• Control Register in ARM.