Add detach and monitor support

The "detach" command allows GDB to detach from a running program linked
with MRI. It causes the debuggee to resume execution and then the user
can exit GDB with the program on the embedded device in a running state
whereas today it would remain halted when GDB disconnects.

Added support for the following "monitor" commands:
* "monitor help" - Lists the currently supported monitor commands to
  the GDB console. Issuing an unknown monitor command will also display
  this help list.
* "monitor showfault" - This command will dump information about the
  current fault to the GDB console just like what happens if already
  connected when the fault occurs. This is useful if you are attaching
  GDB after the fault happens.
* "monitor reset" - After issuing this command in GDB the
  microcontroller will reset on the next "continue" or "detach". This
  doesn't work well when using USBSerial as the debug interface since
  the reset will cause the TTY device being used by GDB to briefly
  disappear during the reset, causing GDB to disconnect. The user
  needs to reissue the appropriate "target remote /dev/tty*" to make
  the connection again.

I needed to implement mriPlatform_CommHasTransmitCompleted() API for
both ThreadDebug and KernelDebug to indicate if the last text
transmitted has been sent. This is needed to make sure that the ack
for the "continue" command is sent back to GDB before the device is
actually reset or GDB gets confused.

Author: adamgreen

libraries/KernelDebug/src/KernelDebug.cpp

