[lldb-mi] Re-implement a few MI commands.

[apolyakov]

Summary

This patch updates exec-next-instruction, exec-step-instruction, exec-finish, exec-interrupt commands to use SB API instead of HandleCommand.

[apolyakov]

[WIP] Fully test -exec-interrupt command. It needs a program being executed at the moment of debugging to stop it.

[aprantl]

Nice. Since you are adding new lit-based tests for these commands, does that mean that the old python tests become redundant and could we remove them? IIRC the python tests don't set synchronous mode so they are prone to fail under load.

[apolyakov]

You are right about python tests. Let's remove them.

[clayborg]

LGTM. Ok when Adrian is happy with testing changes.

[apolyakov]

Removed duplicated and error prone(without --synchronous option) testing.

[aprantl]

packages/Python/lldbsuite/test/tools/lldb-mi/control/TestMiExec.py

228 ↗

(On Diff #152715)

Is this combination of --exec-next and --frame tested anywhere in the new tests?

[apolyakov]

packages/Python/lldbsuite/test/tools/lldb-mi/control/TestMiExec.py

228 ↗

(On Diff #152715)

No. -exec-... commands don't have the --frame option at all as I know.

[apolyakov]

Update comment. It still needs a review, thanks for your time.

[clayborg]

Just waiting for Adrian to indicate he is happy with testing stuff. LGTM

lldb/trunk/lit/tools/lldb-mi/exec/exec-finish.test

+# XFAIL: windows
+# -> llvm.org/pr24452
+#
+# RUN: %cc -o %t %p/inputs/main.c -g
+# RUN: %lldbmi %t < %s | FileCheck %s
+
+# Test lldb-mi -exec-finish command.
+
+# Check that we have a valid target created via '%lldbmi %t'.
+# CHECK: ^done
+
+-break-insert main
+# CHECK: ^done,bkpt={number="1"
+
+-break-insert dummyFunction
+# CHECK: ^done,bkpt={number="2"
+
+-exec-run
+# CHECK: ^running
+# CHECK: *stopped,reason="breakpoint-hit"
+
+-exec-finish --thread 0
+# Check that exec-finish can process the case of invalid thread ID.
+# CHECK: ^error,msg="Command 'exec-finish'. Thread ID invalid"
+
+-exec-finish --thread 1
+# CHECK: ^running
+# CHECK: *stopped,reason="breakpoint-hit"
+
+-exec-finish
+# Check exec-finish in a selected thread.
+# CHECK: ^running
+# CHECK: *stopped,reason="end-stepping-range"

lldb/trunk/lit/tools/lldb-mi/exec/exec-interrupt.test

+# XFAIL: windows
+# -> llvm.org/pr24452
+#
+# RUN: %cc -o %t %p/inputs/main.c -g
+# RUN: %lldbmi %t < %s | FileCheck %s
+
+# Test lldb-mi -exec-interrupt command.
+
+# Check that we have a valid target created via '%lldbmi %t'.
+# CHECK: ^done
+
+-break-insert main
+# CHECK: ^done,bkpt={number="1"
+
+-exec-run
+# CHECK: ^running
+# CHECK: *stopped,reason="breakpoint-hit"
+
+-exec-interrupt
+# CHECK: ^error,msg="Process is not running."

lldb/trunk/lit/tools/lldb-mi/exec/exec-next-instruction.test

+# XFAIL: windows
+# -> llvm.org/pr24452
+#
+# RUN: %cc -o %t %p/inputs/main.c -g
+# RUN: %lldbmi %t < %s | FileCheck %s
+
+# Test lldb-mi -exec-next-instruction command.
+
+# Check that we have a valid target created via '%lldbmi %t'.
+# CHECK: ^done
+
+-break-insert main
+# CHECK: ^done,bkpt={number="1"
+
+-exec-run
+# CHECK: ^running
+# CHECK: *stopped,reason="breakpoint-hit"
+
+-exec-next-instruction --thread 0
+# Check that exec-next-instruction can process the case of invalid thread ID.
+# CHECK: ^error,msg="Command 'exec-next-instruction'. Thread ID invalid"
+
+-exec-next-instruction --thread 1
+# CHECK: ^running
+# CHECK: *stopped,reason="end-stepping-range"
+
+-exec-next-instruction
+# Check exec-next-instruction in a selected thread.
+# CHECK: ^running
+# CHECK: *stopped,reason="end-stepping-range"

lldb/trunk/lit/tools/lldb-mi/exec/exec-step-instruction.test

+# XFAIL: windows
+# -> llvm.org/pr24452
+#
+# RUN: %cc -o %t %p/inputs/main.c -g
+# RUN: %lldbmi %t < %s | FileCheck %s
+
+# Test lldb-mi -exec-step-instruction command.
+
+# Check that we have a valid target created via '%lldbmi %t'.
+# CHECK: ^done
+
+-break-insert main
+# CHECK: ^done,bkpt={number="1"
+
+-exec-run
+# CHECK: ^running
+# CHECK: *stopped,reason="breakpoint-hit"
+
+-exec-step-instruction --thread 0
+# Check that exec-step-instruction can process the case of invalid thread ID.
+# CHECK: ^error,msg="Command 'exec-step-instruction'. Thread ID invalid"
+
+-exec-next-instruction --thread 1
+# CHECK: ^running
+# CHECK: *stopped,reason="end-stepping-range"
+
+-exec-step-instruction
+# Check exec-step-instruction in a selected thread.
+# CHECK: ^running
+# CHECK: *stopped,reason="end-stepping-range"

lldb/trunk/lit/tools/lldb-mi/exec/inputs/main.c

+void dummyFunction() {
+  int a = 0;
+}
+
 int main(void) {
   int x = 0;
+  dummyFunction();
   return x;
 }

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-mi/control/TestMiExec.py

def test_lldbmi_exec_arguments_reset(self):
         self.expect("\^done,bkpt={number=\"1\"")
         self.runCmd("-exec-run")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"breakpoint-hit\"")
 
         # Check argc to see if arg passed
         self.runCmd("-data-evaluate-expression argc")
         self.expect("\^done,value=\"1\"")
-
-    @skipIfRemote   # We do not currently support remote debugging via the MI.
-    @skipIfWindows  # llvm.org/pr24452: Get lldb-mi tests working on Windows
-    @skipIfFreeBSD  # llvm.org/pr22411: Failure presumably due to known thread races
-    def test_lldbmi_exec_next(self):
-        """Test that 'lldb-mi --interpreter' works for stepping."""
-
-        self.spawnLldbMi(args=None)
-
-        # Load executable
-        self.runCmd("-file-exec-and-symbols %s" % self.myexe)
-        self.expect("\^done")
-
-        # Run to main
-        self.runCmd("-break-insert -f main")
-        self.expect("\^done,bkpt={number=\"1\"")
-        self.runCmd("-exec-run")
-        self.expect("\^running")
-        self.expect("\*stopped,reason=\"breakpoint-hit\"")
-
-        # Warning: the following is sensitive to the lines in the source
-
-        # Test -exec-next
-        self.runCmd("-exec-next --thread 1 --frame 0")
-        self.expect("\^running")
-        self.expect(
-            "\*stopped,reason=\"end-stepping-range\".+?main\.cpp\",line=\"29\"")
-
-        # Test that --thread is optional
-        self.runCmd("-exec-next --frame 0")
-        self.expect("\^running")
-        self.expect(
-            "\*stopped,reason=\"end-stepping-range\".+?main\.cpp\",line=\"30\"")
-
-        # Test that --frame is optional
-        self.runCmd("-exec-next --thread 1")
-        self.expect("\^running")
-        self.expect(
-            "\*stopped,reason=\"end-stepping-range\".+?main\.cpp\",line=\"31\"")
-
-        # Test that both --thread and --frame are optional
-        self.runCmd("-exec-next")
-        self.expect("\^running")
-        self.expect(
-            "\*stopped,reason=\"end-stepping-range\".+?main\.cpp\",line=\"32\"")
-
-        # Test that an invalid --thread is handled
-        self.runCmd("-exec-next --thread 0")
-        self.expect("\^error,msg=\"Command 'exec-next'. Thread ID invalid")
-        self.runCmd("-exec-next --thread 10")
-        self.expect("\^error,msg=\"Command 'exec-next'. Thread ID invalid")
-
-        # Test that an invalid --frame is handled
-        # FIXME: no error is returned
-        self.runCmd("-exec-next --frame 10")
-        #self.expect("\^error: Frame index 10 is out of range")
-
-    @skipIfRemote   # We do not currently support remote debugging via the MI.
-    @skipIfWindows  # llvm.org/pr24452: Get lldb-mi tests working on Windows
-    @skipIfFreeBSD  # llvm.org/pr22411: Failure presumably due to known thread races
-    def test_lldbmi_exec_next_instruction(self):
-        """Test that 'lldb-mi --interpreter' works for instruction stepping."""
-
-        self.spawnLldbMi(args=None)
-
-        # Load executable
-        self.runCmd("-file-exec-and-symbols %s" % self.myexe)
-        self.expect("\^done")
-
-        # Run to main
-        self.runCmd("-break-insert -f main")
-        self.expect("\^done,bkpt={number=\"1\"")
-        self.runCmd("-exec-run")
-        self.expect("\^running")
-        self.expect("\*stopped,reason=\"breakpoint-hit\"")
-
-        # Warning: the following is sensitive to the lines in the
-        # source and optimizations
-
-        # Test -exec-next-instruction
-        self.runCmd("-exec-next-instruction --thread 1 --frame 0")
-        self.expect("\^running")
-        self.expect(
-            "\*stopped,reason=\"end-stepping-range\".+?main\.cpp\",line=\"28\"")
-
-        # Test that --thread is optional
-        self.runCmd("-exec-next-instruction --frame 0")
-        self.expect("\^running")
-        # Depending on compiler, it can stop at different line
-        self.expect(
-            "\*stopped,reason=\"end-stepping-range\".+?main\.cpp\",line=\"(28|29)\"")
-
-        # Test that --frame is optional
-        self.runCmd("-exec-next-instruction --thread 1")
-        self.expect("\^running")
-        # Depending on compiler, it can stop at different line
-        self.expect(
-            "\*stopped,reason=\"end-stepping-range\".+?main\.cpp\",line=\"(28|29|30)\"")
-
-        # Test that both --thread and --frame are optional
-        self.runCmd("-exec-next-instruction")
-        self.expect("\^running")
-        # Depending on compiler, it can stop at different line
-        self.expect(
-            "\*stopped,reason=\"end-stepping-range\".+?main\.cpp\",line=\"(28|29|30|31)\"")
-
-        # Test that an invalid --thread is handled
-        self.runCmd("-exec-next-instruction --thread 0")
-        self.expect("\^error,message=\"error: Thread index 0 is out of range")
-        self.runCmd("-exec-next-instruction --thread 10")
-        self.expect("\^error,message=\"error: Thread index 10 is out of range")
-
-        # Test that an invalid --frame is handled
-        # FIXME: no error is returned
-        self.runCmd("-exec-next-instruction --frame 10")
-        #self.expect("\^error: Frame index 10 is out of range")
-
-    @skipIfRemote   # We do not currently support remote debugging via the MI.
-    @skipIfWindows  # llvm.org/pr24452: Get lldb-mi tests working on Windows
-    @skipIfFreeBSD  # llvm.org/pr22411: Failure presumably due to known thread races
-    def test_lldbmi_exec_step(self):
-        """Test that 'lldb-mi --interpreter' works for stepping into."""
-
-        self.spawnLldbMi(args=None)
-
-        # Load executable
-        self.runCmd("-file-exec-and-symbols %s" % self.myexe)
-        self.expect("\^done")
-
-        # Run to main
-        self.runCmd("-break-insert -f main")
-        self.expect("\^done,bkpt={number=\"1\"")
-        self.runCmd("-exec-run")
-        self.expect("\^running")
-        self.expect("\*stopped,reason=\"breakpoint-hit\"")
-
-        # Warning: the following is sensitive to the lines in the source
-
-        # Test that -exec-step steps into (or not) printf depending on debug info
-        # Note that message is different in Darwin and Linux:
-        # Darwin: "*stopped,reason=\"end-stepping-range\",frame={addr=\"0x[0-9a-f]+\",func=\"main\",args=[{name=\"argc\",value=\"1\"},{name=\"argv\",value="0x[0-9a-f]+\"}],file=\"main.cpp\",fullname=\".+main.cpp\",line=\"\d\"},thread-id=\"1\",stopped-threads=\"all\"
-        # Linux:
-        # "*stopped,reason=\"end-stepping-range\",frame={addr="0x[0-9a-f]+\",func=\"__printf\",args=[{name=\"format\",value=\"0x[0-9a-f]+\"}],file=\"printf.c\",fullname=\".+printf.c\",line="\d+"},thread-id=\"1\",stopped-threads=\"all\"
-        self.runCmd("-exec-step --thread 1 --frame 0")
-        self.expect("\^running")
-        it = self.expect(["\*stopped,reason=\"end-stepping-range\".+?func=\"main\"",
-                          "\*stopped,reason=\"end-stepping-range\".+?func=\"(?!main).+?\""])
-        # Exit from printf if needed
-        if it == 1:
-            self.runCmd("-exec-finish")
-            self.expect("\^running")
-            self.expect(
-                "\*stopped,reason=\"end-stepping-range\".+?func=\"main\"")
-
-        # Test that -exec-step steps into g_MyFunction and back out
-        # (and that --thread is optional)
-        self.runCmd("-exec-step --frame 0")
-        self.expect("\^running")
-        self.expect(
-            "\*stopped,reason=\"end-stepping-range\".+?func=\"g_MyFunction.*?\"")
-        # Use -exec-finish here to make sure that control reaches the caller.
-        # -exec-step can keep us in the g_MyFunction for gcc
-        self.runCmd("-exec-finish --frame 0")
-        self.expect("\^running")
-        it = self.expect(["\*stopped,reason=\"end-stepping-range\".+?main\.cpp\",line=\"30\"",
-                         "\*stopped,reason=\"end-stepping-range\".+?main\.cpp\",line=\"29\""])
-
-        if it == 1:
-            # Call to s_MyFunction may not follow immediately after g_MyFunction.
-            # There might be some instructions in between to restore caller-saved registers.
-            # We need to get past these instructions with a next to reach call to s_MyFunction.
-            self.runCmd("-exec-next --thread 1")
-            self.expect("\^running")
-            self.expect("\*stopped,reason=\"end-stepping-range\".+?main\.cpp\",line=\"30\"")
-
-        # Test that -exec-step steps into s_MyFunction
-        # (and that --frame is optional)
-        self.runCmd("-exec-step --thread 1")
-        self.expect("\^running")
-        self.expect(
-            "\*stopped,reason=\"end-stepping-range\".+?func=\".*?s_MyFunction.*?\"")
-
-        # Test that -exec-step steps into g_MyFunction from inside
-        # s_MyFunction (and that both --thread and --frame are optional)
-        self.runCmd("-exec-step")
-        self.expect("\^running")
-        self.expect(
-            "\*stopped,reason=\"end-stepping-range\".+?func=\"g_MyFunction.*?\"")
-
-        # Test that an invalid --thread is handled
-        self.runCmd("-exec-step --thread 0")
-        self.expect("\^error,msg=\"Command 'exec-step'. Thread ID invalid")
-        self.runCmd("-exec-step --thread 10")
-        self.expect("\^error,msg=\"Command 'exec-step'. Thread ID invalid")
-
-        # Test that an invalid --frame is handled
-        # FIXME: no error is returned
-        self.runCmd("-exec-step --frame 10")
-        #self.expect("\^error: Frame index 10 is out of range")
-
-    @skipIfRemote   # We do not currently support remote debugging via the MI.
-    @skipIfWindows  # llvm.org/pr24452: Get lldb-mi tests working on Windows
-    @skipIfFreeBSD  # llvm.org/pr22411: Failure presumably due to known thread races
-    def test_lldbmi_exec_step_instruction(self):
-        """Test that 'lldb-mi --interpreter' works for instruction stepping into."""
-
-        self.spawnLldbMi(args=None)
-
-        # Load executable
-        self.runCmd("-file-exec-and-symbols %s" % self.myexe)
-        self.expect("\^done")
-
-        # Warning: the following is sensitive to the lines in the
-        # source and optimizations
-
-        # Run to main
-        self.runCmd("-break-insert -f main")
-        self.expect("\^done,bkpt={number=\"1\"")
-        self.runCmd("-exec-run")
-        self.expect("\^running")
-        self.expect("\*stopped,reason=\"breakpoint-hit\"")
-
-        # Test that -exec-next steps over printf
-        self.runCmd("-exec-next --thread 1 --frame 0")
-        self.expect("\^running")
-        self.expect(
-            "\*stopped,reason=\"end-stepping-range\".+?main\.cpp\",line=\"29\"")
-
-        # Test that -exec-step-instruction steps over non branching
-        # instruction
-        self.runCmd("-exec-step-instruction --thread 1 --frame 0")
-        self.expect("\^running")
-        self.expect("\*stopped,reason=\"end-stepping-range\".+?main\.cpp\"")
-
-        # Test that -exec-step-instruction steps into g_MyFunction
-        # instruction (and that --thread is optional)
-
-        # In case of MIPS, there might be more than one instruction
-        # before actual call instruction (like load, move and call instructions).
-        # The -exec-step-instruction would step one assembly instruction.
-        # Thus we may not enter into g_MyFunction function. The -exec-step would definitely
-        # step into the function.
-
-        if self.isMIPS():
-            self.runCmd("-exec-step --frame 0")
-        else:
-            self.runCmd("-exec-step-instruction --frame 0")
-        self.expect("\^running")
-        self.expect(
-            "\*stopped,reason=\"end-stepping-range\".+?func=\"g_MyFunction.*?\"")
-
-        # Test that -exec-step-instruction steps over non branching
-        # (and that --frame is optional)
-        self.runCmd("-exec-step-instruction --thread 1")
-        self.expect("\^running")
-        self.expect(
-            "\*stopped,reason=\"end-stepping-range\".+?func=\"g_MyFunction.*?\"")
-
-        # Test that -exec-step-instruction steps into g_MyFunction
-        # (and that both --thread and --frame are optional)
-        self.runCmd("-exec-step-instruction")
-        self.expect("\^running")
-        self.expect(
-            "\*stopped,reason=\"end-stepping-range\".+?func=\"g_MyFunction.*?\"")
-
-        # Test that an invalid --thread is handled
-        self.runCmd("-exec-step-instruction --thread 0")
-        self.expect("\^error,message=\"error: Thread index 0 is out of range")
-        self.runCmd("-exec-step-instruction --thread 10")
-        self.expect("\^error,message=\"error: Thread index 10 is out of range")
-
-        # Test that an invalid --frame is handled
-        # FIXME: no error is returned
-        self.runCmd("-exec-step-instruction --frame 10")
-        #self.expect("\^error: Frame index 10 is out of range")
-
-    @skipIfRemote   # We do not currently support remote debugging via the MI.
-    @skipIfWindows  # llvm.org/pr24452: Get lldb-mi tests working on Windows
-    @skipIfFreeBSD  # llvm.org/pr22411: Failure presumably due to known thread races
-    def test_lldbmi_exec_finish(self):
-        """Test that 'lldb-mi --interpreter' works for -exec-finish."""
-
-        self.spawnLldbMi(args=None)
-
-        # Load executable
-        self.runCmd("-file-exec-and-symbols %s" % self.myexe)
-        self.expect("\^done")
-
-        # Set BP at g_MyFunction and run to BP
-        self.runCmd("-break-insert -f g_MyFunction")
-        self.expect("\^done,bkpt={number=\"1\"")
-        self.runCmd("-exec-run")
-        self.expect("\^running")
-        self.expect("\*stopped,reason=\"breakpoint-hit\"")
-
-        # Test that -exec-finish returns from g_MyFunction
-        self.runCmd("-exec-finish --thread 1 --frame 0")
-        self.expect("\^running")
-        self.expect("\*stopped,reason=\"end-stepping-range\".+?func=\"main\"")
-
-        # Run to BP inside s_MyFunction call
-        self.runCmd("-break-insert s_MyFunction")
-        self.expect("\^done,bkpt={number=\"2\"")
-        self.runCmd("-exec-continue")
-        self.expect("\^running")
-        self.expect("\*stopped,reason=\"breakpoint-hit\"")
-
-        # Test that -exec-finish hits BP at g_MyFunction call inside
-        # s_MyFunction (and that --thread is optional)
-        self.runCmd("-exec-finish --frame 0")
-        self.expect("\^running")
-        self.expect("\*stopped,reason=\"breakpoint-hit\"")
-
-        # Test that -exec-finish returns from g_MyFunction call inside
-        # s_MyFunction (and that --frame is optional)
-        self.runCmd("-exec-finish --thread 1")
-        self.expect("\^running")
-        self.expect(
-            "\*stopped,reason=\"end-stepping-range\".+?func=\".*?s_MyFunction.*?\"")
-
-        # Test that -exec-finish returns from s_MyFunction
-        # (and that both --thread and --frame are optional)
-        self.runCmd("-exec-finish")
-        self.expect("\^running")
-        self.expect("\*stopped,reason=\"end-stepping-range\".+?func=\"main\"")
-
-        # Test that an invalid --thread is handled
-        self.runCmd("-exec-finish --thread 0")
-        self.expect("\^error,message=\"error: Thread index 0 is out of range")
-        self.runCmd("-exec-finish --thread 10")
-        self.expect("\^error,message=\"error: Thread index 10 is out of range")
-
-        # Test that an invalid --frame is handled
-        # FIXME: no error is returned
-        #self.runCmd("-exec-finish --frame 10")
-        #self.expect("\^error: Frame index 10 is out of range")
-
-        # Set BP at printf and run to BP
-        self.runCmd("-break-insert -f printf")
-        self.expect("\^done,bkpt={number=\"3\"")
-        self.runCmd("-exec-continue")
-        self.expect("\^running")
-        self.expect("\*stopped,reason=\"breakpoint-hit\"")
-
-        # Test that -exec-finish returns from printf
-        self.runCmd("-exec-finish --thread 1 --frame 0")
-        self.expect("\^running")
-        self.expect("\*stopped,reason=\"end-stepping-range\".+?func=\"main\"")

lldb/trunk/tools/lldb-mi/MICmdCmdExec.h

 //                  MICmdCmd.h / .cpp
 //              For an introduction to adding a new command see
 //              CMICmdCmdSupportInfoMiCmdQuery
 //              command class as an example.
 
 #pragma once
 
 // Third party headers:
-#include "lldb/API/SBCommandReturnObject.h"
-
 // In-house headers:
 #include "MICmdBase.h"
 
 //++
 //============================================================================
 // Details: MI command class. MI commands derived from the command base class.
 //          *this class implements MI command "exec-run".
 //--
public:
 
   // Overridden:
 public:
   // From CMICmdInvoker::ICmd
   bool Execute() override;
   bool Acknowledge() override;
   // From CMICmnBase
   /* dtor */ ~CMICmdCmdExecContinue() override;
-  // Attributes:
 };
 
 //++
 //============================================================================
 // Details: MI command class. MI commands derived from the command base class.
 //          *this class implements MI command "exec-next".
 //--
 class CMICmdCmdExecNext : public CMICmdBase {
public:
   bool Execute() override;
   bool Acknowledge() override;
   bool ParseArgs() override;
   // From CMICmnBase
   /* dtor */ ~CMICmdCmdExecNextInstruction() override;
 
   // Attributes:
 private:
-  lldb::SBCommandReturnObject m_lldbResult;
   const CMIUtilString m_constStrArgNumber; // Not specified in MI spec but
                                            // Eclipse gives this option
 };
 
 //++
 //============================================================================
 // Details: MI command class. MI commands derived from the command base class.
 //          *this class implements MI command "exec-step-instruction".
