FreeRTOS-MPU: Read running task stack pointer from $sp register (#73)

* FreeRTOS-MPU: Read running task stack pointer from $sp register

* FreeRTOS-MPU: try Cortex-A/R $r13_usr before $sp

During ISRs and other exception handlers, $sp uses one of the banked r13
registers (r13_irq, r13_fiq, etc.). Use $r13_usr if available instead.

* FreeRTOS-MPU: try Cortex-M $psp before $sp

During ISRs and other exception handlers, $sp is linked to $msp. Use the
task stack pointer $psp if available instead.

* getStackPointerRegVal: try $sp_usr for OpenOCD compatibility

Author: malsyned

src/rtos/rtos-common.ts

@@ -194,6 +194,31 @@ export abstract class RTOSBase {
         }
     }
 
+    protected async getStackPointerRegVal(frameId: number): Promise<number | undefined> {
+        const spRegs = [
+            // Cortex-M ports use PSP for task stacks, MSP for exceptions
+            'psp',
+            // Cortex-A/R uses r13_usr for task stacks, r13_irq, r13_fiq, r13_svc, etc. for exceptions
+            'r13_usr',
+            // ...but OpenOCD calls it sp_usr, not r13_usr
+            'sp_usr',
+            // Both GDB and LLDB provide a generic stack pointer alias named $sp
+            // on platforms that don't already define a register named "sp". For
+            // other debuggers, this method may fail to find the stack pointer
+            // register.
+            'sp',
+        ];
+        for (const spReg of spRegs) {
+            try {
+                const val = parseInt((await this.evalForVarValue(frameId, `$${spReg}`)) || '');
+                if (val) {
+                    return val;
+                }
+            } catch (e) {}
+        }
+        return undefined;
+    }
+
     protected async detectArchitectureIfEmpty(
         architecture: Architecture | undefined,
         frameId: number

src/rtos/rtos-freertos.ts

@@ -645,7 +645,6 @@ export class RTOSFreeRTOS extends RTOSCommon.RTOSBase {
                                 (await this.getExprVal('(char *)' + thInfo['pcTaskName']?.exp, frameId)) || '';
                             const match = tmpThName.match(/"([^*]*)"$/);
                             const thName = match ? match[1] : tmpThName;
-                            const stackInfo = await this.getStackInfo(thInfo, 0xA5, frameId);
                             // This is the order we want stuff in
                             const display: { [key: string]: RTOSCommon.DisplayRowItem } = {};
                             const mySetter = (x: DisplayFields, text: string, value?: any) => {
@@ -692,6 +691,7 @@ export class RTOSFreeRTOS extends RTOSCommon.RTOSBase {
                                     }
                                 }
                             }
+                            const stackInfo = await this.getStackInfo(threadRunning, thInfo, 0xA5, frameId);
                             mySetter(DisplayFields.StackStart, RTOSCommon.hexFormat(stackInfo.stackStart));
                             mySetter(
                                 DisplayFields.StackTop,
@@ -750,15 +750,16 @@ export class RTOSFreeRTOS extends RTOSCommon.RTOSBase {
         });
     }
 
-    protected async getStackInfo(thInfo: RTOSCommon.RTOSStrToValueMap, waterMark: number, frameId: number) {
+    protected async getStackInfo(threadRunning: boolean, thInfo: RTOSCommon.RTOSStrToValueMap, waterMark: number, frameId: number) {
         const pxStack = thInfo['pxStack']?.val;
         const pxTopOfStack = thInfo['pxTopOfStack']?.val;
         const pxEndOfStack = thInfo['pxEndOfStack']?.val;
         const stackInfo: RTOSCommon.RTOSStackInfo = {
             stackStart: parseInt(pxStack),
             stackTop: parseInt(pxTopOfStack)
         };
-        const mpuStackTop = await this.mpuGetStackTop(thInfo, frameId);
+
+        const mpuStackTop = await this.mpuGetStackTop(threadRunning, thInfo, frameId);
         if (mpuStackTop === null) {
             stackInfo.stackTop = undefined;
         } else if (mpuStackTop !== undefined) {
@@ -817,6 +818,7 @@ export class RTOSFreeRTOS extends RTOSCommon.RTOSBase {
     // * undefined: no MPU context was found (meaning pxTopOfStack can be used for deltas)
     // * null: MPU context was found, but could not be interpreted (unsupported architecture, unexpected size, etc.)
     private async mpuGetStackTop(
+        threadRunning: boolean,
         thInfo: RTOSCommon.RTOSStrToValueMap,
         frameId: number
     ): Promise<number | null | undefined> {
@@ -825,8 +827,11 @@ export class RTOSFreeRTOS extends RTOSCommon.RTOSBase {
         }
         const xMPUSettings = (await this.getVarChildrenObj(thInfo['xMPUSettings'].ref, 'xMPUSettings')) || {};
 
-        // non-privileged tasks use a separate system call stack, and back up
-        // their task SP. Use that backup if it's present and non-NULL.
+        // When a non-privileged task voluntarily relinquishes the CPU,
+        // uxContext contains a pointer into the system call stack, rather than
+        // the task stack. While that task is paused, pulTaskStack
+        // (pulTaskStackPointer on some ports) will contain a backup of the
+        // task's stack pointer. (continued...)
         if ('xSystemCallStackInfo' in xMPUSettings) {
             const xSystemCallStackInfo =
                 (await this.getVarChildrenObj(xMPUSettings['xSystemCallStackInfo'].ref, 'xSystemCallStackInfo')) || {};
@@ -840,6 +845,18 @@ export class RTOSFreeRTOS extends RTOSCommon.RTOSBase {
             }
         }
 
+        // (...) However, when that task returns to a RUNNING state,
+        // pulTaskStack gets zeroed and the only way to get a stack top that
+        // bears any resemblance to reality is to read directly from the stack
+        // pointer register. Note that this can still have surprising results if
+        // the program is halted in an ISR or system call.
+        if (threadRunning) {
+            const taskSP = await this.getStackPointerRegVal(frameId);
+            if (taskSP !== undefined) {
+                return taskSP;
+            }
+        }
+
         if (!('ulContext' in xMPUSettings)) {
             return undefined;
         }