Make lldb-mi handle only MI commands

[abidh]

Summary

Previously lldb-mi can also act as a driver like normal lldb. It needed a lot
of redundant code in the lldb-mi for that. I think that if a user wants command
line lldb driver then he/she should use the lldb for it. This change will cleanup
the code a lot. When this change goes in, it will allow us to remove some more
redundant code too.

All tests pass on Linux. Did some sanity testing on command line and with eclipse.

[ki.stfu]

I don't mind about cleaning, but I disagree about CLI support in lldb-mi. I think support of mixed commands is useful (sometimes), and actually I planned to add this for lldb-mi one fine day.
For example, lldb-mi supports "quit" command (aka stdin hack) to be more friendly with users.

I tried to add this support using the CMIDriver::SetEnableFallThru(true), but this realization contained a lot of bugs. Therefore I preferred to wrap all CLI commands into "-interpreter-exec" and I don't mind about cleaning of lldb-mi.

[ki.stfu]

All tests pass on OS X.

As I understood you will remove Driver.cpp later, right?

[abidh]

In D8381#142042, @ki.stfu wrote:

All tests pass on OS X.

As I understood you will remove Driver.cpp later, right?

Yes. I will remove it later. Thanks for review.

[ted]

gdb handles command line gdb and MI in one executable. I think lldb should do the same. We ship one executable, called hexagon-lldb, that is actually lldb-mi. Pass --interpreter and it runs MI, otherwise it runs the standard LLDB CLI.

I'd really prefer one executable instead of two.

If you go through with this, PLEASE make sure the ctrl-c handler works on all platforms. This has been a problem for us on Windows, so I want to make sure after this change it still works. Also, ctrl-c shouldn't quit MI if a target isn't running. Imagine accidentally hitting ctrl-c twice to stop a target, but the second one quits.

[ki.stfu]

Hello Ted,

As I said above I planned to add support for CLI commands in lldb-mi. Here
is my patch for that: http://reviews.llvm.org/D8483

Thanks,
Ilia

[abidh]

In D8381#142039, @ki.stfu wrote:

I don't mind about cleaning, but I disagree about CLI support in lldb-mi.

In D8381#144097, @ted wrote:

gdb handles command line gdb and MI in one executable. I think lldb should do the same. We ship one executable, called hexagon-lldb, that is actually lldb-mi. Pass --interpreter and it runs MI, otherwise it runs the standard LLDB CLI.

I'd really prefer one executable instead of two.

If you go through with this, PLEASE make sure the ctrl-c handler works on all platforms. This has been a problem for us on Windows, so I want to make sure after this change it still works. Also, ctrl-c shouldn't quit MI if a target isn't running. Imagine accidentally hitting ctrl-c twice to stop a target, but the second one quits.

Ted,
Thanks for your concerns. I also faced this double ctrl-c issue in my internal branch that I build with mingw and I think I fixed it. The issue was non persistent single handling on Windows using signal API. MSVC uses SetConsoleCtrlHandler and this should not be a problem there. But I will keep an eye.

Regarding single executable, unfortunately, we already have 2. Trying to make lldb-mi also behave as lldb causes a lot of code duplication and #ifdef mess. I think it is better that it does one job and does it well.

[ki.stfu]

In D8381#144097, @ted wrote:

Also, ctrl-c shouldn't quit MI if a target isn't running. Imagine accidentally hitting ctrl-c twice to stop a target, but the second one quits.

I checked it in GDB/MI on Windows and it works as you said it shouldn't work. or did you mean that GDB/MI also doesn't work the way you want?

[ted]

I would like ctrl-c to not exit lldb-mi. "quit" exits, and it's too easy to hit ctrl-c when the target isn't running and accidentally exit lldb-mi.

I get my desired behavior by removing:

m_bExitApp = true;
m_rStdin.OnExitHandler();

from the bottom of CMIDriver::SetExitApplicationFlag() in MIDriver.cpp.

tools/lldb-mi/MICmnConfig.h

 //===-- MICmnConfig.h -------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //--
 #pragma once
 
-// 1 = Yes compile MI Driver version, 0 = compile original LLDB driver code only.
-// 0 was mainly just for testing purposes and so may be removed at a later time.
-#define MICONFIG_COMPILE_MIDRIVER_VERSION 1
-
 // 1 = Show debug process attach modal dialog, 0 = do not show
 // For windows only ATM, other OS's code is an infinite loop which a debugger must change a value to continue
 #define MICONFIG_DEBUG_SHOW_ATTACH_DBG_DLG 0
 