public:
   bool Execute() override;
   bool Acknowledge() override;
   bool ParseArgs() override;
   // From CMICmnBase
   /* dtor */ ~CMICmdCmdExecStepInstruction() override;
 
   // Attributes:
 private:
-  lldb::SBCommandReturnObject m_lldbResult;
   const CMIUtilString m_constStrArgNumber; // Not specified in MI spec but
                                            // Eclipse gives this option
 };
 
 //++
 //============================================================================
 // Details: MI command class. MI commands derived from the command base class.
 //          *this class implements MI command "exec-finish".
public:
   // Overridden:
 public:
   // From CMICmdInvoker::ICmd
   bool Execute() override;
   bool Acknowledge() override;
   bool ParseArgs() override;
   // From CMICmnBase
   /* dtor */ ~CMICmdCmdExecFinish() override;
-
-  // Attributes:
-private:
-  lldb::SBCommandReturnObject m_lldbResult;
 };
 
 // CODETAG_DEBUG_SESSION_RUNNING_PROG_RECEIVED_SIGINT_PAUSE_PROGRAM
 //++
 //============================================================================
 // Details: MI command class. MI commands derived from the command base class.
 //          *this class implements MI command "exec-interrupt".
 // Gotchas: Using Eclipse this command is injected into the command system when
