Allow to pass an executable file via lldb-mi arguments (MI)

[ki.stfu]

Summary

1. Allow to pass an executable file via lldb-mi arguments
2. Add tests
3. Fix (gdb) prompt in CMIDriver::LocalDebugSessionStartupExecuteCommands
4. Fix prompt in CMIDriver::InterpretCommandThisDriver: use the lldb-mi prompt instead of a hard-coded value.

All tests pass on OS X.

test/tools/lldb-mi/startup_options/Makefile

+LEVEL = ../../../make
+
+CXX_SOURCES := main.cpp
+
+include $(LEVEL)/Makefile.rules

test/tools/lldb-mi/startup_options/TestMiStartupOptions.py

+"""
+Test lldb-mi startup options.
+"""
+
+# adjust path for lldbmi_testcase.py
+import sys, os.path
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+import lldbmi_testcase
+from lldbtest import *
+import unittest2
+
+class MiStartupOptionsTestCase(lldbmi_testcase.MiTestCaseBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @lldbmi_test
+    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
+    def test_lldbmi_executable_option_file(self):
+        """Test that 'lldb-mi --interpreter %s' loads executable file."""
+
+        self.spawnLldbMi(args = "%s" % self.myexe)
+
+        # Test that lldb-mi is ready after startup
+        self.expect(self.child_prompt, exactly = True)
+
+        # Test that the executable is loaded when file was specified
+        self.expect("-file-exec-and-symbols \"%s\"" % self.myexe)
+        self.expect("\^done")
+
+        # Test that lldb-mi is ready when executable was loaded
+        self.expect(self.child_prompt, exactly = True)
+
+        # Run
+        self.runCmd("-exec-run")
+        self.expect("\^running")
+        self.expect("\*stopped,reason=\"exited-normally\"")
+
+    @lldbmi_test
+    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
+    def test_lldbmi_executable_option_unknown_file(self):
+        """Test that 'lldb-mi --interpreter %s' fails on unknown executable file."""
+
+        # Prepare path to executable
+        path = "unknown_file"
+
+        self.spawnLldbMi(args = "%s" % path)
+
+        # Test that lldb-mi is ready after startup
+        self.expect(self.child_prompt, exactly = True)
+
+        # Test that the executable isn't loaded when unknown file was specified
+        self.expect("-file-exec-and-symbols \"%s\"" % path)
+        self.expect("\^error,msg=\"Command 'file-exec-and-symbols'. Target binary '%s' is invalid. error: unable to find executable for '%s'\"" % (path, path))
+
+        # Test that lldb-mi is ready when executable was loaded
+        self.expect(self.child_prompt, exactly = True)
+
+    @lldbmi_test
+    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
+    def test_lldbmi_executable_option_absolute_path(self):
+        """Test that 'lldb-mi --interpreter %s' loads executable which is specified via absolute path."""
+
+        # Prepare path to executable
+        import os
+        path = os.path.join(os.getcwd(), self.myexe)
+
+        self.spawnLldbMi(args = "%s" % path)
+
+        # Test that lldb-mi is ready after startup
+        self.expect(self.child_prompt, exactly = True)
+
+        # Test that the executable is loaded when file was specified using absolute path
+        self.expect("-file-exec-and-symbols \"%s\"" % path)
+        self.expect("\^done")
+
+        # Test that lldb-mi is ready when executable was loaded
+        self.expect(self.child_prompt, exactly = True)
+
+        # Run
+        self.runCmd("-exec-run")
+        self.expect("\^running")
+        self.expect("\*stopped,reason=\"exited-normally\"")
+
+    @lldbmi_test
+    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
+    def test_lldbmi_executable_option_relative_path(self):
+        """Test that 'lldb-mi --interpreter %s' loads executable which is specified via relative path."""
+
+        # Prepare path to executable
+        path = "./%s" % self.myexe
+
+        self.spawnLldbMi(args = "%s" % path)
+
+        # Test that lldb-mi is ready after startup
+        self.expect(self.child_prompt, exactly = True)
+
+        # Test that the executable is loaded when file was specified using relative path
+        self.expect("-file-exec-and-symbols \"%s\"" % path)
+        self.expect("\^done")
+
+        # Test that lldb-mi is ready when executable was loaded
+        self.expect(self.child_prompt, exactly = True)
+
+        # Run
+        self.runCmd("-exec-run")
+        self.expect("\^running")
+        self.expect("\*stopped,reason=\"exited-normally\"")
+
+    @lldbmi_test
+    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
+    def test_lldbmi_executable_option_unknown_path(self):
+        """Test that 'lldb-mi --interpreter %s' fails on executable file which is specified via unknown path."""
+
+        # Prepare path to executable
+        path = "unknown_dir/%s" % self.myexe
+
+        self.spawnLldbMi(args = "%s" % path)
+
+        # Test that lldb-mi is ready after startup
+        self.expect(self.child_prompt, exactly = True)
+
+        # Test that the executable isn't loaded when file was specified using unknown path
+        self.expect("-file-exec-and-symbols \"%s\"" % path)
+        self.expect("\^error,msg=\"Command 'file-exec-and-symbols'. Target binary '%s' is invalid. error: unable to find executable for '%s'\"" % (path, path))
+
+        # Test that lldb-mi is ready when executable was loaded
+        self.expect(self.child_prompt, exactly = True)
+
+if __name__ == '__main__':
+    unittest2.main()

test/tools/lldb-mi/startup_options/main.cpp

+//===-- main.cpp ------------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+int
+main(int argc, char const *argv[])
+{
+    return 0;
+}

tools/lldb-mi/MICmnConfig.h

 // 1 = Check for stdin before we issue blocking read, 0 = issue blocking call always
 #define MICONFIG_POLL_FOR_STD_IN 1
 
 // 1 = Write to MI's Log file warnings about commands that did not handle arguments or
 // options present to them by the driver's client, 0 = no warnings given
 #define MICONFIG_GIVE_WARNING_CMD_ARGS_NOT_HANDLED 1
 
 // 1 = Enable MI Driver in MI mode to create a local debug session, 0 = Report "Not implemented"
-#define MICONFIG_ENABLE_MI_DRIVER_MI_MODE_CMDLINE_ARG_EXECUTABLE_DEBUG_SESSION 0
+#define MICONFIG_ENABLE_MI_DRIVER_MI_MODE_CMDLINE_ARG_EXECUTABLE_DEBUG_SESSION 1

tools/lldb-mi/MIDriver.cpp

CMIDriver::InterpretCommandThisDriver(const CMIUtilString &vTextLine, bool &vwbCmdYesValid)
     if (bCmdNotInCmdFactor)
         strNotInCmdFactory = CMIUtilString::Format(MIRSRC(IDS_DRIVER_CMD_NOT_IN_FACTORY), cmdData.strMiCmd.c_str());
     const CMIUtilString strNot(CMIUtilString::Format("%s ", MIRSRC(IDS_WORD_NOT)));
     const CMIUtilString msg(
         CMIUtilString::Format(MIRSRC(IDS_DRIVER_CMD_RECEIVED), vTextLine.c_str(), strNot.c_str(), strNotInCmdFactory.c_str()));
     const CMICmnMIValueConst vconst = CMICmnMIValueConst(msg);
     const CMICmnMIValueResult valueResult("msg", vconst);
     const CMICmnMIResultRecord miResultRecord(cmdData.strMiCmdToken, CMICmnMIResultRecord::eResultClass_Error, valueResult);
-    m_rStdOut.WriteMIResponse(miResultRecord.GetString());
-    m_rStdOut.WriteMIResponse("(gdb)");
+    bool bOk = m_rStdOut.WriteMIResponse(miResultRecord.GetString());
+    if (bOk && m_rStdin.GetEnablePrompt())
+        bOk = m_rStdOut.WriteMIResponse(m_rStdin.GetPrompt());
 
     // Proceed to wait for or execute next command
-    return MIstatus::success;
+    return bOk;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Having previously had the potential command validated and found valid now
 //          get the command executed.
 //          This function is used by the application's main thread.
 // Type:    Method.
 // Args:    vCmdData    - (RW) Command meta data.

 // Return:  MIstatus::success - Functionality succeeded.
 //          MIstatus::failure - Functionality failed.
 // Throws:  None.
 //--
 bool
 CMIDriver::LocalDebugSessionStartupExecuteCommands(void)
 {
     const CMIUtilString strCmd(CMIUtilString::Format("-file-exec-and-symbols \"%s\"", m_strCmdLineArgExecuteableFileNamePath.AddSlashes().c_str()));
-    const bool bOk = CMICmnStreamStdout::TextToStdout(strCmd);
-    return (bOk && InterpretCommand(strCmd));
+    bool bOk = CMICmnStreamStdout::TextToStdout(strCmd);
+    bOk = bOk && InterpretCommand(strCmd);
+    if (bOk && m_rStdin.GetEnablePrompt())
+        bOk = m_rStdOut.WriteMIResponse(m_rStdin.GetPrompt());
+    return bOk;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Set the MI Driver into "its debugging an executable passed as an argument"
 //          mode as against running via a client like Eclipse.
 // Type:    Method.
 // Args:    None.
 // Return:  None.