Reduce number of threads in lldb-mi.

[abidh]

Summary

LLDB-mi have 3 threads.

1. Wait for input.
2. Process commands.
3. Process events.

This revision merges 1 & 2. Same thread waits on input and then process the
command. This way, no synchronization is needed between first and 2nd. Also it is
easy to check when to exit.

This revision just makes the minimal changes to use one thread for reading intput
and then processnig the commands. A lot of code has become redundant now. I will
clean it up gradually.

All lldb-mi tests pass with gcc and clang as test compiler. Also did minimal testing
on command line and works ok. The "quit" and "-gdb-exit" command close the application
without needing any further return.

After this revision goes in, it will not be possible to give the name of the
executable on command line and lldb-mi accepting it. This functionality is already
stubbed out in the code by he following #ifdef so we will not lose anything.
MICONFIG_ENABLE_MI_DRIVER_MI_MODE_CMDLINE_ARG_EXECUTABLE_DEBUG_SESSION

For posix system, it is even possible to make lldb-mi a single thread app. But on
windows, it is difficult to wait on stdin with timeout like what you can do with
select. So next best thing is to use 2 threads instead of 3.

[abidh]

Lock mutex before processing command.

[ki.stfu]

Extra cleaning is needed.

tools/lldb-mi/MIDriver.cpp

552–573

I think you should use MICmnStreamStdin module. For example, m_rStdin.ReadLine() function.

Also you should check if we need IOSStdinHandler::InputAvailable and IOSStdinHandler::InterruptReadLine functions and use them (or remove).

556

Why you don't remove CMICmnStreamStdin::ThreadRun() and CMICmnStreamStdin::MonitorStdin()?

631

We should remove ReadStdinLineQueue if it not used any more.

tools/lldb-mi/MIDriver.h

178

I think you should use existing code from MICmnStreamStdin.

[ki.stfu]

I have tested the Diff 2 on OS X, all tests passed.

[abidh]

tools/lldb-mi/MIDriver.cpp

552–573

As I said in my comments above. Not only these functions but a lot of other code will be redundant after this and I will remove them gradually.

631

I will surly do in a separate revision. There will be a lot of code cleanup.

tools/lldb-mi/MIDriver.h

178

A lot of those classes will be unnecessary after this revision and I plan to remove them. So only this Readline will be kept.

[ki.stfu]

After this revision goes in, it will not be possible to give the name of the executable on command line and lldb-mi accepting it. This functionality is already stubbed out in the code by he following #ifdef so we will not lose anything.

Why? We can use ExecuteCommand instead of InjectCommand in LocalDebugSessionStartupInjectCommands. I have tested it, and it works.

For posix system, it is even possible to make lldb-mi a single thread app. But on windows, it is difficult to wait on stdin with timeout like what you can do with select. So next best thing is to use 2 threads instead of 3.

Can you explain me, why? I don't mind, I'm just wondering.

[abidh]

After this revision goes in, it will not be possible to give the name of the executable on command line and lldb-mi accepting it. This functionality is already stubbed out in the code by he following #ifdef so we will not lose anything.

Why? We can use ExecuteCommand instead of InjectCommand in LocalDebugSessionStartupInjectCommands. I have tested it, and it works.

You are right. We can keep this functionality. But I dont like code being stubbed out with random #ifdef. If it is needed then it should be enabled all times and tested. Otherwise it should be removed.

For posix system, it is even possible to make lldb-mi a single thread app. But on windows, it is difficult to wait on stdin with timeout like what you can do with select. So next best thing is to use 2 threads instead of 3.

Can you explain me, why? I don't mind, I'm just wondering.

On linux, I have experimented with a single-threaded lldb-mi and it works. The sequence is

1. Wait for stdin with a timeout.
2. If a command, process it and go to 4.
3. If time out, go to 4.
4. Process events if any and go to 1.

This worked on Linux. But problem is that 'select' call works only with sockets on Windows. I tried other Windows APIs but nothing provides a simple interface as select. So I abandoned the idea of making it single threaded.

[ki.stfu]

tools/lldb-mi/MIDriver.cpp

631

If be honest I'd prefer to do it simultaneously. It gives a chance to review all your changes at once and it will help me (and possible us) adopt a more exact solution.

[abidh]

Remove ReadStdinLineQueue. Move ReadLine to the end of the file.

[ki.stfu]

In D7746#126426, @abidh wrote:

After this revision goes in, it will not be possible to give the name of the executable on command line and lldb-mi accepting it. This functionality is already stubbed out in the code by he following #ifdef so we will not lose anything.

Why? We can use ExecuteCommand instead of InjectCommand in LocalDebugSessionStartupInjectCommands. I have tested it, and it works.

You are right. We can keep this functionality. But I dont like code being stubbed out with random #ifdef. If it is needed then it should be enabled all times and tested. Otherwise it should be removed.

We can enable this ability by default. It will not require additional efforts on startup.