public:
 
   // Overridden:
 public:
   // From CMICmdInvoker::ICmd
   bool Execute() override;
   bool Acknowledge() override;
   // From CMICmnBase
   /* dtor */ ~CMICmdCmdExecInterrupt() override;
-
-  // Attributes:
-private:
-  lldb::SBCommandReturnObject m_lldbResult;
 };
 
 //++
 //============================================================================
 // Details: MI command class. MI commands derived from the command base class.
 //          *this class implements MI command "exec-arguments".
 //--
 class CMICmdCmdExecArguments : public CMICmdBase {

lldb/trunk/tools/lldb-mi/MICmdCmdExec.cpp

if (pArgThread->GetFound() &&
     SetError(CMIUtilString::Format(MIRSRC(IDS_CMD_ERR_OPTION_NOT_FOUND),
                                    m_cmdData.strMiCmd.c_str(),
                                    m_constStrArgThread.c_str()));
     return MIstatus::failure;
   }
 
   CMICmnLLDBDebugSessionInfo &rSessionInfo(
       CMICmnLLDBDebugSessionInfo::Instance());
-  lldb::SBDebugger &rDebugger = rSessionInfo.GetDebugger();
-  CMIUtilString strCmd("thread step-inst-over");
-  if (nThreadId != UINT64_MAX)
-    strCmd += CMIUtilString::Format(" %llu", nThreadId);
-  rDebugger.GetCommandInterpreter().HandleCommand(strCmd.c_str(), m_lldbResult,
-                                                  false);
 
-  return MIstatus::success;
+  lldb::SBError error;
+  if (nThreadId != UINT64_MAX) {
+    lldb::SBThread sbThread =
+        rSessionInfo.GetProcess().GetThreadByIndexID(nThreadId);
+    if (!sbThread.IsValid()) {
+      SetError(CMIUtilString::Format(MIRSRC(IDS_CMD_ERR_THREAD_INVALID),
+                                     m_cmdData.strMiCmd.c_str(),
+                                     m_constStrArgThread.c_str()));
+      return MIstatus::failure;
+    }
+    sbThread.StepInstruction(true, error);
+  } else
+    rSessionInfo.GetProcess().GetSelectedThread().StepInstruction(
+        true, error);
+
+  return HandleSBError(error);
 }
 
 //++
 //------------------------------------------------------------------------------------
 // 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 - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool CMICmdCmdExecNextInstruction::Acknowledge() {