-// 1 = Compile in and init LLDB driver code alongside MI version, 0 = do not compile in
-#define MICONFIG_COMPILE_MIDRIVER_WITH_LLDBDRIVER 1
-
-// 1 = Give runtime our own custom buffer, 0 = Use runtime managed buffer
-#define MICONFIG_CREATE_OWN_STDIN_BUFFER 0
-
-// 1 = Use the MI driver regardless of --interpreter, 0 = require --interpreter argument
-// This depends on MICONFIG_COMPILE_MIDRIVER_WITH_LLDBDRIVER
-#define MICONFIG_DEFAULT_TO_MI_DRIVER 0
-
-// 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 1

tools/lldb-mi/MICmnResources.cpp

"Version: GNU gdb (GDB) 7.4 \n(This is a MI stub on top of LLDB and not GDB)\nAll rights reserved.\n"}, // *** Eclipse needs this
                              "using the internal\ndebugger then forms MI response formatted text which is returned to the\nclient."},
     {IDE_MI_APP_INFORMATION, "Information:\nCurrent limitations. The MI Driver currently only handles remote target\ndebugging. Local "
                              "debugging has not been implemented. The MI Driver has\nbeen designed primarily to be used with Eclipse Juno "
                              "and a custom plugin.\nThe custom plugin is not necessary to operate the MI Driver."},
     {IDE_MI_APP_ARG_USAGE, "\nMI driver usage:\n\n\tlldb-mi [--longOption] [-s hortOption] [executeable]\n\n[] = optional argument."},
     {IDE_MI_APP_ARG_HELP, "-h\n--help\n\tPrints out usage information for the MI debugger. Exit the MI\n\tDriver immediately."},
     {IDE_MI_APP_ARG_VERSION, "--version\n\tPrints out GNU (gdb) version information. Exit the MI Driver\n\timmediately."},
     {IDE_MI_APP_ARG_VERSION_LONG, "--versionLong\n\tPrints out MI Driver version information. Exit the MI Driver\n\timmediately."},
-    {IDE_MI_APP_ARG_INTERPRETER, "--interpreter\n\tUse the MI Driver for the debugger (MI mode)(Default is the\n\tLLDB driver). Any LLDB "
-                                 "command line options are ignored even\n\tif the MI Driver falls through to the LLDB driver. "
-                                 "(Depends\n\ton the build configuration see MICmnConfig.h)\n\tNormally specified by the driver client "
-                                 "i.e. Eclipse.\n\tCannot specify an executable with this option, use --executable."},
-    {IDE_MI_APP_ARG_EXECUTEABLE, "--executable\n\tUse the MI Driver in MI mode for the debugging the specified\n\texecutable. Any LLDB "
-                                 "command line options are ignored even\n\tif the MI Driver falls through to the LLDB driver. "
-                                 "(Depends\n\ton the build configuration see MICmnConfig.h)\n\tNormally specified from the command line."},
+    {IDE_MI_APP_ARG_INTERPRETER, "--interpreter\n\t This option is kept for backward compatibility. This executable always run in MI mode"},
+    {IDE_MI_APP_ARG_EXECUTEABLE, "--executable\n\tUse the MI Driver in MI mode for the debugging the specified executable." },
     {IDE_MI_APP_ARG_APP_LOG, "--log\n\tUse this argument to tell the MI Driver to update it's log\n\tfile '%s'."},
     {IDE_MI_APP_ARG_EXAMPLE, "Example MI command:\n\t3-info-gdb-mi-command gdb-set\n\t3^done,command={exists=\"true\"}"},
     {IDE_MI_APP_ARG_EXECUTABLE, "executable (NOT IMPLEMENTED)\n\tThe file path to the executable i.e. '\"C:\\My Dev\\foo.exe\"'."},
     {IDS_STDIN_ERR_INVALID_PROMPT, "Stdin. Invalid prompt description '%s'"},
     {IDS_STDIN_ERR_THREAD_CREATION_FAILED, "Stdin. Thread creation failed '%s'"},
     {IDS_STDIN_ERR_THREAD_DELETE, "Stdin. Thread failed to delete '%s'"},
     {IDS_STDIN_ERR_CHKING_BYTE_AVAILABLE, "Stdin. Peeking on stdin stream '%s'"},
     {IDS_STDIN_INPUT_CTRL_CHARS, "Stdin. Receive characters not handled as a command: "},

