Add -exec-abort command (MI); Don't exit on eStateExited

[ki.stfu]

Summary

Add -exec-abort command + test.

Also, I had fixed an error, when lldb-mi exits on eStateExited. With current patch we can re-run target:

-file-exec-and-symbols hello
^done
-exec-run
^running
*stopped,reason="breakpoint-hit"...
-exec-abort
^done
*stopped,reason="exited-normally"...    <- program exits
-exec-run                               <- run again
^running
*stopped,reason="breakpoint-hit"...

All tests pass on OS X.

[clayborg]

Looks good.

[abidh]

Looks ok apart from one small change.

tools/lldb-mi/MICmdCmdExec.h

349

Please remove the name as we discussed in an earlier patch.

[ki.stfu]

In D7794#128149, @abidh wrote:

Looks ok apart from one small change.

Yep. Forgot to upload new patch, sorry. I'll commit it tomorrow.

[ki.stfu]

Remove Gotchas/Authors/Changes sections

test/tools/lldb-mi/control/TestMiExec.py

 """
 Test lldb-mi -exec-xxx commands.
 """
 
 import lldbmi_testcase
 from lldbtest import *
 import unittest2
 
 class MiExecTestCase(lldbmi_testcase.MiTestCaseBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @lldbmi_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
-    @unittest2.skip("-exec-abort isn't implemented")
+    @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_exec_abort(self):
         """Test that 'lldb-mi --interpreter' works for -exec-abort."""
 
         self.spawnLldbMi(args = None)
 
         # Test that -exec-abort fails on invalid process
         self.runCmd("-exec-abort")
         self.expect("\^error,msg=\"Command 'exec-abort'. Invalid process during debug session\"")

tools/lldb-mi/MICmdCmdExec.h

 //              CMICmdCmdExecContinue           interface.
 //              CMICmdCmdExecNext               interface.
 //              CMICmdCmdExecStep               interface.
 //              CMICmdCmdExecNextInstruction    interface.
 //              CMICmdCmdExecStepInstruction    interface.
 //              CMICmdCmdExecFinish             interface.
 //              CMICmdCmdExecInterrupt          interface.
 //              CMICmdCmdExecArguments          interface.
+//              CMICmdCmdExecAbort              interface.
 //
 //              To implement new MI commands derive a new command class from the command base
 //              class. To enable the new command for interpretation add the new command class
 //              to the command factory. The files of relevance are:
 //                  MICmdCommands.cpp
 //                  MICmdBase.h / .cpp
 //                  MICmdCmd.h / .cpp
 //              For an introduction to adding a new command see CMICmdCmdSupportInfoMiCmdQuery
public:
     virtual bool ParseArgs(void);
     // From CMICmnBase
     /* dtor */ virtual ~CMICmdCmdExecArguments(void);
 
     // Attributes:
   private:
     const CMIUtilString m_constStrArgArguments;
 };
+
+//++ ============================================================================
+// Details: MI command class. MI commands derived from the command base class.
+//          *this class implements MI command "exec-abort".
+//--
+class CMICmdCmdExecAbort : public CMICmdBase
+{
+    // Statics:
+  public:
+    // Required by the CMICmdFactory when registering *this command
+    static CMICmdBase *CreateSelf(void);
+
+    // Methods:
+  public:
+    /* ctor */ CMICmdCmdExecAbort(void);
+
+    // Overridden:
+  public:
+    // From CMICmdInvoker::ICmd
+    virtual bool Execute(void);
+    virtual bool Acknowledge(void);
+    // From CMICmnBase
+    /* dtor */ virtual ~CMICmdCmdExecAbort(void);
+};

tools/lldb-mi/MICmdCmdExec.cpp

 //              CMICmdCmdExecContinue           implementation.
 //              CMICmdCmdExecNext               implementation.
 //              CMICmdCmdExecStep               implementation.
 //              CMICmdCmdExecNextInstruction    implementation.
 //              CMICmdCmdExecStepInstruction    implementation.
 //              CMICmdCmdExecFinish             implementation.
 //              CMICmdCmdExecInterrupt          implementation.
 //              CMICmdCmdExecArguments          implementation.
+//              CMICmdCmdExecAbort              implementation.
 //
 // Environment: Compilers:  Visual C++ 12.
 //                          gcc (Ubuntu/Linaro 4.8.1-10ubuntu9) 4.8.1
 //              Libraries:  See MIReadmetxt.
 //
 // Copyright:   None.
 //--
 

 // Return:  CMICmdBase * - Pointer to a new command.
 // Throws:  None.
 //--
 CMICmdBase *
 CMICmdCmdExecArguments::CreateSelf(void)
 {
     return new CMICmdCmdExecArguments();
 }