-  if (m_lldbResult.GetErrorSize() > 0) {
-    const char *pLldbErr = m_lldbResult.GetError();
-    MIunused(pLldbErr);
-    const CMICmnMIValueConst miValueConst(m_lldbResult.GetError());
-    const CMICmnMIValueResult miValueResult("message", miValueConst);
-    const CMICmnMIResultRecord miRecordResult(
-        m_cmdData.strMiCmdToken, CMICmnMIResultRecord::eResultClass_Error,
-        miValueResult);
-    m_miResultRecord = miRecordResult;
-  } else {
-    const CMICmnMIResultRecord miRecordResult(
-        m_cmdData.strMiCmdToken, CMICmnMIResultRecord::eResultClass_Running);
-    m_miResultRecord = miRecordResult;
-  }
-
+  m_miResultRecord = CMICmnMIResultRecord(
   return MIstatus::success;
 }
 
 //++
 //------------------------------------------------------------------------------------
 // Details: Required by the CMICmdFactory when registering *this command. The
 // factory
 //          calls this function to create an instance of *this command.
if (pArgThread->GetFound() &&
     SetError(CMIUtilString::Format(MIRSRC(IDS_CMD_ERR_OPTION_NOT_FOUND),
                                    m_cmdData.strMiCmd.c_str(),
                                    m_constStrArgThread.c_str()));
     return MIstatus::failure;
   }
 
   CMICmnLLDBDebugSessionInfo &rSessionInfo(
       CMICmnLLDBDebugSessionInfo::Instance());