For posix system, it is even possible to make lldb-mi a single thread app. But on windows, it is difficult to wait on stdin with timeout like what you can do with select. So next best thing is to use 2 threads instead of 3.

Can you explain me, why? I don't mind, I'm just wondering.

On linux, I have experimented with a single-threaded lldb-mi and it works. The sequence is

1. Wait for stdin with a timeout.
2. If a command, process it and go to 4.
3. If time out, go to 4.
4. Process events if any and go to 1.

This worked on Linux. But problem is that 'select' call works only with sockets on Windows. I tried other Windows APIs but nothing provides a simple interface as select. So I abandoned the idea of making it single threaded.

A small interval will load CPU. 2 threads is a good solution.

[ki.stfu]

tools/lldb-mi/MIDriver.h

178

I think we should move this functionality to CMICmnStreamStdin class and keep it (if you want to delete entire class).

[ki.stfu]

Let's summarize:

• remove unnecessary code in this patch (don't do it in different revision)
• keep CMICmnStreamStdin/CMICmnStreamStdout/CMICmnStreamStderr class
• use CMICmnStreamStdin::ReadLine
• use ExecuteCommand instead of InjectCommand in LocalDebugSessionStartupInjectCommands (and rename it to LocalDebugSessionStartupExecuteCommands)

[abidh]

In D7746#126486, @ki.stfu wrote:

Let's summarize:

• remove unnecessary code in this patch (don't do it in different revision)

Ok. I have done more cleanup. But a lot of things are connected. I prefer to go in relatively small patches. In that cases, it is easier to figure out which commit caused a breakage.

• keep CMICmnStreamStdin/CMICmnStreamStdout/CMICmnStreamStderr class

I dont intend to remove them in this patch anyway. But longer term, we will see.

• use CMICmnStreamStdin::ReadLine

I dont think that is correct. CMICmnStreamStdin::ReadLine delegate to classes for Windows and Linux. Windows class especailly touches some members which are set in InputAvailable which we are not using anymore.

When we have removed the input monitoring thread, most of the function in this class are redundant. Longer term, I think this class will go.

• use ExecuteCommand instead of InjectCommand in LocalDebugSessionStartupInjectCommands (and rename it to LocalDebugSessionStartupExecuteCommands)

I have done that and removed Queue and InjectMICommands functions.

I will post updated patch shortly.

[abidh]

The above patch does not handle the signal correctly. I will fix that too.

[ki.stfu]

In D7746#126524, @abidh wrote:

• use CMICmnStreamStdin::ReadLine

I dont think that is correct. CMICmnStreamStdin::ReadLine delegate to classes for Windows and Linux. Windows class especailly touches some members which are set in InputAvailable which we are not using anymore.
When we have removed the input monitoring thread, most of the function in this class are redundant. Longer term, I think this class will go.

We can reduce its logic and remove CMICmnStreamStdinWindows and CMICmnStreamStdinLinux. I just want to keep the stdin operations in separate file, as it were done for stdout/stderr. It looks good for me.

[abidh]

Used CMICmnStreamStdin::ReadLine to read input.
Changed the scheme of how singal are handled.
Removed some un-used function and data from CMIDriver.

[ki.stfu]

Looks good. What about further cleaning? We can clean CMICmnStreamStdin and remove MICmnStreamStdinLinux MICmnStreamStdinWindows classes. You want to do it in separate review?

tools/lldb-mi/MICmnStreamStdin.h

125–126

Let's do it the same way as in MICmnStreamStdinLinux.cpp:

• Specify m_constBufferSize and m_pCmdBuffer in header file:

67     // Attributes:
68   private:
69     const MIuint m_constBufferSize;
70     FILE *m_pStdin;
71     MIchar *m_pCmdBuffer;

• Initialize in ctor:

42 CMICmnStreamStdinLinux::CMICmnStreamStdinLinux(void)
43     : m_constBufferSize(1024)
44     , m_pStdin(nullptr)
45     , m_pCmdBuffer(nullptr)
46     , m_waitForInput(true)

• Create buffer in CMICmnStreamStdinLinux::Initialize:

83     // Other resources required
84     if (bOk)
85     {
86         m_pCmdBuffer = new MIchar[m_constBufferSize];
87         m_pStdin = stdin;
88     }

• Use it in fgets:

199     // Read user input
200     const MIchar *pText = ::fgets(&m_pCmdBuffer[0], m_constBufferSize, stdin);

• Don't forget to free it in CMICmnStreamStdinLinux::Shutdown:

126     // Tidy up
127     if (m_pCmdBuffer != nullptr)
128     {
129         delete[] m_pCmdBuffer;
130         m_pCmdBuffer = nullptr;
131     }

tools/lldb-mi/MIDriver.cpp

968

The InjectMICommand prints the passed command using m_rStdOut.WriteMIResponse. You should do the same.

1177–1179

It should be like:

const CMIUtilString strCommand(CMIUtilString::Format("-file-exec-and-symbols \"%s\"", m_strCmdLineArgExecuteableFileNamePath.c_str()));
const bool bOk = CMICmnStreamStdout::TextToStdout(strCommand);
return (bOk && InterpretCommand(strCommand));

tools/lldb-mi/MIDriverMain.cpp

137

Should we remove it too?

tools/lldb-mi/MIDriverMgr.cpp

792

void DeliverSignal(const int vnSignal)

tools/lldb-mi/MIDriverMgr.h

82

Please, specify an argument name and let's use lldb-mi style:

virtual void DeliverSignal(const int vnSignal) = 0;

110

void DeliverSignal(const int vnSignal);

[abidh]

We can reduce its logic and remove CMICmnStreamStdinWindows and CMICmnStreamStdinLinux. I just want to keep the stdin operations in separate file, as it were done for stdout/stderr. It looks good for me.

In D7746#126540, @ki.stfu wrote:

In D7746#126524, @abidh wrote:

• use CMICmnStreamStdin::ReadLine

I dont think that is correct. CMICmnStreamStdin::ReadLine delegate to classes for Windows and Linux. Windows class especailly touches some members which are set in InputAvailable which we are not using anymore.
When we have removed the input monitoring thread, most of the function in this class are redundant. Longer term, I think this class will go.

We can reduce its logic and remove CMICmnStreamStdinWindows and CMICmnStreamStdinLinux. I just want to keep the stdin operations in separate file, as it were done for stdout/stderr. It looks good for me.

OK I will move it CMICmnStreamStdin with a different name. There is already a function with similar name throughout the hierarchy with different signature.

In D7746#126634, @ki.stfu wrote:

Looks good. What about further cleaning? We can clean CMICmnStreamStdin and remove MICmnStreamStdinLinux MICmnStreamStdinWindows classes. You want to do it in separate review?

Yes. As I said earlier, there is a lot of code to cleanup. But we should do it in steps.

tools/lldb-mi/MICmnStreamStdin.h

125–126

What benefits that gives us to use dynamic buffer?

tools/lldb-mi/MIDriver.cpp

968

I did it intentionally. Eclipse uses signal to stop the execution. It we print that command on the output, it makes eclipse switch view and show it in console which does not look nice. It is an internal details that we stopped the execution using -exec-interrupt command. We could have called the lldb API directly. So we should not be printing that information anyway.

1177–1179

Why is TextToStdout necessary? There are many small clean-up and fixes that can be done. But not all in one revision.

tools/lldb-mi/MIDriverMain.cpp

137

I did not understand. What should we remove?

tools/lldb-mi/MIDriverMgr.h

82

Ok I will add the name, not sure about the lldb-mi style. I think we should slowly move the codebase to look similar to lldb proper.

[abidh]

Add name of some function arguments.
Some smaller cleanup suggested in review.

[ki.stfu]

Fix lines 125-126 and 1,177-1,179 and feel free to commit.

tools/lldb-mi/MICmnStreamStdin.h

125–126

Very large buffers on stack may cause an segfault. But if dynamic memory fails it will throw bad_alloc exception (what is better :))

tools/lldb-mi/MIDriver.cpp

968

ok

1177–1179

Agree, but a cleaning of CMICmnStreamStdin class not affect to lldb-mi functionality unlike this case. Please fix it in this commit.

tools/lldb-mi/MIDriverMain.cpp

137

I meant CMICmnStreamStdin::SetCtrlCHit

tools/lldb-mi/MIDriverMgr.h

82

lldb-mi is too big. I'm not sure about it.

[zturner]

tools/lldb-mi/MICmnStreamStdin.h

125–126

Use dynamic buffer IMO. If your program is out of heap space good luck doing anything else anyway. Maybe this call doesn't fail by using stack, but the next call will. We just had this discussion with Greg the other day on lldb-dev, and we agreed that we should reduce the usage of stack buffers in LLDB as a whole. Performance of 1 heap allocation is not a concern, but using stack buffer reduces the amount of stack LLDB uses, and we don't know if it decides to do a deep recursion or something.

(BTW, if dynamic memory fails it won't throw bad_alloc exception, it will just terminate the program, because we compile with exceptions disabled. So whether it's here, or 5 lines of code later, doesn't really make a difference :)

[abidh]

In D7746#126707, @ki.stfu wrote:

Fix lines 125-126 and 1,177-1,179 and feel free to commit.

OK I have made the changes requested and committed it in 230003.

tools/lldb-mi/Driver.h

public:
     virtual bool GetDriverIsGDBMICompatibleDriver(void) const;
     virtual bool SetId(const CMIUtilString &vID);
     virtual const CMIUtilString &GetId(void) const;
     // From CMIDriverBase
     virtual bool DoFallThruToAnotherDriver(const CMIUtilString &vCmd, CMIUtilString &vwErrMsg);
     virtual bool SetDriverParent(const CMIDriverBase &vrOtherDriver);
     virtual const CMIUtilString &GetDriverName(void) const;
     virtual const CMIUtilString &GetDriverId(void) const;
+    virtual void DeliverSignal(int signal) {}
 
     // Original code:
   public:
     Driver();
 
     virtual ~Driver();
 
     void MainLoop();

tools/lldb-mi/MICmnStreamStdin.h

public:
     const CMIUtilString &GetPrompt(void) const;
     bool SetPrompt(const CMIUtilString &vNewPrompt);
     void SetEnablePrompt(const bool vbYes);
     bool GetEnablePrompt(void) const;
     void SetCtrlCHit(void);
     bool SetVisitor(IStreamStdin &vrVisitor);
     bool SetOSStdinHandler(IOSStdinHandler &vrHandler);
     void OnExitHandler(void);
+    const MIchar *ReadLine(CMIUtilString &vwErrMsg);
 
     // Overridden:
   public:
     // From CMIUtilThreadActiveObjBase
     virtual const CMIUtilString &ThreadGetName(void) const;
 
     // Overridden:
   protected:
     // From CMIUtilThreadActiveObjBase
     virtual bool ThreadRun(bool &vrIsAlive);
     virtual bool
     ThreadFinish(void); // Let this thread clean up after itself
 
     // Methods:
   private:
     /* ctor */ CMICmnStreamStdin(void);
     /* ctor */ CMICmnStreamStdin(const CMICmnStreamStdin &);
     void operator=(const CMICmnStreamStdin &);
 
     bool MonitorStdin(bool &vrwbYesExit);
-    const MIchar *ReadLine(CMIUtilString &vwErrMsg);
     bool
     InputAvailable(bool &vbAvail); // Bytes are available on stdin
 
     // Overridden:
   private:
     // From CMICmnBase
     /* dtor */ virtual ~CMICmnStreamStdin(void);
 
     // Attributes:
   private:
     const CMIUtilString m_constStrThisThreadname;
     IStreamStdin *m_pVisitor;
     CMIUtilString m_strPromptCurrent; // Command line prompt as shown to the user
     volatile bool m_bKeyCtrlCHit;     // True = User hit Ctrl-C, false = has not yet
     bool m_bShowPrompt;               // True = Yes prompt is shown/output to the user (stdout), false = no prompt
     bool m_bRedrawPrompt;             // True = Prompt needs to be redrawn
     IOSStdinHandler *m_pStdinReadHandler;
+    static const int m_constBufferSize = 2048;
+    char m_cmdBuffer[m_constBufferSize];
 };

tools/lldb-mi/MICmnStreamStdin.cpp

 #include "MIUtilSingletonHelper.h"
 #include "MIDriver.h"
 #if defined(_MSC_VER)
 #include "MIUtilSystemWindows.h"
 #include "MICmnStreamStdinWindows.h"
 #else
 #include "MICmnStreamStdinLinux.h"
 #endif // defined( _MSC_VER )
+#include <string.h> // For std::strerror()
 
 //++ ------------------------------------------------------------------------------------
 // Details: CMICmnStreamStdin constructor.
 // Type:    Method.
 // Args:    None.
 // Return:  None.
 // Throws:  None.
 //--

 // Type:    Method.
 // Args:    vwErrMsg    - (W) Empty string ok or error description.
 // Return:  MIchar * - text buffer pointer or NULL on failure.
 // Throws:  None.
 //--
 const MIchar *
 CMICmnStreamStdin::ReadLine(CMIUtilString &vwErrMsg)
 {
-    return m_pStdinReadHandler->ReadLine(vwErrMsg);
+    vwErrMsg.clear();
+
+    // Read user input
+    const MIchar *pText = ::fgets(&m_cmdBuffer[0], m_constBufferSize, stdin);
+    if (pText == nullptr)
+    {
+        if (::ferror(stdin) != 0)
+            vwErrMsg = ::strerror(errno);
+        return nullptr;
+    }
+
+    // Strip off new line characters
+    for (MIchar *pI = m_cmdBuffer; *pI != '\0'; pI++)
+    {
+        if ((*pI == '\n') || (*pI == '\r'))
+        {
+            *pI = '\0';
+            break;
+        }
+    }
+
+    return pText;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Inform *this stream that the user hit Control-C key to exit.
 //          The function is normally called by the SIGINT signal in sigint_handler() to
 //          simulate kill app from the client.
 //          This function is called by a Kernel thread.
 // Type:    Method.

tools/lldb-mi/MIDriver.h

 //          another driver object registered with the Driver Manager.
 // Gotchas: None.
 // Authors: Illya Rudkin 29/01/2014.
 // Changes: None.
 //--
 class CMIDriver : public CMICmnBase,
                   public CMIDriverMgr::IDriver,
                   public CMIDriverBase,
-                  public CMICmnStreamStdin::IStreamStdin,
                   public MI::ISingleton<CMIDriver>
 {
     friend class MI::ISingleton<CMIDriver>;
 
     // Enumerations:
   public:
     //++ ----------------------------------------------------------------------
     // Details: The MI Driver has a running state which is used to help determin
public:
     const CMIUtilString &GetAppNameShort(void) const;
     const CMIUtilString &GetAppNameLong(void) const;
     const CMIUtilString &GetVersionDescription(void) const;
 
     // MI do work
     bool WriteMessageToLog(const CMIUtilString &vMessage);
     bool SetEnableFallThru(const bool vbYes);
     bool GetEnableFallThru(void) const;
-    bool InjectMICommand(const CMIUtilString &vMICmd);
     bool HaveExecutableFileNamePathOnCmdLine(void) const;
     const CMIUtilString &GetExecutableFileNamePathOnCmdLine(void) const;
 
     // Overridden:
   public:
     // From CMIDriverMgr::IDriver
     virtual bool DoInitialize(void);
     virtual bool DoShutdown(void);
public:
     virtual void SetExitApplicationFlag(const bool vbForceExit);
     virtual bool DoFallThruToAnotherDriver(const CMIUtilString &vCmd, CMIUtilString &vwErrMsg);
     virtual bool SetDriverToFallThruTo(const CMIDriverBase &vrOtherDriver);
     virtual FILE *GetStdin(void) const;
     virtual FILE *GetStdout(void) const;
     virtual FILE *GetStderr(void) const;
     virtual const CMIUtilString &GetDriverName(void) const;
     virtual const CMIUtilString &GetDriverId(void) const;
-    // From CMICmnStreamStdin
-    virtual bool ReadLine(const CMIUtilString &vStdInBuffer, bool &vrbYesExit);
+    virtual void DeliverSignal(int signal);
 
     // Typedefs:
   private:
     typedef std::queue<CMIUtilString> QueueStdinLine_t;
 
     // Methods:
   private:
     /* ctor */ CMIDriver(void);
     /* ctor */ CMIDriver(const CMIDriver &);
     void operator=(const CMIDriver &);
 
     lldb::SBError ParseArgs(const int argc, const char *argv[], FILE *vpStdOut, bool &vwbExiting);
-    bool ReadStdinLineQueue(void);
     bool DoAppQuit(void);
     bool InterpretCommand(const CMIUtilString &vTextLine);
     bool InterpretCommandThisDriver(const CMIUtilString &vTextLine, bool &vwbCmdYesValid);
     bool InterpretCommandFallThruDriver(const CMIUtilString &vTextLine, bool &vwbCmdYesValid);
     bool ExecuteCommand(const SMICmdData &vCmdData);
     bool StartWorkerThreads(void);
     bool StopWorkerThreads(void);
     bool InitClientIDEToMIDriver(void) const;
     bool InitClientIDEEclipse(void) const;
-    bool QueueMICommand(const CMIUtilString &vMICmd);
     bool LocalDebugSessionStartupInjectCommands(void);
 
     // Overridden:
   private:
     // From CMICmnBase
     /* dtor */ virtual ~CMIDriver(void);
 
     // Attributes:
   private:
     static const CMIUtilString ms_constAppNameShort;
     static const CMIUtilString ms_constAppNameLong;
     static const CMIUtilString ms_constMIVersion;
     //
     bool m_bFallThruToOtherDriverEnabled; // True = yes fall through, false = do not pass on command
     CMIUtilThreadMutex m_threadMutex;
-    QueueStdinLine_t m_queueStdinLine; // Producer = stdin monitor, consumer = *this driver
     bool m_bDriverIsExiting;           // True = yes, driver told to quit, false = continue working
     void *m_handleMainThread;          // *this driver is run by the main thread
     CMICmnStreamStdin &m_rStdin;
     CMICmnLLDBDebugger &m_rLldbDebugger;
     CMICmnStreamStdout &m_rStdOut;
     DriverState_e m_eCurrentDriverState;
     bool m_bHaveExecutableFileNamePathOnCmdLine; // True = Yes executable given as one of the parameters to the MI Driver, false = not found
     CMIUtilString m_strCmdLineArgExecuteableFileNamePath;
     bool m_bDriverDebuggingArgExecutable; // True = The MI Driver (MI mode) is debugging executable passed as argument, false = running via
                                           // a client i.e Eclipse
 };

tools/lldb-mi/MIDriver.cpp

 //--
 bool
 CMIDriver::GetDriverIsGDBMICompatibleDriver(void) const
 {
     return true;
 }
 
 //++ ------------------------------------------------------------------------------------
-// Details: Callback function for monitoring stream stdin object. Part of the visitor
-//          pattern.
-//          This function is called by the CMICmnStreamStdin::CThreadStdin
-//          "stdin monitor" thread (ID).
-// Type:    Overridden.
-// Args:    vStdInBuffer    - (R) Copy of the current stdin line data.
-//          vrbYesExit      - (RW) True = yes exit stdin monitoring, false = continue monitor.
-// Return:  MIstatus::success - Functional succeeded.
-//          MIstatus::failure - Functional failed.
-// Throws:  None.
-//--
-bool
-CMIDriver::ReadLine(const CMIUtilString &vStdInBuffer, bool &vrwbYesExit)
-{
-    // For debugging. Update prompt show stdin is working
-    // printf( "%s\n", vStdInBuffer.c_str() );
-    // fflush( stdout );
-
-    // Special case look for the quit command here so stop monitoring stdin stream
-    // So we do not go back to fgetc() and wait and hang thread on exit
-    if (vStdInBuffer == "quit")
-        vrwbYesExit = true;
-
-    // 1. Put new line in the queue container by stdin monitor thread
-    // 2. Then *this driver calls ReadStdinLineQueue() when ready to read the queue in its
-    // own thread
-    const bool bOk = QueueMICommand(vStdInBuffer);
-
-    // Check to see if the *this driver is shutting down (exit application)
-    if (!vrwbYesExit)
-        vrwbYesExit = m_bDriverIsExiting;
-
-    return bOk;
-}
-
-//++ ------------------------------------------------------------------------------------
 // Details: Start worker threads for the driver.
 // Type:    Method.
 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMIDriver::StartWorkerThreads(void)
 {
     bool bOk = MIstatus::success;
 
     // Grab the thread manager
     CMICmnThreadMgrStd &rThreadMgr = CMICmnThreadMgrStd::Instance();
 
-    // Start the stdin thread
-    bOk &= m_rStdin.SetVisitor(*this);
-    if (bOk && !rThreadMgr.ThreadStart<CMICmnStreamStdin>(m_rStdin))
-    {
-        const CMIUtilString errMsg = CMIUtilString::Format(MIRSRC(IDS_THREADMGR_ERR_THREAD_FAIL_CREATE),
-                                                           CMICmnThreadMgrStd::Instance().GetErrorDescription().c_str());
-        SetErrorDescriptionn(errMsg);
-        return MIstatus::failure;
-    }
-
     // Start the event polling thread
     if (bOk && !rThreadMgr.ThreadStart<CMICmnLLDBDebugger>(m_rLldbDebugger))
     {
         const CMIUtilString errMsg = CMIUtilString::Format(MIRSRC(IDS_THREADMGR_ERR_THREAD_FAIL_CREATE),
                                                            CMICmnThreadMgrStd::Instance().GetErrorDescription().c_str());
         SetErrorDescriptionn(errMsg);
         return MIstatus::failure;
     }

 
 //++ ------------------------------------------------------------------------------------
 // Details: Call this function puts *this driver to work.
 //          This function is used by the application's main thread.
 // Type:    Overridden.
 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMIDriver::DoMainLoop(void)
 {
     if (!InitClientIDEToMIDriver()) // Init Eclipse IDE
     {
         SetErrorDescriptionn(MIRSRC(IDS_MI_INIT_ERR_CLIENT_USING_DRIVER));
         return MIstatus::failure;
     }
 
     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 (!LocalDebugSessionStartupInjectCommands())
         {
             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)
     {
-        // Poll stdin queue and dispatch
-        if (!ReadStdinLineQueue())
+        CMIUtilString errorText;
+        const MIchar *pCmd = m_rStdin.ReadLine (errorText);
+        if (pCmd != nullptr)
         {
-            // Something went wrong
-            break;
-        }
-    }
-
-    // Signal that the application is shutting down
-    DoAppQuit();
-
-    // Close and wait for the workers to stop
-    StopWorkerThreads();
-
-    // Ensure that a new line is sent as the last act of the dying driver
-    m_rStdOut.WriteMIResponse("\n", false);
-
-    return MIstatus::success;
-}
-
-//++ ------------------------------------------------------------------------------------
-// Details: *this driver sits and waits for input to the stdin line queue shared by *this
-//          driver and the stdin monitor thread, it queues, *this reads, interprets and
-//          reacts.
-//          This function is used by the application's main thread.
-// Type:    Method.
-// Args:    None.
-// Return:  MIstatus::success - Functional succeeded.
-//          MIstatus::failure - Functional failed.
-// Throws:  None.
-//--
-bool
-CMIDriver::ReadStdinLineQueue(void)
-{
-    // True when queue contains input
-    bool bHaveInput = false;
-
-    // Stores the current input line
-    CMIUtilString lineText;
-    {
-        // Lock while we access the queue
-        CMIUtilThreadLock lock(m_threadMutex);
-        if (!m_queueStdinLine.empty())
-        {
-            lineText = m_queueStdinLine.front();
-            m_queueStdinLine.pop();
-            bHaveInput = !lineText.empty();
-        }
-    }
-
-    // Process while we have input
-    if (bHaveInput)
+            CMIUtilString lineText(pCmd);
+            if (!lineText.empty ())
             {
                 if (lineText == "quit")
                 {
                     // We want to be exiting when receiving a quit command
                     m_bExitApp = true;
-            return MIstatus::success;
+                    break;
                 }
 
-        // Process the command
                 bool bOk = false;
                 {
                     // Lock Mutex before processing commands so that we don't disturb an event
-            // that is being processed.
+                    // being processed
                     CMIUtilThreadLock lock(CMICmnLLDBDebugSessionInfo::Instance().GetSessionMutex());
                     bOk = InterpretCommand(lineText);
                 }
-
                 // Draw prompt if desired
                 if (bOk && m_rStdin.GetEnablePrompt())
                     m_rStdOut.WriteMIResponse(m_rStdin.GetPrompt());
-
-        // Input has been processed
-        bHaveInput = false;
             }
-    else
-    {
-        // Give resources back to the OS
-        const std::chrono::milliseconds time(1);
-        std::this_thread::sleep_for(time);
         }
+    }
+
+    // Signal that the application is shutting down
+    DoAppQuit();
+
+    // Close and wait for the workers to stop
+    StopWorkerThreads();
+
+    // Ensure that a new line is sent as the last act of the dying driver
+    m_rStdOut.WriteMIResponse("\n", false);
 
     return MIstatus::success;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Set things in motion, set state etc that brings *this driver (and the
 //          application) to a tidy shutdown.
 //          This function is used by the application's main thread.

 //--
 const CMIUtilString &
 CMIDriver::GetId(void) const
 {
     return m_strDriverId;
 }
 
 //++ ------------------------------------------------------------------------------------
-// Details: Inject a command into the command processing system to be interpreted as a
-//          command read from stdin. The text representing the command is also written
-//          out to stdout as the command did not come from via stdin.
-// Type:    Method.
-// Args:    vMICmd  - (R) Text data representing a possible command.
-// Return:  MIstatus::success - Functional succeeded.
-//          MIstatus::failure - Functional failed.
-// Throws:  None.
-//--
-bool
-CMIDriver::InjectMICommand(const CMIUtilString &vMICmd)
-{
-    const bool bOk = m_rStdOut.WriteMIResponse(vMICmd);
-
-    return bOk && QueueMICommand(vMICmd);
-}
-
-//++ ------------------------------------------------------------------------------------
-// Details: Add a new command candidate to the command queue to be processed by the
-//          command system.
-// Type:    Method.
-// Args:    vMICmd  - (R) Text data representing a possible command.
-// Return:  MIstatus::success - Functional succeeded.
-//          MIstatus::failure - Functional failed.
-// Throws:  None.
-//--
-bool
-CMIDriver::QueueMICommand(const CMIUtilString &vMICmd)
-{
-    CMIUtilThreadLock lock(m_threadMutex);
-    m_queueStdinLine.push(vMICmd);
-
-    return MIstatus::success;
-}
-
-//++ ------------------------------------------------------------------------------------
 // Details: Interpret the text data and match against current commands to see if there
 //          is a match. If a match then the command is issued and actioned on. The
 //          text data if not understood by *this driver is past on to the Fall Thru
 //          driver.
 //          This function is used by the application's main thread.
 // Type:    Method.
 // Args:    vTextLine   - (R) Text data representing a possible command.
 // Return:  MIstatus::success - Functional succeeded.
CMIDriver::SetExitApplicationFlag(const bool vbForceExit)
     }
 
     // CODETAG_DEBUG_SESSION_RUNNING_PROG_RECEIVED_SIGINT_PAUSE_PROGRAM
     // Did we receive a SIGINT from the client during a running debug program, if
     // so then SIGINT is not to be taken as meaning kill the MI driver application
     // but halt the inferior program being debugged instead
     if (m_eCurrentDriverState == eDriverState_RunningDebugging)
     {
-        InjectMICommand("-exec-interrupt");
+        InterpretCommand("-exec-interrupt");
         return;
     }
 
     m_bExitApp = true;
     m_rStdin.OnExitHandler();
 }
 
 //++ ------------------------------------------------------------------------------------

 // Args:    None.
 // Return:  MIstatus::success - Functionality succeeded.
 //          MIstatus::failure - Functionality failed.
 // Throws:  None.
 //--
 bool
 CMIDriver::LocalDebugSessionStartupInjectCommands(void)
 {
-    const CMIUtilString strCmd(CMIUtilString::Format("-file-exec-and-symbols %s", m_strCmdLineArgExecuteableFileNamePath.c_str()));
+    const CMIUtilString strCmd(CMIUtilString::Format("-file-exec-and-symbols \"%s\"", m_strCmdLineArgExecuteableFileNamePath.c_str()));
 
-    return InjectMICommand(strCmd);
+    return InterpretCommand(strCmd);
 }
 
 //++ ------------------------------------------------------------------------------------
 // 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.

 // Return:  None.
 // Throws:  None.
 //--
 bool
 CMIDriver::IsDriverDebuggingArgExecutable(void) const
 {
     return m_bDriverDebuggingArgExecutable;
 }
+
+//++ ------------------------------------------------------------------------------------
+// Details: Gets called when lldb-mi gets a signal. Stops the process if it was SIGINT.
+//
+// Type:    Method.
+// Args:    signal that was delivered
+// Return:  None.
+// Throws:  None.
+//--
+void
+CMIDriver::DeliverSignal(int signal)
+{
+    if (signal == SIGINT && (m_eCurrentDriverState == eDriverState_RunningDebugging))
+        InterpretCommand("-exec-interrupt");
+}

tools/lldb-mi/MIDriverMain.cpp

if (pDebugger != nullptr)
             g_interrupt_sent = true;
             pDebugger->DispatchInputInterrupt();
             g_interrupt_sent = false;
         }
     }
 
     CMICmnLog::Instance().WriteLog(CMIUtilString::Format(MIRSRC(IDS_PROCESS_SIGNAL_RECEIVED), "SIGINT", vSigno));
 
