Refactor fault handling code

The code now records the original addresses of the fault handlers
before switching them to the debug stubs to reduce code duplication
by having a unique stub for each of HardFault, MemManagement,
BusFault, and UsageFault that just loads the original address into R3
and then transfers control to the common mriFaultHandlerStub().

Author: adamgreen

libraries/ThreadMRI/src/ThreadMRI.cpp

@@ -100,6 +100,11 @@ volatile osThreadId_t           mriThreadSingleStepThreadId;
 volatile uint32_t               mriThreadOrigSVCall;
 volatile uint32_t               mriThreadOrigSysTick;
 volatile uint32_t               mriThreadOrigPendSV;
+// Addresses of the original fault handlers before being replaced with debugger specific ones.
+volatile uint32_t               mriThreadOrigHardFault;
+volatile uint32_t               mriThreadOrigMemManagement;
+volatile uint32_t               mriThreadOrigBusFault;
+volatile uint32_t               mriThreadOrigUsageFault;
 
 // UNDONE: For debugging. If different than g_haltedThreadId then the mriMain() thread was signalled when the previous
 //         instance was still running.
@@ -108,9 +113,12 @@ static volatile osThreadId_t    g_debugThreadId;
 
 
 
-// Assembly Language fault handling stubs. They do some preprocessing and then call the C handlers below if appropriate.
+// Assembly Language fault handling stubs. They do some preprocessing and then call the C handlers if appropriate.
 extern "C" void mriDebugMonitorHandlerStub(void);
-extern "C" void mriFaultHandlerStub(void);
+extern "C" void mriHardFaultHandlerStub(void);
+extern "C" void mriMemManagementHandlerStub(void);
+extern "C" void mriBusFaultHandlerStub(void);
+extern "C" void mriUsageFaultHandlerStub(void);
 // Assembly Language stubs for RTX context switching routines. They check to see if DebugMon should be pended before
 // calling the actual RTX handlers.
 extern "C" void mriSVCHandlerStub(void);
@@ -128,7 +136,7 @@ static bool hasEncounteredDebugEvent();
 static void recordAndClearFaultStatusBits();
 static void wakeMriMainToDebugCurrentThread();
 static void stopSingleStepping();
-static void switchFaultHandlersToDebugger();
+static void recordAndSwitchFaultHandlersToDebugger();
 
 
 
@@ -306,15 +314,20 @@ void Platform_Init(Token* pParameterTokens)
 
     g_enableDWTandFPB = 0;
     mriThreadSingleStepThreadId = NULL;
-    switchFaultHandlersToDebugger();
+    recordAndSwitchFaultHandlersToDebugger();
 }
 
-static void switchFaultHandlersToDebugger(void)
+static void recordAndSwitchFaultHandlersToDebugger()
 {
-    NVIC_SetVector(HardFault_IRQn,        (uint32_t)mriFaultHandlerStub);
-    NVIC_SetVector(MemoryManagement_IRQn, (uint32_t)mriFaultHandlerStub);
-    NVIC_SetVector(BusFault_IRQn,         (uint32_t)mriFaultHandlerStub);
-    NVIC_SetVector(UsageFault_IRQn,       (uint32_t)mriFaultHandlerStub);
+    mriThreadOrigHardFault = NVIC_GetVector(HardFault_IRQn);
+    mriThreadOrigMemManagement = NVIC_GetVector(MemoryManagement_IRQn);
+    mriThreadOrigBusFault = NVIC_GetVector(BusFault_IRQn);
+    mriThreadOrigUsageFault = NVIC_GetVector(UsageFault_IRQn);
+
+    NVIC_SetVector(HardFault_IRQn,        (uint32_t)mriHardFaultHandlerStub);
+    NVIC_SetVector(MemoryManagement_IRQn, (uint32_t)mriMemManagementHandlerStub);
+    NVIC_SetVector(BusFault_IRQn,         (uint32_t)mriBusFaultHandlerStub);
+    NVIC_SetVector(UsageFault_IRQn,       (uint32_t)mriUsageFaultHandlerStub);
     NVIC_SetVector(DebugMonitor_IRQn,     (uint32_t)mriDebugMonitorHandlerStub);
 }
 

libraries/ThreadMRI/src/ThreadMRI_asm.S