-  lldb::SBDebugger &rDebugger = rSessionInfo.GetDebugger();
-  CMIUtilString strCmd("thread step-inst");
-  if (nThreadId != UINT64_MAX)
-    strCmd += CMIUtilString::Format(" %llu", nThreadId);
-  rDebugger.GetCommandInterpreter().HandleCommand(strCmd.c_str(), m_lldbResult,
-                                                  false);
 
-  return MIstatus::success;
+  lldb::SBError error;
+  if (nThreadId != UINT64_MAX) {
+    lldb::SBThread sbThread =
+        rSessionInfo.GetProcess().GetThreadByIndexID(nThreadId);
+    if (!sbThread.IsValid()) {
+      SetError(CMIUtilString::Format(MIRSRC(IDS_CMD_ERR_THREAD_INVALID),
+                                     m_cmdData.strMiCmd.c_str(),
+                                     m_constStrArgThread.c_str()));
+      return MIstatus::failure;
+    }
+    sbThread.StepInstruction(false, error);
+  } else
+    rSessionInfo.GetProcess().GetSelectedThread().StepInstruction(
+        false, error);
+
+  return HandleSBError(error);
 }
 
 //++
 //------------------------------------------------------------------------------------
 // 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 - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool CMICmdCmdExecStepInstruction::Acknowledge() {