+
+//---------------------------------------------------------------------------------------
+//---------------------------------------------------------------------------------------
+//---------------------------------------------------------------------------------------
+
+//++ ------------------------------------------------------------------------------------
+// Details: CMICmdCmdExecAbort constructor.
+// Type:    Method.
+// Args:    None.
+// Return:  None.
+// Throws:  None.
+//--
+CMICmdCmdExecAbort::CMICmdCmdExecAbort(void)
+{
+    // Command factory matches this name with that received from the stdin stream
+    m_strMiCmd = "exec-abort";
+
+    // Required by the CMICmdFactory when registering *this command
+    m_pSelfCreatorFn = &CMICmdCmdExecAbort::CreateSelf;
+}
+
+//++ ------------------------------------------------------------------------------------
+// Details: CMICmdCmdExecAbort destructor.
+// Type:    Overrideable.
+// Args:    None.
+// Return:  None.
+// Throws:  None.
+//--
+CMICmdCmdExecAbort::~CMICmdCmdExecAbort(void)
+{
+}
+
+//++ ------------------------------------------------------------------------------------
+// Details: The invoker requires this function. The command does work in this function.
+//          The command is likely to communicate with the LLDB SBDebugger in here.
+// Type:    Overridden.
+// Args:    None.
+// Return:  MIstatus::success - Function succeeded.
+//          MIstatus::failure - Function failed.
+// Throws:  None.
+//--
+bool
+CMICmdCmdExecAbort::Execute(void)
+{
+    CMICmnLLDBDebugSessionInfo &rSessionInfo(CMICmnLLDBDebugSessionInfo::Instance());
+    lldb::SBProcess sbProcess = rSessionInfo.GetProcess();
+    if (!sbProcess.IsValid())
+    {
+        SetError(CMIUtilString::Format(MIRSRC(IDS_CMD_ERR_INVALID_PROCESS), m_cmdData.strMiCmd.c_str()));
+        return MIstatus::failure;
+    }
+
+    lldb::SBError sbError = sbProcess.Destroy();
+    if (sbError.Fail())
+    {
+        SetError(CMIUtilString::Format(MIRSRC(IDS_CMD_ERR_LLDBPROCESS_DESTROY), m_cmdData.strMiCmd.c_str(), sbError.GetCString()));
+        return MIstatus::failure;
+    }
+
+    return MIstatus::success;
+}
+
+//++ ------------------------------------------------------------------------------------
+// Details: The invoker requires this function. The command prepares a MI Record Result
+//          for the work carried out in the Execute().
+// Type:    Overridden.
+// Args:    None.
+// Return:  MIstatus::success - Function succeeded.
+//          MIstatus::failure - Function failed.
+// Throws:  None.
+//--
+bool
+CMICmdCmdExecAbort::Acknowledge(void)
+{
+    const CMICmnMIResultRecord miRecordResult(m_cmdData.strMiCmdToken, CMICmnMIResultRecord::eResultClass_Done);
+    m_miResultRecord = miRecordResult;
+    return MIstatus::success;
+}
+
+//++ ------------------------------------------------------------------------------------
+// Details: Required by the CMICmdFactory when registering *this command. The factory
+//          calls this function to create an instance of *this command.
+// Type:    Static method.
+// Args:    None.
+// Return:  CMICmdBase * - Pointer to a new command.
+// Throws:  None.
+//--
+CMICmdBase *
+CMICmdCmdExecAbort::CreateSelf(void)
+{
+    return new CMICmdCmdExecAbort();
+}

tools/lldb-mi/MICmdCommands.cpp

MICmnCommands::RegisterAll(void)
     bOk &= Register<CMICmdCmdDataEvaluateExpression>();
     bOk &= Register<CMICmdCmdDataReadMemoryBytes>();
     bOk &= Register<CMICmdCmdDataReadMemory>();
     bOk &= Register<CMICmdCmdDataListRegisterNames>();
     bOk &= Register<CMICmdCmdDataListRegisterValues>();
     bOk &= Register<CMICmdCmdDataWriteMemory>();
     bOk &= Register<CMICmdCmdEnablePrettyPrinting>();
     bOk &= Register<CMICmdCmdEnvironmentCd>();
