ThreadMRI can now be global

ThreadMRI can now be declared as a global like DebugSerial. It will
take care of calling begin() on the underlying Serial object. So now if
you declare a ThreadMRI object somewhere in your code, that will be
enough to pull the MRI debug monitor into your code so that you can use
GDB for remote debugging.

The implementation of calling HardwareSerial::begin() takes a bit of
extra work:
* At time the ThreadMRI object's constructor runs, the underlying
  HardwareSerial object might not yet have been initialized. It is
  safest to perform this call from setup().
* ThreadMRI sets a temporary breakpoint on setup() from its global
  constructor. When this breakpoint hits, it can then call the begin()
  method.

By default the ThreadMRI object will cause execution to be halted on
the first line of setup() so that the user can connect with GDB and
set breakpoints/watchpoints at points of interest before they allow
their program to run. This can be disabled via the 4th parameter
of ThreadMRI's constructor.

I doubled the stack size from 512 to 1024 bytes for mriMain() as the
STM code to initialize the baud rate of the serial port is pretty stack
hungry and it overflowed at 512 bytes.

Author: adamgreen

libraries/ThreadMRI/examples/ThreadMRI/ThreadMRI.ino

@@ -5,16 +5,13 @@
 
 #include <ThreadMRI.h>
 
-ThreadMRI g_debugger;
+ThreadMRI g_debugger(Serial1, USART1_IRQn, 115200, true);
 
 extern "C" void testContext(void);
 
 void setup() {
-    // UNDONE: Using Serial1 for now to unblock my progress.
-    Serial1.begin(115200);
-    g_debugger.begin();
     //testContext();
-    __debugbreak();
+    //__debugbreak();
 }
 
 void loop() {

libraries/ThreadMRI/src/ThreadMRI.cpp

@@ -29,15 +29,10 @@ extern "C"
     #include "architectures/armv7-m/debug_cm3.h"
 }
 
-// UNDONE: Switch back to the USB/CDC based serial port.
-#undef Serial
-#define Serial Serial1
-#define MRI_SERIAL_IRQ USART1_IRQn
-
 
 // Configuration Parameters
 // The size of the mriThread() stack in uint64_t objects.
-#define MRI_THREAD_STACK_SIZE   64
+#define MRI_THREAD_STACK_SIZE   128
 // The maximum number of active threads that can be handled by the debugger.
 #define MAXIMUM_ACTIVE_THREADS  64
 
@@ -77,8 +72,11 @@ extern "C"
 
 
 
-// Flag to verify that only one ThreadMRI object has been initialized.
-static bool                     g_alreadyInitialized;
+// Globals that describe the ThreadMRI singleton.
+static HardwareSerial*          g_pSerial;
+static IRQn_Type                g_irq;
+static uint32_t                 g_baudRate;
+static bool                     g_breakInSetup;
 
 // The ID of the halted thread being debugged.
 static volatile osThreadId_t    g_haltedThreadId;
@@ -143,14 +141,16 @@ static void switchRtxHandlersToDebugStubsForSingleStepping();
 static void restoreRtxHandlers();
 static void setDebugActiveFlag();
 static void clearDebugActiveFlag();
+static void callSerialBeginFromSetup();
+static int justEnteredSetupCallback(void* pv);
+static void hookSerialISR();
 static bool isThreadMode(uint32_t excReturn);
 static bool hasEncounteredDebugEvent();
 static bool hasControlCBeenDetected();
 static void recordAndClearFaultStatusBits();
 static void wakeMriMainToDebugCurrentThread();
 static void stopSingleStepping();
 static void recordAndSwitchFaultHandlersToDebugger();
-static void hookSerialISR();
 static bool isDebugThreadActive();
 static void setFaultDetectedFlag();
 static bool isImpreciseBusFault();
@@ -164,21 +164,32 @@ static void setControlCFlag();
 
 
 
-ThreadMRI::ThreadMRI()
+ThreadMRI::ThreadMRI(HardwareSerial& serial, IRQn_Type IRQn, uint32_t baudRate, bool breakInSetup /* =true */)
 {
+    init(serial, IRQn, baudRate, breakInSetup);
 }
 
+ThreadMRI::ThreadMRI(HardwareSerial& serial, IRQn_Type IRQn)
+{
+    init(serial, IRQn, 0, false);
+}
 
-bool ThreadMRI::begin()
+void ThreadMRI::init(HardwareSerial& serial, IRQn_Type IRQn, uint32_t baudRate, bool breakInSetup)
 {
-    if (g_alreadyInitialized) {
+    if (g_pSerial != NULL) {
         // Only allow 1 ThreadMRI object to be initialized.
-        return false;
+        return;
     }
 
-    // UNDONE: Move into constructor.
+    // Setup the singleton.
+    g_irq = IRQn;
+    g_baudRate = baudRate;
+    g_breakInSetup = breakInSetup;
+
+    // Initialize the MRI core.
     mriInit("");
 
+    // Start the debugger thread.
     static uint64_t             stack[MRI_THREAD_STACK_SIZE];
     static osRtxThread_t        threadTcb;
     static const osThreadAttr_t threadAttr =
@@ -193,10 +204,13 @@ bool ThreadMRI::begin()
     };
     mriThreadId = osThreadNew(mriMain, NULL, &threadAttr);
     if (mriThreadId == NULL) {
-        return false;
+        return;
+    }
+
+    g_pSerial = &serial;
+    if (g_baudRate != 0) {
+        callSerialBeginFromSetup();
     }
-    g_alreadyInitialized = true;
-    return true;
 }
 
 static __NO_RETURN void mriMain(void *pv)