-  if (m_lldbResult.GetErrorSize() > 0) {
-    const char *pLldbErr = m_lldbResult.GetError();
-    MIunused(pLldbErr);
-    const CMICmnMIValueConst miValueConst(m_lldbResult.GetError());
-    const CMICmnMIValueResult miValueResult("message", miValueConst);
-    const CMICmnMIResultRecord miRecordResult(
-        m_cmdData.strMiCmdToken, CMICmnMIResultRecord::eResultClass_Error,
-        miValueResult);
-    m_miResultRecord = miRecordResult;
-  } else {
-    const CMICmnMIResultRecord miRecordResult(
-        m_cmdData.strMiCmdToken, CMICmnMIResultRecord::eResultClass_Running);
-    m_miResultRecord = miRecordResult;
-  }
-
+  m_miResultRecord = CMICmnMIResultRecord(
   return MIstatus::success;
 }
 
 //++
 //------------------------------------------------------------------------------------
 // Details: Required by the CMICmdFactory when registering *this command. The
 // factory
 //          calls this function to create an instance of *this command.
if (pArgThread->GetFound() &&
     SetError(CMIUtilString::Format(MIRSRC(IDS_CMD_ERR_OPTION_NOT_FOUND),
                                    m_cmdData.strMiCmd.c_str(),
                                    m_constStrArgThread.c_str()));
     return MIstatus::failure;
   }
 
   CMICmnLLDBDebugSessionInfo &rSessionInfo(
       CMICmnLLDBDebugSessionInfo::Instance());