@@ -48,13 +48,13 @@ mriDebugMonitorHandlerStub:
     .size   mriDebugMonitorHandlerStub, .-mriDebugMonitorHandlerStub
 
 
-    // UNDONE: Have a separate stub for each fault handler (hard, memmanage, bus, usage)
     .global mriFaultHandlerStub
     .type mriFaultHandlerStub, function
     .thumb_func
     /* extern "C" void mriFaultHandlerStub(void);
-       This stub is called whenever a fault fires. It checks the EXC_RETURN value to determine if thread or handler
-       mode caused fault:
+       This stub is called whenever a fault fires w/ R3 set to the original handler for the particular fault. This
+       allows the original handler to be called if a crash occurs in handler mode which can't be debugged by ThreadMRI.
+       It checks the EXC_RETURN value to determine if thread or handler mode caused fault:
         Thread: Pass control to mriFaultHandler() so that it can be debugged.
         Handler: If caused by debug event, pass control to mriFaultHandler() so that break/watchpoints can be disabled.
                  Otherwise pass control to the standard mbed-os HardFault_Handler so that crash can be dumped.
@@ -72,14 +72,76 @@ mriFaultHandlerStub:
     ldr     r1, =HFSR
     ldr     r1, [r1]
     tst     r1, #HFSR_DEBUG_EVENT_BIT
-    /* If not a debug event then fall through to default hard fault handler as something bad has happened. */
-    beq.w   HardFault_Handler
     /* If forced into hard fault due to debug event then breakpoint/watchpoint occurred and needs to be ignored. */
-    b.w     mriFaultHandler
+    bne.w   mriFaultHandler
+    /* If not a debug event then fall through to default hard fault handler as something bad has happened. */
+    mov     pc, r3
     .pool
     .size   mriFaultHandlerStub, .-mriFaultHandlerStub
 
 
+    .global mriHardFaultHandlerStub
+    .type mriHardFaultHandlerStub, function
+    .thumb_func
+    /* extern "C" void mriHardFaultHandlerStub(void);
+       This stub is called whenever a Hard Fault fires.
+    */
+mriHardFaultHandlerStub:
+    /* Load address of real fault handler into r3 & call generic fault stub. */
+    ldr     r3, =mriThreadOrigHardFault
+    ldr     r3, [r3]
+    b       mriFaultHandlerStub
+    .pool
+    .size   mriHardFaultHandlerStub, .-mriHardFaultHandlerStub
+
+
+    .global mriMemManagementHandlerStub
+    .type mriMemManagementHandlerStub, function
+    .thumb_func
+    /* extern "C" void mriMemManagementHandlerStub(void);
+       This stub is called whenever a MemManagement fault fires.
+    */
+mriMemManagementHandlerStub:
+    /* Load address of real fault handler into r3 & call generic fault stub. */
+    ldr     r3, =mriThreadOrigMemManagement
+    ldr     r3, [r3]
+    b       mriFaultHandlerStub
+    .pool
+    .size   mriMemManagementHandlerStub, .-mriMemManagementHandlerStub
+
+
+    .global mriBusFaultHandlerStub
+    .type mriBusFaultHandlerStub, function
+    .thumb_func
+    /* extern "C" void mriBusFaultHandlerStub(void);
+       This stub is called whenever a Bus Fault fires.
+    */
+mriBusFaultHandlerStub:
+    /* Load address of real fault handler into r3 & call generic fault stub. */
+    ldr     r3, =mriThreadOrigBusFault
+    ldr     r3, [r3]
+    b       mriFaultHandlerStub
+    .pool
+    .size   mriBusFaultHandlerStub, .-mriBusFaultHandlerStub
+
+
+    .global mriUsageFaultHandlerStub
+    .type mriUsageFaultHandlerStub, function
+    .thumb_func
+    /* extern "C" void mriUsageFaultHandlerStub(void);
+       This stub is called whenever a Usage Fault fires.
+    */
+mriUsageFaultHandlerStub:
+    /* Load address of real fault handler into r3 & call generic fault stub. */
+    ldr     r3, =mriThreadOrigUsageFault
+    ldr     r3, [r3]
+    b       mriFaultHandlerStub
+    .pool
+    .size   mriUsageFaultHandlerStub, .-mriUsageFaultHandlerStub
+
+
+
+
     .global mriRTXHandlerStub
     .type mriRTXHandlerStub, function
     .thumb_func