tools/lldb-mi/MIDriver.cpp

CMIDriver::Initialize(void)
     MI::ModuleInit<CMICmnStreamStderr>(IDS_MI_INIT_ERR_STREAMSTDERR, bOk, errMsg);
     MI::ModuleInit<CMICmnResources>(IDS_MI_INIT_ERR_RESOURCES, bOk, errMsg);
     MI::ModuleInit<CMICmnThreadMgrStd>(IDS_MI_INIT_ERR_THREADMANAGER, bOk, errMsg);
     MI::ModuleInit<CMICmnStreamStdin>(IDS_MI_INIT_ERR_STREAMSTDIN, bOk, errMsg);
     MI::ModuleInit<CMICmdMgr>(IDS_MI_INIT_ERR_CMDMGR, bOk, errMsg);
     bOk &= m_rLldbDebugger.SetDriver(*this);
     MI::ModuleInit<CMICmnLLDBDebugger>(IDS_MI_INIT_ERR_LLDBDEBUGGER, bOk, errMsg);
 
-#if MICONFIG_COMPILE_MIDRIVER_WITH_LLDBDRIVER
-    CMIDriverMgr &rDrvMgr = CMIDriverMgr::Instance();
-    bOk = bOk && rDrvMgr.RegisterDriver(*g_driver, "LLDB driver"); // Will be pass thru driver
-    if (bOk)
-    {
-        bOk = SetEnableFallThru(false); // This is intentional at this time - yet to be fully implemented
-        bOk = bOk && SetDriverToFallThruTo(*g_driver);
-        CMIUtilString strOtherDrvErrMsg;
-        if (bOk && GetEnableFallThru() && !g_driver->MISetup(strOtherDrvErrMsg))
-        {
-            bOk = false;
-            errMsg = CMIUtilString::Format(MIRSRC(IDS_MI_INIT_ERR_FALLTHRUDRIVER), strOtherDrvErrMsg.c_str());
-        }
-    }
-#endif // MICONFIG_COMPILE_MIDRIVER_WITH_LLDBDRIVER
-
     m_bExitApp = false;
 
     m_bInitialized = bOk;
 
     if (!bOk)
     {
         const CMIUtilString msg = CMIUtilString::Format(MIRSRC(IDS_MI_INIT_ERR_DRIVER), errMsg.c_str());
         SetErrorDescription(msg);

 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Check the arguments that were passed to this program to make sure they are
 //          valid and to get their argument values (if any). The following are options
 //          that are only handled by *this driver:
 //              --executable
 //          The application's options --interpreter and --executable in code act very similar.
-//          The --executable is necessary to differentiate whither the MI Driver is being
-//          using by a client i.e. Eclipse or from the command line. Eclipse issues the option
+//          The --executable is necessary to differentiate whether the MI Driver is being
+//          used by a client i.e. Eclipse or from the command line. Eclipse issues the option
 //          --interpreter and also passes additional arguments which can be interpreted as an
 //          executable if called from the command line. Using --executable tells the MI
 //          Driver is being called the command line and that the executable argument is indeed
 //          a specified executable an so actions commands to set up the executable for a
 //          debug session. Using --interpreter on the commnd line does not action additional
 //          commands to initialise a debug session and so be able to launch the process.
 // Type:    Overridden.
 // Args:    argc        - (R)   An integer that contains the count of arguments that follow in
if (bHaveArgs)
             {                                        // See fn description.
                 bHaveExecutableLongOption = true;
             }
         }
     }
 
     if (bHaveExecutableFileNamePath && bHaveExecutableLongOption)
     {
-// CODETAG_CMDLINE_ARG_EXECUTABLE_DEBUG_SESSION
-#if MICONFIG_ENABLE_MI_DRIVER_MI_MODE_CMDLINE_ARG_EXECUTABLE_DEBUG_SESSION
         SetDriverDebuggingArgExecutable();
-#else
-        vwbExiting = true;
-        errStatus.SetErrorString(MIRSRC(IDS_DRIVER_ERR_LOCAL_DEBUG_NOT_IMPL));
-#endif // MICONFIG_ENABLE_MI_DRIVER_MI_MODE_CMDLINE_ARG_EXECUTABLE_DEBUG_SESSION
     }
 
     return errStatus;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: A client can ask if *this driver is GDB/MI compatible.
 // Type:    Overridden.