-  lldb::SBDebugger &rDebugger = rSessionInfo.GetDebugger();
-  CMIUtilString strCmd("thread step-out");
-  if (nThreadId != UINT64_MAX)
-    strCmd += CMIUtilString::Format(" %llu", nThreadId);
-  rDebugger.GetCommandInterpreter().HandleCommand(strCmd.c_str(), m_lldbResult,
-                                                  false);
 
-  return MIstatus::success;
+  lldb::SBError error;
+  if (nThreadId != UINT64_MAX) {
+    lldb::SBThread sbThread =
+        rSessionInfo.GetProcess().GetThreadByIndexID(nThreadId);
+    if (!sbThread.IsValid()) {
+      SetError(CMIUtilString::Format(MIRSRC(IDS_CMD_ERR_THREAD_INVALID),
+                                     m_cmdData.strMiCmd.c_str(),
+                                     m_constStrArgThread.c_str()));
+      return MIstatus::failure;
+    }
+    sbThread.StepOut(error);
+  } else
+    rSessionInfo.GetProcess().GetSelectedThread().StepOut(error);
+
+  return HandleSBError(error);
 }
 
 //++
 //------------------------------------------------------------------------------------
 // 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 - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool CMICmdCmdExecFinish::Acknowledge() {
-  if (m_lldbResult.GetErrorSize() > 0) {
-    const char *pLldbErr = m_lldbResult.GetError();
-    MIunused(pLldbErr);
-    const CMICmnMIValueConst miValueConst(m_lldbResult.GetError());
-    const CMICmnMIValueResult miValueResult("message", miValueConst);
-    const CMICmnMIResultRecord miRecordResult(
-        m_cmdData.strMiCmdToken, CMICmnMIResultRecord::eResultClass_Error,
-        miValueResult);
-    m_miResultRecord = miRecordResult;
-  } else {
-    const CMICmnMIResultRecord miRecordResult(
-        m_cmdData.strMiCmdToken, CMICmnMIResultRecord::eResultClass_Running);
-    m_miResultRecord = miRecordResult;
-  }
-
+  m_miResultRecord = CMICmnMIResultRecord(
   return MIstatus::success;
 }
 
 //++
 //------------------------------------------------------------------------------------
 // Details: Required by the CMICmdFactory when registering *this command. The
 // factory
 //          calls this function to create an instance of *this command.

 //          here.
 // Type:    Overridden.
 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool CMICmdCmdExecInterrupt::Execute() {
-  CMICmnLLDBDebugSessionInfo &rSessionInfo(
-      CMICmnLLDBDebugSessionInfo::Instance());
-  lldb::SBDebugger &rDebugger = rSessionInfo.GetDebugger();
-  CMIUtilString strCmd("process interrupt");
-  const lldb::ReturnStatus status =
-      rDebugger.GetCommandInterpreter().HandleCommand(strCmd.c_str(),
-                                                      m_lldbResult, false);
-  MIunused(status);
-
+  const auto successHandler = [this] {
     // CODETAG_DEBUG_SESSION_RUNNING_PROG_RECEIVED_SIGINT_PAUSE_PROGRAM
     if (!CMIDriver::Instance().SetDriverStateRunningNotDebugging()) {
       const CMIUtilString &rErrMsg(CMIDriver::Instance().GetErrorDescription());
-    SetErrorDescription(
-        CMIUtilString::Format(MIRSRC(IDS_CMD_ERR_SET_NEW_DRIVER_STATE),
-                              strCmd.c_str(), rErrMsg.c_str()));
+      SetErrorDescription(CMIUtilString::Format(
+          MIRSRC(IDS_CMD_ERR_SET_NEW_DRIVER_STATE),
+          m_cmdData.strMiCmd.c_str(),
+          rErrMsg.c_str()));
       return MIstatus::failure;
     }
-
     return MIstatus::success;
+  };
+
+  return HandleSBErrorWithSuccess(
+      CMICmnLLDBDebugSessionInfo::Instance().GetProcess().Stop(),
+      successHandler);
 }
 
 //++
 //------------------------------------------------------------------------------------
 // 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 - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool CMICmdCmdExecInterrupt::Acknowledge() {