+    bOk &= Register<CMICmdCmdExecAbort>();
     bOk &= Register<CMICmdCmdExecArguments>();
     bOk &= Register<CMICmdCmdExecContinue>();
     bOk &= Register<CMICmdCmdExecInterrupt>();
     bOk &= Register<CMICmdCmdExecFinish>();
     bOk &= Register<CMICmdCmdExecNext>();
     bOk &= Register<CMICmdCmdExecNextInstruction>();
     bOk &= Register<CMICmdCmdExecRun>();
     bOk &= Register<CMICmdCmdExecStep>();

tools/lldb-mi/MICmnLLDBDebugger.cpp

CMICmnLLDBDebugger::MonitorSBListenerEvents(bool &vrbIsAlive)
     }
     if (!event.GetBroadcaster().IsValid())
         return MIstatus::success;
 
     // Debugging
     m_pLog->WriteLog(CMIUtilString::Format("##### An event occurred: %s", event.GetBroadcasterClass()));
 
     bool bHandledEvent = false;
-    bool bExitAppEvent = false;
 
     bool bOk = false;
     {
         // Lock Mutex before handling events so that we don't disturb a running cmd
         CMIUtilThreadLock lock(CMICmnLLDBDebugSessionInfo::Instance().GetSessionMutex());
-        bOk = CMICmnLLDBDebuggerHandleEvents::Instance().HandleEvent(event, bHandledEvent, bExitAppEvent);
+        bOk = CMICmnLLDBDebuggerHandleEvents::Instance().HandleEvent(event, bHandledEvent);
     }
     if (!bHandledEvent)
     {
         const CMIUtilString msg(CMIUtilString::Format(MIRSRC(IDS_LLDBDEBUGGER_WRN_UNKNOWN_EVENT), event.GetBroadcasterClass()));
         m_pLog->WriteLog(msg);
     }
     if (!bOk)
     {
         m_pLog->WriteLog(CMICmnLLDBDebuggerHandleEvents::Instance().GetErrorDescription());
     }
 
-    if (bExitAppEvent)
-    {
-        // Set the application to shutdown
-        m_pClientDriver->SetExitApplicationFlag(true);
-
-        // Kill *this thread
-        vrbIsAlive = false;
-    }
-
     return bOk;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: The main worker method for this thread.
 // Type:    Method.
 // Args:    vrbIsAlive  - (W) True = *this thread is working, false = thread has exited.
 // Return:  MIstatus::success - Functional succeeded.