@@ -33,6 +33,7 @@ extern "C" {
 
 // Globals that describe the KernelDebug singleton.
 static mbed::UnbufferedSerial*  g_pSerial;
+static uint32_t                 g_baudRate;
 static IRQn_Type                g_irq;
 static bool                     g_breakInSetup;
 
@@ -72,6 +73,7 @@ arduino::KernelDebug::KernelDebug(PinName txPin, PinName rxPin, IRQn_Type irq, u
     if (g_pSerial != NULL) {
         return;
     }
+    g_baudRate = baudRate;
     g_irq = irq;
     g_breakInSetup = breakInSetup;
     g_pSerial = &_serial;
@@ -175,6 +177,21 @@ uint32_t Platform_CommHasReceiveData(void)
     return g_pSerial->readable();
 }
 
+uint32_t Platform_CommHasTransmitCompleted(void)
+{
+    // This function is called by MRI to make sure that last GDB command has been ACKed before it executes a reset
+    // request. We will busy wait in here until that has happened and then always return true.
+    while (!g_pSerial->writable()) {
+        // Wait until transmit data register is empty.
+    }
+
+    // Might still have one byte in output shift register so wait 10 bit times to be safe.
+    uint32_t microsecondsForOneByte = (10  * 1000000) / g_baudRate;
+    delayMicroseconds(microsecondsForOneByte);
+
+    return 1;
+}
+
 int Platform_CommReceiveChar(void)
 {
     while (!Platform_CommHasReceiveData()) {

libraries/MRI/src/architectures/armv7-m/armv7-m.h

@@ -46,7 +46,7 @@
 */
 #define CORTEXM_DEBUGGER_STACK_FILL            0xDEADBEEF
 #if MRI_DEVICE_HAS_FPU
-    #define CORTEXM_DEBUGGER_STACK_SIZE        90
+    #define CORTEXM_DEBUGGER_STACK_SIZE        180
 #else
     #define CORTEXM_DEBUGGER_STACK_SIZE        45
 #endif

libraries/MRI/src/architectures/armv7-m/armv7-m.x

@@ -1182,6 +1182,11 @@ const char* Platform_GetTargetXml(void)
 }
 
 
+void Platform_ResetDevice(void)
+{
+    NVIC_SystemReset();
+}
+
 
 
 #if !MRI_THREAD_MRI

libraries/MRI/src/core/buffer.c

@@ -1,4 +1,4 @@
-/* Copyright 2014 Adam Green (https://github.com/adamgreen/)
+/* Copyright 2020 Adam Green (https://github.com/adamgreen/)
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
@@ -368,17 +368,32 @@ static void advanceToNextChar(Buffer* pBuffer)
 }
 
 
+typedef struct CompareParams
+{
+    int     (*compareFuncPtr)(Buffer* pBuffer, const char* pDesiredString, size_t stringLength);
+    size_t  charLength;
+} CompareParams;
+
+static int matchesString(CompareParams* pParams, Buffer* pBuffer, const char* pString, size_t stringLength);
 static int doesBufferContainThisString(Buffer* pBuffer, const char* pDesiredString, size_t stringLength);
+static int doesBufferContainThisHexString(Buffer* pBuffer, const char* pDesiredString, size_t stringLength);
+static int hexStringCompare(Buffer* pBuffer, const char* pDesiredString, size_t stringLength);
 int Buffer_MatchesString(Buffer* pBuffer, const char* pString, size_t stringLength)
+{
+    CompareParams params = { doesBufferContainThisString, 1 };
+    return matchesString(&params, pBuffer, pString, stringLength);
+}
+
+static int matchesString(CompareParams* pParams, Buffer* pBuffer, const char* pString, size_t stringLength)
 {
     __try
-        throwExceptionIfBufferLeftIsSmallerThan(pBuffer, stringLength);
+        throwExceptionIfBufferLeftIsSmallerThan(pBuffer, stringLength * pParams->charLength);
     __catch
         __rethrow_and_return(0);
 
-    if(doesBufferContainThisString(pBuffer, pString, stringLength))
+    if(pParams->compareFuncPtr(pBuffer, pString, stringLength))
     {
-        pBuffer->pCurrent += stringLength;
+        pBuffer->pCurrent += stringLength * pParams->charLength;
         return 1;
     }
 
@@ -391,5 +406,45 @@ static int doesBufferContainThisString(Buffer* pBuffer, const char* pDesiredStri
 
     return (strncmp(pBufferString, pDesiredString, stringLength) == 0) &&
            (Buffer_BytesLeft(pBuffer) == stringLength ||
-            pBufferString[stringLength] == ':');
+            pBufferString[stringLength] == ':' ||
+            pBufferString[stringLength] == ',');
+}
+
+
+int Buffer_MatchesHexString(Buffer* pBuffer, const char* pString, size_t stringLength)
+{
+    CompareParams params = { doesBufferContainThisHexString, 2 };
+    return matchesString(&params, pBuffer, pString, stringLength);
+}
+
+static int doesBufferContainThisHexString(Buffer* pBuffer, const char* pDesiredString, size_t stringLength)
+{
+    return (hexStringCompare(pBuffer, pDesiredString, stringLength) == 0) &&
+           (Buffer_BytesLeft(pBuffer) == stringLength*2 ||
+            (Buffer_BytesLeft(pBuffer) >= (stringLength+1)*2 &&
+             pBuffer->pCurrent[stringLength*2] == '2' &&
+             pBuffer->pCurrent[stringLength*2+1] == '0'));
+}
+
+static int hexStringCompare(Buffer* pBuffer, const char* pDesiredString, size_t stringLength)
+{
+    char* pOrig = pBuffer->pCurrent;
+    int   result = 0;
+    size_t i;
+    for (i = 0 ; i < stringLength ; i++)
+    {
+        uint8_t byte = Buffer_ReadByteAsHex(pBuffer);
+        if (byte < (uint8_t)pDesiredString[i])
+        {
+            result = -1;
+            break;
+        }
+        if (byte > (uint8_t)pDesiredString[i])
+        {
+            result = 1;
+            break;
+        }
+    }
+    pBuffer->pCurrent = pOrig;
+    return result;
 }

libraries/MRI/src/core/buffer.h

@@ -1,4 +1,4 @@
-/* Copyright 2012 Adam Green (https://github.com/adamgreen/)
+/* Copyright 2020 Adam Green (https://github.com/adamgreen/)
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
@@ -47,6 +47,7 @@ int32_t  mriBuffer_ReadIntegerAsHex(Buffer* pBuffer);
 void     mriBuffer_WriteIntegerAsHex(Buffer* pBuffer, int32_t value);
 int      mriBuffer_IsNextCharEqualTo(Buffer* pBuffer, char thisChar);
 int      mriBuffer_MatchesString(Buffer* pBuffer, const char* pString, size_t stringLength);
+int      mriBuffer_MatchesHexString(Buffer* pBuffer, const char* pString, size_t stringLength);
 
 /* Macroes which allow code to drop the mri namespace prefix. */
 #define Buffer_Init                 mriBuffer_Init
@@ -68,5 +69,6 @@ int      mriBuffer_MatchesString(Buffer* pBuffer, const char* pString, size_t st
 #define Buffer_WriteIntegerAsHex    mriBuffer_WriteIntegerAsHex
 #define Buffer_IsNextCharEqualTo    mriBuffer_IsNextCharEqualTo
 #define Buffer_MatchesString        mriBuffer_MatchesString
+#define Buffer_MatchesHexString     mriBuffer_MatchesHexString
 
 #endif /* BUFFER_H_ */

libraries/MRI/src/core/cmd_common.h

@@ -1,4 +1,4 @@
-/* Copyright 2012 Adam Green (https://github.com/adamgreen/)
+/* Copyright 2020 Adam Green (https://github.com/adamgreen/)
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
@@ -23,9 +23,10 @@
 /* The bits that can be set in the return value from a command handler to indicate if the caller should return
    immediately or send the prepared response back to gdb.  It also indicates whether program execution should be
    resumed for commands like continue and single step. */
-#define HANDLER_RETURN_RESUME_PROGRAM       1
-#define HANDLER_RETURN_RETURN_IMMEDIATELY   2
-#define HANDLER_RETURN_SKIPPED_OVER_BREAK   4
+#define HANDLER_RETURN_RESUME_PROGRAM       (1 << 0)
+#define HANDLER_RETURN_RETURN_IMMEDIATELY   (1 << 1)
+#define HANDLER_RETURN_SKIPPED_OVER_BREAK   (1 << 2)
+#define HANDLER_RETURN_HANDLED              (1 << 31)
 
 typedef struct
 {

libraries/MRI/src/core/cmd_continue.c

@@ -1,4 +1,4 @@
-/* Copyright 2017 Adam Green (https://github.com/adamgreen/)
+/* Copyright 2020 Adam Green (https://github.com/adamgreen/)
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
@@ -109,3 +109,17 @@ uint32_t HandleContinueWithSignalCommand(void)
 
     return (returnValue | HANDLER_RETURN_RESUME_PROGRAM | HANDLER_RETURN_RETURN_IMMEDIATELY);
 }
+
+
+/* Handle the 'D' command which is sent from gdb to resume execution before it detaches and exits.
+
+    Command Format:     D
+    Response Format:    OK
+
+*/
+uint32_t HandleDetachCommand(void)
+{
+    skipHardcodedBreakpoint();
+    PrepareStringResponse("OK");
+    return HANDLER_RETURN_RESUME_PROGRAM;
+}

libraries/MRI/src/core/cmd_continue.h

@@ -1,4 +1,4 @@
-/* Copyright 2017 Adam Green (https://github.com/adamgreen/)
+/* Copyright 2020 Adam Green (https://github.com/adamgreen/)
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
@@ -21,9 +21,11 @@
 /* Real name of functions are in mri namespace. */
 uint32_t mriCmd_HandleContinueCommand(void);
 uint32_t mriCmd_HandleContinueWithSignalCommand(void);
+uint32_t mriCmd_HandleDetachCommand(void);
 
 /* Macroes which allow code to drop the mri namespace prefix. */
 #define HandleContinueCommand           mriCmd_HandleContinueCommand
 #define HandleContinueWithSignalCommand mriCmd_HandleContinueWithSignalCommand
+#define HandleDetachCommand             mriCmd_HandleDetachCommand
 
 #endif /* CMD_CONTINUE_H_ */

libraries/MRI/src/core/cmd_query.c

@@ -1,4 +1,4 @@
-/* Copyright 2014 Adam Green (https://github.com/adamgreen/)
+/* Copyright 2020 Adam Green (https://github.com/adamgreen/)
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
@@ -20,6 +20,7 @@
 #include <core/mri.h>
 #include <core/cmd_common.h>
 #include <core/cmd_query.h>
+#include <core/gdb_console.h>
 
 
 typedef struct
@@ -40,6 +41,10 @@ static void        validateAnnexIsNull(const char* pAnnex);
 static void        handleQueryTransferReadCommand(AnnexOffsetLength* pArguments);
 static uint32_t    handleQueryTransferFeaturesCommand(void);
 static void        validateAnnexIs(const char* pAnnex, const char* pExpected);
+static uint32_t    handleMonitorCommand(void);
+static uint32_t    handleMonitorResetCommand(void);
+static uint32_t    handleMonitorShowFaultCommand(void);
+static uint32_t    handleMonitorHelpCommand(void);
 /* Handle the 'q' command used by gdb to communicate state to debug monitor and vice versa.
 
     Command Format: qSSS
@@ -50,6 +55,7 @@ uint32_t HandleQueryCommand(void)
     Buffer*             pBuffer = GetBuffer();
     static const char   qSupportedCommand[] = "Supported";
     static const char   qXferCommand[] = "Xfer";
+    static const char   qRcmdCommand[] = "Rcmd";
 
     if (Buffer_MatchesString(pBuffer, qSupportedCommand, sizeof(qSupportedCommand)-1))
     {
@@ -59,6 +65,10 @@ uint32_t HandleQueryCommand(void)
     {
         return handleQueryTransferCommand();
     }
+    else if (Buffer_MatchesString(pBuffer, qRcmdCommand, sizeof(qRcmdCommand)-1))
+    {
+        return handleMonitorCommand();
+    }
     else
     {
         PrepareEmptyResponseForUnknownCommand();
@@ -268,3 +278,64 @@ static void validateAnnexIs(const char* pAnnex, const char* pExpected)
     if (pAnnex == NULL || 0 != strcmp(pAnnex, pExpected))
         __throw(invalidArgumentException);
 }
+
+/* Handle the "qRcmd" command used by gdb to send "monitor" commands to the stub.
+
+    Command Format: qRcmd,XXYY...
+    Where XXYY... are the hexadecimal representation of the ASCII command text.
+*/
+static uint32_t handleMonitorCommand(void)
+{
+    Buffer*             pBuffer =GetBuffer();
+    static const char   reset[] = "reset";
+    static const char   showfault[] = "showfault";
+    static const char   help[] = "help";
+
+    if (!Buffer_IsNextCharEqualTo(pBuffer, ','))
+    {
+        PrepareStringResponse(MRI_ERROR_INVALID_ARGUMENT);
+        return 0;
+    }
+
+    if (Buffer_MatchesHexString(pBuffer, reset, sizeof(reset)-1))
+    {
+        return handleMonitorResetCommand();
+    }
+    else if (Buffer_MatchesHexString(pBuffer, showfault, sizeof(showfault)-1))
+    {
+        return handleMonitorShowFaultCommand();
+    }
+    else if (Buffer_MatchesHexString(pBuffer, help, sizeof(help)-1))
+    {
+        return handleMonitorHelpCommand();
+    }
+    else
+    {
+        WriteStringToGdbConsole("Unrecognized monitor command!\r\n");
+        return handleMonitorHelpCommand();
+    }
+}
+
+static uint32_t handleMonitorResetCommand(void)
+{
+    RequestResetOnNextContinue();
+    WriteStringToGdbConsole("Will reset on next continue.\r\n");
+    PrepareStringResponse("OK");
+    return 0;
+}
+
+static uint32_t handleMonitorShowFaultCommand(void)
+{
+    Platform_DisplayFaultCauseToGdbConsole();
+    PrepareStringResponse("OK");
+    return 0;
+}
+
+static uint32_t handleMonitorHelpCommand(void)
+{
+    WriteStringToGdbConsole("Supported monitor commands:\r\n");
+    WriteStringToGdbConsole("reset\r\n");
+    WriteStringToGdbConsole("showfault\r\n");
+    PrepareStringResponse("OK");
+    return 0;
+}

libraries/MRI/src/core/core.h

@@ -35,6 +35,7 @@ int     mriCore_WasSemihostCallCancelledByGdb(void);
 void    mriCore_FlagSemihostCallAsHandled(void);
 int     mriCore_IsFirstException(void);
 int     mriCore_WasSuccessfullyInit(void);
+void    mriCore_RequestResetOnNextContinue(void);
 
 void    mriCore_SetSignalValue(uint8_t signalValue);
 uint8_t mriCore_GetSignalValue(void);
@@ -60,6 +61,7 @@ int     mriCore_SetTempBreakpoint(uint32_t breakpointAddress, TempBreakpointCall
 #define FlagSemihostCallAsHandled       mriCore_FlagSemihostCallAsHandled
 #define IsFirstException                mriCore_IsFirstException
 #define WasSuccessfullyInit             mriCore_WasSuccessfullyInit
+#define RequestResetOnNextContinue      mriCore_RequestResetOnNextContinue
 #define SetSignalValue                  mriCore_SetSignalValue
 #define GetSignalValue                  mriCore_GetSignalValue
 #define SetSemihostReturnValues         mriCore_SetSemihostReturnValues