-  if (m_lldbResult.GetErrorSize() > 0) {
-    const CMICmnMIValueConst miValueConst(m_lldbResult.GetError());
-    const CMICmnMIValueResult miValueResult("message", miValueConst);
-    const CMICmnMIResultRecord miRecordResult(
-        m_cmdData.strMiCmdToken, CMICmnMIResultRecord::eResultClass_Error,
-        miValueResult);
-    m_miResultRecord = miRecordResult;
-  } else {
-    const CMICmnMIResultRecord miRecordResult(
-        m_cmdData.strMiCmdToken, CMICmnMIResultRecord::eResultClass_Done);
-    m_miResultRecord = miRecordResult;
-  }
-
+  m_miResultRecord = CMICmnMIResultRecord(
   return MIstatus::success;
 }
 
 //++
 //------------------------------------------------------------------------------------
 // Details: Required by the CMICmdFactory when registering *this command. The
 // factory
 //          calls this function to create an instance of *this command.

 //          for the work carried out in the Execute().
 // Type:    Overridden.
 // Args:    None.
 // Return:  MIstatus::success - Function succeeded.
 //          MIstatus::failure - Function failed.
 // Throws:  None.
 //--
 bool CMICmdCmdExecArguments::Acknowledge() {
-  const CMICmnMIResultRecord miRecordResult(
+  m_miResultRecord = CMICmnMIResultRecord(
       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.

 //          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() {
-  const CMICmnMIResultRecord miRecordResult(
+  m_miResultRecord = CMICmnMIResultRecord(
       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() {
   return new CMICmdCmdExecAbort();
 }