CMIDriver::DoMainLoop(void)
     }
 
     if (!StartWorkerThreads())
         return MIstatus::failure;
 
     // App is not quitting currently
     m_bExitApp = false;
 
-// CODETAG_CMDLINE_ARG_EXECUTABLE_DEBUG_SESSION
-#if MICONFIG_ENABLE_MI_DRIVER_MI_MODE_CMDLINE_ARG_EXECUTABLE_DEBUG_SESSION
     if (HaveExecutableFileNamePathOnCmdLine())
     {
         if (!LocalDebugSessionStartupExecuteCommands())
         {
             SetErrorDescription(MIRSRC(IDS_MI_INIT_ERR_LOCAL_DEBUG_SESSION));
             return MIstatus::failure;
         }
     }
-#endif // MICONFIG_ENABLE_MI_DRIVER_MI_MODE_CMDLINE_ARG_EXECUTABLE_DEBUG_SESSION
 
     // While the app is active
     while (!m_bExitApp)
     {
         CMIUtilString errorText;
         const MIchar *pCmd = m_rStdin.ReadLine (errorText);
         if (pCmd != nullptr)
         {

tools/lldb-mi/MIDriverMain.cpp

 #include "Driver.h"
 #include "MIDriverMgr.h"
 #include "MIDriver.h"
 #include "MICmnResources.h"
 #include "MICmnStreamStdin.h"
 #include "MIUtilDebug.h"
 #include "MICmnLog.h"
 
-#if MICONFIG_COMPILE_MIDRIVER_VERSION
 
 #if defined(_MSC_VER)
 #pragma warning(once : 4530) // Warning C4530: C++ exception handler used, but unwind semantics are not enabled. Specify /EHsc
 #endif                       // _MSC_VER
 
-// ToDo: Reevaluate if this function needs to be implemented like the UNIX equivalent
-// CODETAG_IOR_SIGNALS
-//++ ------------------------------------------------------------------------------------
-// Details: The SIGWINCH signal is sent to a process when its controlling terminal
-//          changes its size (a window change).
-// Type:    Function.
-// Args:    vSigno  - (R) Signal number.
-// Return:  None.
-// Throws:  None.
-//--
-void
-sigwinch_handler(int vSigno)
-{
-#ifdef _WIN32 // Restore handler as it is not persistent on Windows
-    signal(SIGWINCH, sigwinch_handler);
-#endif
-    MIunused(vSigno);
-
-    struct winsize window_size;
-    if (::isatty(STDIN_FILENO) && ::ioctl(STDIN_FILENO, TIOCGWINSZ, &window_size) == 0)
-    {
-        CMIDriverMgr &rDriverMgr = CMIDriverMgr::Instance();
-        if (window_size.ws_col > 0)
-        {
-            rDriverMgr.DriverResizeWindow((uint32_t)window_size.ws_col);
-        }
-    }
-
-    CMICmnLog::Instance().WriteLog(CMIUtilString::Format(MIRSRC(IDS_PROCESS_SIGNAL_RECEIVED), "SIGWINCH", vSigno));
-}
-
 // CODETAG_IOR_SIGNALS
 //++ ------------------------------------------------------------------------------------
 // Details: The SIGINT signal is sent to a process by its controlling terminal when a
 //          user wishes to interrupt the process. This is typically initiated by pressing
 //          Control-C, but on some systems, the "delete" character or "break" key can be
 //          used.
 //          Be aware this function may be called on another thread besides the main thread.
 // Type:    Function.
#endif
     }
 
     CMICmnLog::Instance().WriteLog(CMIUtilString::Format(MIRSRC(IDS_PROCESS_SIGNAL_RECEIVED), "SIGINT", vSigno));
 
     // Send signal to driver so that it can take suitable action
     rDriverMgr.DeliverSignal (vSigno);
 }
 