-    // CODETAG_DEBUG_SESSION_RUNNING_PROG_RECEIVED_SIGINT_PAUSE_PROGRAM
-    // Signal MI to shutdown or halt a running debug session
-    CMICmnStreamStdin::Instance().SetCtrlCHit();
+    // 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
#endif
     lldb::SBDebugger *pDebugger = rDriverMgr.DriverGetTheDebugger();
     if (pDebugger != nullptr)
     {
         pDebugger->SaveInputTerminalState();
     }
 
     CMICmnLog::Instance().WriteLog(CMIUtilString::Format(MIRSRC(IDS_PROCESS_SIGNAL_RECEIVED), "SIGTSTP", vSigno));
 
-    // Signal MI to shutdown
-    CMICmnStreamStdin::Instance().SetCtrlCHit();
+    // 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.
#endif
     lldb::SBDebugger *pDebugger = rDriverMgr.DriverGetTheDebugger();
     if (pDebugger != nullptr)
     {
         pDebugger->RestoreInputTerminalState();
     }
 
     CMICmnLog::Instance().WriteLog(CMIUtilString::Format(MIRSRC(IDS_PROCESS_SIGNAL_RECEIVED), "SIGCONT", vSigno));
 
-    // Signal MI to shutdown
-    CMICmnStreamStdin::Instance().SetCtrlCHit();
+    // 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.