tools/lldb-mi/MICmnLLDBDebuggerHandleEvents.h

 {
     friend class MI::ISingleton<CMICmnLLDBDebuggerHandleEvents>;
 
     // Methods:
   public:
     bool Initialize(void);
     bool Shutdown(void);
     //
-    bool HandleEvent(const lldb::SBEvent &vEvent, bool &vrbHandledEvent, bool &vrbExitAppEvent);
+    bool HandleEvent(const lldb::SBEvent &vEvent, bool &vrbHandledEvent);
 
     // Methods:
   private:
     /* ctor */ CMICmnLLDBDebuggerHandleEvents(void);
     /* ctor */ CMICmnLLDBDebuggerHandleEvents(const CMICmnLLDBDebuggerHandleEvents &);
     void operator=(const CMICmnLLDBDebuggerHandleEvents &);
     //
     bool ChkForStateChanges(void);
     bool GetProcessStdout(void);
     bool GetProcessStderr(void);
     bool HandleEventSBBreakPoint(const lldb::SBEvent &vEvent);
     bool HandleEventSBBreakpointCmn(const lldb::SBEvent &vEvent);
     bool HandleEventSBBreakpointAdded(const lldb::SBEvent &vEvent);
     bool HandleEventSBBreakpointLocationsAdded(const lldb::SBEvent &vEvent);
-    bool HandleEventSBProcess(const lldb::SBEvent &vEvent, bool &vrbExitAppEvent);
+    bool HandleEventSBProcess(const lldb::SBEvent &vEvent);
     bool HandleEventSBThread(const lldb::SBEvent &vEvent);
     bool HandleEventSBThreadBitStackChanged(const lldb::SBEvent &vEvent);
     bool HandleEventSBThreadSuspended(const lldb::SBEvent &vEvent);
     bool HandleEventSBCommandInterpreter(const lldb::SBEvent &vEvent);
-    bool HandleProcessEventBroadcastBitStateChanged(const lldb::SBEvent &vEvent, bool &vrbExitAppEvent);
+    bool HandleProcessEventBroadcastBitStateChanged(const lldb::SBEvent &vEvent);
     bool HandleProcessEventStateRunning(void);
     bool HandleProcessEventStateExited(void);
     bool HandleProcessEventStateStopped(bool &vwrbShouldBrk);
     bool HandleProcessEventStopReasonTrace(void);
     bool HandleProcessEventStopReasonBreakpoint(void);
     bool HandleProcessEventStopSignal(bool &vwrbShouldBrk);
     bool HandleProcessEventStopException(void);
     bool HandleProcessEventStateSuspended(const lldb::SBEvent &vEvent);

tools/lldb-mi/MICmnLLDBDebuggerHandleEvents.cpp

 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Interpret the event object to asscertain the action to take or information to
 //          to form and put in a MI Out-of-band record object which is given to stdout.
 // Type:    Method.
 // Args:    vEvent          - (R) An LLDB broadcast event.
 //          vrbHandledEvent - (W) True - event handled, false = not handled.
-//          vrbExitAppEvent - (W) True - Received LLDB exit app event, false = did not.
 // Return:  MIstatus::success - Functionality succeeded.
 //          MIstatus::failure - Functionality failed.
 // Throws:  None.
 //--
 bool
-CMICmnLLDBDebuggerHandleEvents::HandleEvent(const lldb::SBEvent &vEvent, bool &vrbHandledEvent, bool &vrbExitAppEvent)
+CMICmnLLDBDebuggerHandleEvents::HandleEvent(const lldb::SBEvent &vEvent, bool &vrbHandledEvent)
 {
     bool bOk = MIstatus::success;
     vrbHandledEvent = false;
-    vrbExitAppEvent = false;
 
     if (lldb::SBProcess::EventIsProcessEvent(vEvent))
     {
         vrbHandledEvent = true;
-        bOk = HandleEventSBProcess(vEvent, vrbExitAppEvent);
+        bOk = HandleEventSBProcess(vEvent);
     }
     else if (lldb::SBBreakpoint::EventIsBreakpointEvent(vEvent))
     {
         vrbHandledEvent = true;
         bOk = HandleEventSBBreakPoint(vEvent);
     }
     else if (lldb::SBThread::EventIsThreadEvent(vEvent))
     {
         vrbHandledEvent = true;
         bOk = HandleEventSBThread(vEvent);
     }
 
     return bOk;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Handle a LLDB SBProcess event.
 // Type:    Method.
 // Args:    vEvent          - (R) An LLDB broadcast event.
-//          vrbExitAppEvent - (W) True - Received LLDB exit app event, false = did not.
 // Return:  MIstatus::success - Functionality succeeded.
 //          MIstatus::failure - Functionality failed.
 // Throws:  None.
 //--
 bool
-CMICmnLLDBDebuggerHandleEvents::HandleEventSBProcess(const lldb::SBEvent &vEvent, bool &vrbExitAppEvent)
+CMICmnLLDBDebuggerHandleEvents::HandleEventSBProcess(const lldb::SBEvent &vEvent)
 {
     bool bOk = MIstatus::success;
 
     const MIchar *pEventType = "";
     const MIuint nEventType = vEvent.GetType();
     switch (nEventType)
     {
         case lldb::SBProcess::eBroadcastBitInterrupt:
             pEventType = "eBroadcastBitInterrupt";
             break;
         case lldb::SBProcess::eBroadcastBitProfileData:
             pEventType = "eBroadcastBitProfileData";
             break;
         case lldb::SBProcess::eBroadcastBitStateChanged:
             pEventType = "eBroadcastBitStateChanged";
-            bOk = HandleProcessEventBroadcastBitStateChanged(vEvent, vrbExitAppEvent);
+            bOk = HandleProcessEventBroadcastBitStateChanged(vEvent);
             break;
         case lldb::SBProcess::eBroadcastBitSTDERR:
             pEventType = "eBroadcastBitSTDERR";
             bOk = GetProcessStderr();
             break;
         case lldb::SBProcess::eBroadcastBitSTDOUT:
             pEventType = "eBroadcastBitSTDOUT";
             bOk = GetProcessStdout();
CMICmnLLDBDebuggerHandleEvents::HandleEventSBCommandInterpreter(const lldb::SBEvent &vEvent)
 
     return MIstatus::success;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Handle SBProcess event eBroadcastBitStateChanged.
 // Type:    Method.
 // Args:    vEvent          - (R) An LLDB event object.
-//          vrbExitAppEvent - (W) True - Received LLDB exit app event, false = did not.
 // Return:  MIstatus::success - Functionality succeeded.
 //          MIstatus::failure - Functionality failed.
 // Throws:  None.
 //--
 bool
-CMICmnLLDBDebuggerHandleEvents::HandleProcessEventBroadcastBitStateChanged(const lldb::SBEvent &vEvent, bool &vrbExitAppEvent)
+CMICmnLLDBDebuggerHandleEvents::HandleProcessEventBroadcastBitStateChanged(const lldb::SBEvent &vEvent)
 {
     bool bOk = ChkForStateChanges();
     bOk = bOk && GetProcessStdout();
     bOk = bOk && GetProcessStderr();
     if (!bOk)
         return MIstatus::failure;
 
     // Something changed in the process; get the event and report the process's current
switch (eEventState)
             break;
         case lldb::eStateStepping:
             pEventType = "eStateStepping";
             break;
         case lldb::eStateDetached:
             pEventType = "eStateDetached";
             break;
         case lldb::eStateExited:
+            // Don't exit from lldb-mi here. We should be able to re-run target.
             pEventType = "eStateExited";
-            vrbExitAppEvent = true;
             bOk = HandleProcessEventStateExited();
             break;
         default:
         {
             const CMIUtilString msg(CMIUtilString::Format(MIRSRC(IDS_LLDBOUTOFBAND_ERR_UNKNOWN_EVENT), "SBProcess BroadcastBitStateChanged",
                                                           (MIuint)eEventState));
             SetErrorDescription(msg);
             return MIstatus::failure;

tools/lldb-mi/MICmnResources.h

enum
 
     IDS_CMD_ERR_N_OPTIONS_REQUIRED,
     IDS_CMD_ERR_OPTION_NOT_FOUND,
     IDS_CMD_ERR_ARGS,
     IDS_CMD_WRN_ARGS_NOT_HANDLED,
     IDS_CMD_ERR_FNFAILED,
     IDS_CMD_ERR_SHARED_DATA_NOT_FOUND,
     IDS_CMD_ERR_LLDBPROCESS_DETACH,
+    IDS_CMD_ERR_LLDBPROCESS_DESTROY,
     IDS_CMD_ERR_SETWKDIR,
     IDS_CMD_ERR_INVALID_TARGET,
     IDS_CMD_ERR_INVALID_TARGET_CURRENT,
     IDS_CMD_ERR_INVALID_TARGET_TYPE,
     IDS_CMD_ERR_INVALID_TARGET_PLUGIN,
     IDS_CMD_ERR_CONNECT_TO_TARGET,
     IDS_CMD_ERR_INVALID_TARGETPLUGINCURRENT,
     IDS_CMD_ERR_NOT_IMPLEMENTED,

tools/lldb-mi/MICmnResources.cpp

const CMICmnResources::SRsrcTextData CMICmnResources::ms_pResourceId2TextData[] = {
     {IDS_WORD_ERR_MSG_NOT_IMPLEMENTED_BRKTS, "<error message not implemented>"},
     {IDS_CMD_ERR_N_OPTIONS_REQUIRED, "Command '%s'. Missing options, %d required"},
     {IDS_CMD_ERR_OPTION_NOT_FOUND, "Command '%s'. Option '%s' not found"},
     {IDS_CMD_ERR_ARGS, "Command '%s'. %s"},
     {IDS_CMD_WRN_ARGS_NOT_HANDLED, "Command '%s'. Warning the following options not handled by the command: %s"},
     {IDS_CMD_ERR_FNFAILED, "Command '%s'. Fn '%s' failed"},
     {IDS_CMD_ERR_SHARED_DATA_NOT_FOUND, "Command '%s'. Shared data '%s' not found"},
     {IDS_CMD_ERR_LLDBPROCESS_DETACH, "Command '%s'. Process detach failed. '%s'"},
+    {IDS_CMD_ERR_LLDBPROCESS_DESTROY, "Command '%s'. Process destroy failed. '%s'"},
     {IDS_CMD_ERR_SETWKDIR, "Command '%s'. Failed to set working directory '%s'"},
     {IDS_CMD_ERR_INVALID_TARGET, "Command '%s'. Target binary '%s' is invalid. %s"},
     {IDS_CMD_ERR_INVALID_TARGET_CURRENT, "Command '%s'. Current SBTarget is invalid"},
     {IDS_CMD_ERR_INVALID_TARGET_TYPE, "Command '%s'. Target type '%s' is not recognised"},
     {IDS_CMD_ERR_INVALID_TARGET_PLUGIN, "Command '%s'. Target plugin is invalid. %s"},
     {IDS_CMD_ERR_CONNECT_TO_TARGET, "Command '%s'. Error connecting to target: '%s'"},
     {IDS_CMD_ERR_INVALID_TARGETPLUGINCURRENT, "Command '%s'. Current target plugin is invalid"},
     {IDS_CMD_ERR_NOT_IMPLEMENTED, "Command '%s'. Command not implemented"},