-// ToDo: Reevaluate if this function needs to be implemented like the UNIX equivalent
-// CODETAG_IOR_SIGNALS
-//++ ------------------------------------------------------------------------------------
-// Details: The SIGTSTP signal is sent to a process by its controlling terminal to
-//          request it to stop temporarily. It is commonly initiated by the user pressing
-//          Control-Z. Unlike SIGSTOP, the process can register a signal handler for or
-//          ignore the signal.
-//          *** The function does not behave ATM like the UNIX equivalent ***
-// Type:    Function.
-// Args:    vSigno  - (R) Signal number.
-// Return:  None.
-// Throws:  None.
-//--
-void
-sigtstp_handler(int vSigno)
-{
-#ifdef _WIN32 // Restore handler as it is not persistent on Windows
-    signal(SIGTSTP, sigtstp_handler);
-#endif
-    CMIDriverMgr &rDriverMgr = CMIDriverMgr::Instance();
-    lldb::SBDebugger *pDebugger = rDriverMgr.DriverGetTheDebugger();
-    if (pDebugger != nullptr)
-    {
-        pDebugger->SaveInputTerminalState();
-    }
-
-    CMICmnLog::Instance().WriteLog(CMIUtilString::Format(MIRSRC(IDS_PROCESS_SIGNAL_RECEIVED), "SIGTSTP", vSigno));
-
-    // Send signal to driver so that it can take suitable action
-    rDriverMgr.DeliverSignal (vSigno);
-}
-
-// ToDo: Reevaluate if this function needs to be implemented like the UNIX equivalent
-// CODETAG_IOR_SIGNALS
-//++ ------------------------------------------------------------------------------------
-// Details: The SIGCONT signal instructs the operating system to continue (restart) a
-//          process previously paused by the SIGSTOP or SIGTSTP signal. One important use
-//          of this signal is in job control in the UNIX shell.
-//          *** The function does not behave ATM like the UNIX equivalent ***
-// Type:    Function.
-// Args:    vSigno  - (R) Signal number.
-// Return:  None.
-// Throws:  None.
-//--
-void
-sigcont_handler(int vSigno)
-{
-#ifdef _WIN32 // Restore handler as it is not persistent on Windows
-    signal(SIGCONT, sigcont_handler);
-#endif
-    CMIDriverMgr &rDriverMgr = CMIDriverMgr::Instance();
-    lldb::SBDebugger *pDebugger = rDriverMgr.DriverGetTheDebugger();
-    if (pDebugger != nullptr)
-    {
-        pDebugger->RestoreInputTerminalState();
-    }
-
-    CMICmnLog::Instance().WriteLog(CMIUtilString::Format(MIRSRC(IDS_PROCESS_SIGNAL_RECEIVED), "SIGCONT", vSigno));
-
-    // Send signal to driver so that it can take suitable action
-    rDriverMgr.DeliverSignal (vSigno);
-}
-
 //++ ------------------------------------------------------------------------------------
 // Details: Init the MI driver system. Initialize the whole driver system which includes
 //          both the original LLDB driver and the MI driver.
 // Type:    Function.
 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 DriverSystemInit(void)
 {
     bool bOk = MIstatus::success;
-
-#if MICONFIG_COMPILE_MIDRIVER_WITH_LLDBDRIVER
-    Driver *pDriver = Driver::CreateSelf();
-    if (pDriver == nullptr)
-        return MIstatus::failure;
-#endif // MICONFIG_COMPILE_MIDRIVER_WITH_LLDBDRIVER
-
     CMIDriver &rMIDriver = CMIDriver::Instance();
     CMIDriverMgr &rDriverMgr = CMIDriverMgr::Instance();
     bOk = rDriverMgr.Initialize();
 
     // Register MIDriver first as it needs to initialize and be ready
     // for the Driver to get information from MIDriver when it initializes
     // (LLDB Driver is registered with the Driver Manager in MI's Initialize())
     bOk = bOk && rDriverMgr.RegisterDriver(rMIDriver, "MIDriver"); // Will be main driver

 //--
 bool
 DriverSystemShutdown(const bool vbAppExitOk)
 {
     bool bOk = MIstatus::success;
 
     // *** Order is important here ***
     CMIDriverMgr::Instance().Shutdown();
-
-#if MICONFIG_COMPILE_MIDRIVER_WITH_LLDBDRIVER
-    delete g_driver;
-    g_driver = nullptr;
-#endif // MICONFIG_COMPILE_MIDRIVER_WITH_LLDBDRIVER
-
     return bOk;
 }
 
-#else
-void
-sigwinch_handler(int signo)
-{
-    struct winsize window_size;
-    if (isatty(STDIN_FILENO) && ::ioctl(STDIN_FILENO, TIOCGWINSZ, &window_size) == 0)
-    {
-        if ((window_size.ws_col > 0) && g_driver != NULL)
-        {
-            g_driver->ResizeWindow(window_size.ws_col);
-        }
-    }
-}
-
-void
-sigint_handler(int signo)
-{
-    static bool g_interrupt_sent = false;
-    if (g_driver)
-    {
-        if (!g_interrupt_sent)
-        {
-            g_interrupt_sent = true;
-            g_driver->GetDebugger().DispatchInputInterrupt();
-            g_interrupt_sent = false;
-            return;
-        }
-    }
-
-    exit(signo);
-}
-
-void
-sigtstp_handler(int signo)
-{
-    g_driver->GetDebugger().SaveInputTerminalState();
-    signal(signo, SIG_DFL);
-    kill(getpid(), signo);
-    signal(signo, sigtstp_handler);
-}
-
-void
-sigcont_handler(int signo)
-{
-    g_driver->GetDebugger().RestoreInputTerminalState();
-    signal(signo, SIG_DFL);
-    kill(getpid(), signo);
-    signal(signo, sigcont_handler);
-}
-#endif // #if MICONFIG_COMPILE_MIDRIVER_VERSION
-
 //++ ------------------------------------------------------------------------------------
 // Details: MI's application start point of execution. The applicaton runs in two modes.
 //          An LLDB native driver mode where it acts no different from the LLDB driver.
 //          The other mode is the MI when it finds on the command line
 //          the --interpreter option. Command line argument --help on its own will give
 //          help for the LLDB driver. If entered with --interpreter then application
 //          help will provided.
 // Type:    Method.
 // Args:    argc    - (R) An integer that contains the count of arguments that follow in
 //                        argv. The argc parameter is always greater than or equal to 1.
 //          argv    - (R) An array of null-terminated strings representing command-line
 //                        arguments entered by the user of the program. By convention,
 //                        argv[0] is the command with which the program is invoked.
 // Return:  int -  0 =   Normal exit, program success.
 //                >0    = Program success with status i.e. Control-C signal status
 //                <0    = Program failed.
 //              -1      = Program failed reason not specified here, see MI log file.
 //              -1000   = Program failed did not initailize successfully.
 // Throws:  None.
 //--
-#if MICONFIG_COMPILE_MIDRIVER_VERSION
 int
 main(int argc, char const *argv[])
 {
 #if MICONFIG_DEBUG_SHOW_ATTACH_DBG_DLG
 #ifdef _WIN32
     CMIUtilDebug::ShowDlgWaitForDbgAttach();
 #else
     CMIUtilDebug::WaitForDbgAttachInfinteLoop();
 #endif //  _WIN32
 #endif // MICONFIG_DEBUG_SHOW_ATTACH_DBG_DLG
 
     // *** Order is important here ***
     bool bOk = DriverSystemInit();
     if (!bOk)
     {
         DriverSystemShutdown(bOk);
         return -1000;
     }
 
     // CODETAG_IOR_SIGNALS
-    signal(SIGPIPE, SIG_IGN);
-    signal(SIGWINCH, sigwinch_handler);
     signal(SIGINT, sigint_handler);
-    signal(SIGTSTP, sigtstp_handler);
-    signal(SIGCONT, sigcont_handler);
 
     bool bExiting = false;
     CMIDriverMgr &rDriverMgr = CMIDriverMgr::Instance();
     bOk = bOk && rDriverMgr.ParseArgs(argc, argv, bExiting);
     if (bOk && !bExiting)
         bOk = rDriverMgr.DriverParseArgs(argc, argv, stdout, bExiting);
     if (bOk && !bExiting)
         bOk = rDriverMgr.DriverMainLoop();
 
     // Logger and other resources shutdown now
     DriverSystemShutdown(bOk);
 
     const int appResult = bOk ? 0 : -1;
 
     return appResult;
 }
-#else  // Operate the lldb Driver only version of the code
-int
-main(int argc, char const *argv[], char *envp[])
-{
-    MIunused(envp);
-    using namespace lldb;
-    SBDebugger::Initialize();
-
-    SBHostOS::ThreadCreated("<lldb.driver.main-thread>");
-
-    signal(SIGPIPE, SIG_IGN);
-    signal(SIGWINCH, sigwinch_handler);
-    signal(SIGINT, sigint_handler);
-    signal(SIGTSTP, sigtstp_handler);
-    signal(SIGCONT, sigcont_handler);
-
-    // Create a scope for driver so that the driver object will destroy itself
-    // before SBDebugger::Terminate() is called.
-    {
-        Driver driver;
-
-        bool exiting = false;
-        SBError error(driver.ParseArgs(argc, argv, stdout, exiting));
-        if (error.Fail())
-        {
-            const char *error_cstr = error.GetCString();
-            if (error_cstr)
-                ::fprintf(stderr, "error: %s\n", error_cstr);
-        }
-        else if (!exiting)
-        {
-            driver.MainLoop();
-        }
-    }
-
-    SBDebugger::Terminate();
-    return 0;
-}
-#endif // MICONFIG_COMPILE_MIDRIVER_VERSION

tools/lldb-mi/MIDriverMgr.cpp

CMIDriverMgr::ParseArgs(const int argc, const char *argv[], bool &vwbExiting)
 
     // Look for the command line options
     bool bHaveArgInterpret = false;
     bool bHaveArgVersion = false;
     bool bHaveArgVersionLong = false;
     bool bHaveArgLog = false;
     bool bHaveArgHelp = false;
 
-// Hardcode the use of the MI driver
-#if MICONFIG_DEFAULT_TO_MI_DRIVER
     bHaveArgInterpret = true;
-#endif // MICONFIG_DEFAULT_TO_MI_DRIVER
-
     if (bHaveArgs)
     {
         // CODETAG_MIDRIVE_CMD_LINE_ARG_HANDLING
         for (MIint i = 1; i < argc; i++)
         {
             // *** Add args to help in GetHelpOnCmdLineArgOptions() ***
             const CMIUtilString strArg(argv[i]);
 

tools/lldb-mi/MIReadMe.txt

 ========================================================================
     The MI Driver - LLDB Machine Interface V2 (MI)  Project Overview
 ========================================================================
 
 The MI Driver is a stand alone executable that either be used via a 
 client i.e. Eclipse or directly from the command line. 
 
-The MI Driver has two modes of operation; LLDB and MI. The MI Driver (CMIDriver)
-which operates the MI mode is a driver in its own right to work alongside
-the LLDB driver (driver .h/.cpp). Only one is operatational at a time depending
-on the options entered on the command line. The MI Driver reads MI inputs and
-outputs MI responses to be interpreted by a client i.e. Eclipse. 
-Should the MI Driver not understand an instruction it could be passed to the 
-LLDB driver for interpretation (MI Driver build configuration dependant). Should 
-the LLDB driver mode be chosen then it the MI Driver will behave as the normal 
-LLDB driver.
-
 For help information on using the MI driver type at the command line:
 
   lldb-mi --interpreter --help
 
 A blog about the MI Driver is available on CodePlay's website. ALthough it may not be
 completely accurate after the recent changes in lldb-mi.
 http://www.codeplay.com/portal/lldb-mi-driver---part-1-introduction
 
 In MI mode and invoked with --log option, lldb-mi generates lldb-mi-log.txt 
 This file keeps a history of the MI Driver's activity for one session. It is
 used to aid the debugging of the MI Driver. It also gives warnings about
 command's which do not support certain argument or options.  
 
 Note any command or text sent to the MI Driver in MI mode that is not a command 
 registered in the MI Driver's Command Factory will be rejected and an error messsage
 will be generated.
 
 All the files prefix with MI are specifically for the MI driver code only.
-Non prefixed code is the original LLDB driver which has been left untouched
-as much as possible. This allows the LLDB driver code to develop 
-independently and make future integration more straight forward. 
-
-File MIDriverMain.cpp contains the executables main() function and some 
-common global functions common to the two drivers.
+File MIDriverMain.cpp contains the executables main() function.
 
 =========================================================================
 Current limitations:
 1. Not all commands and their options have been implemented. Please see
 the source code for details.
 2. LLDB-MI may have additinal arguments not used in GDB MI. Please see
 MIExtesnsions.txt
 
 =========================================================================
 The MI Driver build configuration:
 MICmnConfig.h defines various preprocessor build options.