tools/lldb-mi/MIDriverMgr.h

class IDriver
         virtual void DoResizeWindow(const uint32_t vWindowSizeWsCol) = 0;
         virtual lldb::SBError DoParseArgs(const int argc, const char *argv[], FILE *vpStdOut, bool &vwbExiting) = 0;
         virtual CMIUtilString GetError(void) const = 0;
         virtual const CMIUtilString &GetName(void) const = 0;
         virtual lldb::SBDebugger &GetTheDebugger(void) = 0;
         virtual bool GetDriverIsGDBMICompatibleDriver(void) const = 0;
         virtual bool SetId(const CMIUtilString &vId) = 0;
         virtual const CMIUtilString &GetId(void) const = 0;
+        virtual void DeliverSignal(int signal) = 0;
 
         // Not part of the interface, ignore
         /* dtor */ virtual ~IDriver(void) {}
     };
 
     // Methods:
   public:
     // MI system
public:
     //
     // MI Proxy fn to current specified working driver
     bool DriverMainLoop(void);
     void DriverResizeWindow(const uint32_t vWindowSizeWsCol);
     bool DriverParseArgs(const int argc, const char *argv[], FILE *vpStdOut, bool &vwbExiting);
     CMIUtilString DriverGetError(void) const;
     CMIUtilString DriverGetName(void) const;
     lldb::SBDebugger *DriverGetTheDebugger(void);
+    void DeliverSignal(int signal);
 
     // Typedef:
   private:
     typedef std::map<CMIUtilString, IDriver *> MapDriverIdToDriver_t;
     typedef std::pair<CMIUtilString, IDriver *> MapPairDriverIdToDriver_t;
 
     // Methods:
   private:

tools/lldb-mi/MIDriverMgr.cpp

CMIDriverMgr::GetDriver(const CMIUtilString &vrDriverId) const
     MapDriverIdToDriver_t::const_iterator it = m_mapDriverIdToDriver.find(vrDriverId);
     if (it == m_mapDriverIdToDriver.end())
         return nullptr;
 
     IDriver *pDriver = (*it).second;
 
     return pDriver;
 }
+
+
+//++ ------------------------------------------------------------------------------------
+// Details: Gets called when lldb-mi gets a signal. Passed signal to current driver.
+//
+// Type:    Method.
+// Args:    signal that was delivered
+// Return:  None.
+// Throws:  None.
+//--
+void
+CMIDriverMgr::DeliverSignal(int signal)
+{
+    if (m_pDriverCurrent != nullptr)
+        m_pDriverCurrent->DeliverSignal(signal);
+}