@@ -335,6 +349,37 @@ static void clearDebugActiveFlag()
     mriCortexMState.flags &= ~CORTEXM_FLAGS_ACTIVE_DEBUG;
 }
 
+static void callSerialBeginFromSetup()
+{
+    mriCore_SetTempBreakpoint((uint32_t)setup, justEnteredSetupCallback, NULL);
+}
+
+static int justEnteredSetupCallback(void* pv)
+{
+    g_pSerial->begin(g_baudRate);
+    hookSerialISR();
+
+    // Return 0 to indicate that we want to halt execution at the beginning of setup() or 1 to not force a halt.
+    return g_breakInSetup ? 0 : 1;
+}
+
+static void hookSerialISR()
+{
+    g_origSerialISR = (void(*)(void))NVIC_GetVector(g_irq);
+    NVIC_SetVector(g_irq, (uint32_t)serialISRHook);
+}
+
+
+ThreadMRI::~ThreadMRI() {
+    // IMPORTANT NOTE: You are attempting to destroy the connection to GDB which isn't allowed.
+    //                 Don't allow your ThreadMRI object to go out of scope like this.
+    __debugbreak();
+    for (;;) {
+        // Loop forever.
+    }
+}
+
+
 
 
 // ---------------------------------------------------------------------------------------------------------------------
@@ -351,7 +396,6 @@ void Platform_Init(Token* pParameterTokens)
     g_enableDWTandFPB = 0;
     mriThreadSingleStepThreadId = NULL;
     recordAndSwitchFaultHandlersToDebugger();
-    hookSerialISR();
 }
 
 static void recordAndSwitchFaultHandlersToDebugger()
@@ -368,31 +412,25 @@ static void recordAndSwitchFaultHandlersToDebugger()
     NVIC_SetVector(DebugMonitor_IRQn,     (uint32_t)mriDebugMonitorHandlerStub);
 }
 
-static void hookSerialISR()
-{
-    g_origSerialISR = (void(*)(void))NVIC_GetVector(MRI_SERIAL_IRQ);
-    NVIC_SetVector(MRI_SERIAL_IRQ, (uint32_t)serialISRHook);
-}
-
 
 
 
 uint32_t Platform_CommHasReceiveData(void)
 {
-    return Serial.available();
+    return g_pSerial->available();
 }
 
 int Platform_CommReceiveChar(void)
 {
-    while (!Serial.available()) {
+    while (!g_pSerial->available()) {
         // Busy wait.
     }
-    return Serial.read();
+    return g_pSerial->read();
 }
 
 void Platform_CommSendChar(int character)
 {
-    Serial.write(character);
+    g_pSerial->write(character);
 }
 
 int Platform_CommCausedInterrupt(void)
@@ -632,7 +670,7 @@ static bool isInstruction32Bit(uint16_t firstWordOfInstruction)
 static void serialISRHook()
 {
     g_origSerialISR();
-    if (!isDebuggerActive() && Serial.available() > 0) {
+    if (!isDebuggerActive() && g_pSerial->available() > 0) {
         // Pend a halt into the debug monitor now that there is data from GDB ready to be read by it.
         setControlCFlag();
         setMonitorPending();

libraries/ThreadMRI/src/ThreadMRI.h

@@ -19,9 +19,35 @@
 
 class ThreadMRI {
 public:
-    ThreadMRI();
-
-    bool begin();
+    // You must declare your ThreadMRI object as a global or function scoped static so that it doesn't get
+    // destroyed. Which constructor you use, depends on where you declare it.
+
+    // Use this constructor when declaring ThreadMRI object as a global outside of any functions.
+    // You must specify the baudrate so that ThreadMRI can call begin() on the specified serial object.
+    //  breakInSetup - should it break at beginning of setup().
+    //
+    // Global Example:
+    //      ThreadMRI threadMRI(Serial1, USART1_IRQn, 115200);
+    ThreadMRI(HardwareSerial& serial, IRQn_Type IRQn, uint32_t baudRate, bool breakInSetup=true);
+
+    // Use this constructor when declaring ThreadMRI object as a function scoped static. You must call begin() on
+    // the serial object before constructing the ThreadMRI object.
+    //
+    // Function Scoped Static Example:
+    //      #include <MRI.h>
+    //      void setup() {
+    //          Serial1.begin(115200);
+    //          static ThreadMRI threadMRI(Serial1, USART1_IRQn);
+    //          __debugbreak();
+    //      }
+    ThreadMRI(HardwareSerial& serial, IRQn_Type IRQn);
+
+    // You should never let your ThreadMRI object go out of scope. Make it global or static. To warn you if you do
+    // let it go out of scope by mistake, this destructor will break into GDB and then enter an infinite loop.
+    ~ThreadMRI();
+
+protected:
+    void init(HardwareSerial& serial, IRQn_Type IRQn, uint32_t baudRate, bool breakInSetup);
 };
 
 // Use to insert a hardcoded breakpoint into your code.