Improve LLDB prompt handling

[labath]

Summary

There is an issue in lldb where the command prompt can appear at the wrong time. The partial fix
we have in for this is not working all the time and is introducing unnecessary delays. This
change does:

• Change Process:SyncIOHandler to use integer start id's for synchronization to avoid it being confused by quick start-stop cycles. I picked this up from a suggested patch by Greg to lldb-dev.
• coordinates printing of asynchronous text with the iohandlers. This is also based on a (different) Greg's patch, but I have added stronger synchronization to it to avoid races.

Together, these changes solve the prompt problem for me on linux (both with and without libedit).
I think they should behave similarly on Mac and FreeBSD and I think they will not make matters
worse for windows.

[emaste]

Unfortunately I still get the prompt at the wrong time with the patch:

feynman% bin/lldb /bin/ls
(lldb) target create "/bin/ls"
Current executable set to '/bin/ls' (x86_64).
(lldb) b main
Breakpoint 1: where = ls`main + 33 at ls.c:163, address = 0x00000000004023f1
(lldb) run
Process 80336 launching
Process 80336 launched: '/bin/ls' (x86_64)
(lldb) Process 80336 stopped
* thread #1: tid = 103527, 0x00000000004023f1 ls`main(argc=1, argv=0x00007fffffffe3d0) + 33 at ls.c:163, stop reason = breakpoint 1.1
    frame #0: 0x00000000004023f1 ls`main(argc=1, argv=0x00007fffffffe3d0) + 33 at ls.c:163
   160  #ifdef COLORLS
   161          char termcapbuf[1024];  /* termcap definition buffer */
   162          char tcapbuf[512];      /* capability buffer */
-> 163          char *bp = tcapbuf;
   164  #endif
   165 
   166          (void)setlocale(LC_ALL, "");

[labath]

dang. :(

Do you compile your LLDB with libedit support?

[emaste]

In D9823#174229, @labath wrote:

dang. :(

Do you compile your LLDB with libedit support?

Yes - I can try it without as well if you like, but I just noticed something.

I have seen prompt issues at different points in the debugee lifecycle in the past, and perhaps they are separate issues. There's the one I pasted above, where the prompt comes out between launched and stopped, and one where the prompt is emitted at the wrong time when stepping, stopping at breakpoints, etc. I haven't been able to reproduce the second case with this patch, only the one at startup.

Thus, I think it might be that this solves the hard part of the problem (with thread races). The remaining issue may well be different, and it feels like it will be fairly straightforward (and independent of libedit support).

[labath]

Oops. I see what's the problem now. I have accidentally committed a line which hard-disables libedit (I used it for testing). I have put up a new version of this patch. Could you test this one please. I have been mostly focusing on the libedit case and I hope this one is nailed.

Getting the output right without libedit is harder. With libedit, I just erase the command line when I want to output text and then redraw it. Redrawing the prompt could be done i guess (not sure if it's windows-compatible though), but redrawing the user-entered text is hard. That's why I don't try to do that now and instead rely on the improved SyncIOHandler trick to make sure the prompt doesn't get drawn in the first place. It seems that is not working for some reason. The new version of this also includes a bunch of new logging statements. Could you also try this out without libedit once again with enabled logging ("log enable -f lldb.log lldb process") and send me the file. We need to figure out why SyncIOHandler is failing.

thanks,
pl

source/Commands/CommandObjectProcess.cpp

273

This should block until we install the process handler.

source/Core/IOHandler.cpp

390

Oops.

source/Target/Process.cpp

4445

This should install the process handler.

[labath]

• Add missing line.
• Add logging statements

[emaste]

Indeed, this appears to be fixed for me with libedit.

[emaste]

Log for the non-libedit failing case is here:
https://people.freebsd.org/~emaste/lldb/no-libedit-prompt-issue.log

created as follows:

feynman% bin/lldb /bin/ls
(lldb) target create "/bin/ls"
Current executable set to '/bin/ls' (x86_64).
(lldb) log enable -f no-libedit-prompt-issue.log lldb process
(lldb) b main
Breakpoint 1: where = ls`main + 33 at ls.c:163, address = 0x00000000004023f1
(lldb) run
Process 87568 launching
Process 87568 launched: '/bin/ls' (x86_64)
(lldb) Process 87568 stopped
* thread #1: tid = 104753, 0x00000000004023f1 ls`main(argc=1, argv=0x00007fffffffe588) + 33 at ls.c:163, stop reason = breakpoint 1.1
    frame #0: 0x00000000004023f1 ls`main(argc=1, argv=0x00007fffffffe588) + 33 at ls.c:163
   160  #ifdef COLORLS
   161          char termcapbuf[1024];  /* termcap definition buffer */
   162          char tcapbuf[512];      /* capability buffer */
-> 163          char *bp = tcapbuf;
   164  #endif
   165 
   166          (void)setlocale(LC_ALL, "");
quit
Quitting LLDB will kill one or more processes. Do you really want to proceed: [Y/n] y
feynman%

[clayborg]

Looks mostly good. See my inline comments so we can avoid calling Activate() and calling Deactivate() on IOHandlers in the push and pop functions. Our Debugger::ExecuteIOHandlers() should handle those for us and Debugger::ExecuteIOHandlers() will do it at the right time.

source/Core/Debugger.cpp

1041

We shouldn't have to call Activate() here. Once the top IOHandler exits it's Run() function, the Debugger::ExecuteIOHandlers() will call it for us. See the code below:

void
Debugger::ExecuteIOHandlers()
{
    
    while (1)
    {
        IOHandlerSP reader_sp(m_input_reader_stack.Top());
        if (!reader_sp)
            break;

        reader_sp->Activate();
        reader_sp->Run();
        reader_sp->Deactivate();

        // Remove all input readers that are done from the top of the stack
        while (1)
        {
            IOHandlerSP top_reader_sp = m_input_reader_stack.Top();
            if (top_reader_sp && top_reader_sp->GetIsDone())
                m_input_reader_stack.Pop();
            else
                break;
        }
    }
    ClearIOHandlers();
}

1046–1049

We should probably just call Cancel and don't call Deactivate(). The Debugger::ExecuteIOHandlers() will deactivate the top IOHandler when it exits Run().

[labath]

• Don't bump sync var when state is launching

[labath]

Thanks for all the help Ed. The log file has helped me to trace the problem to the handling of the eStateLaunching state (which I guess is not used on linux). I have put up an updated version of this patch. Could you give it one more go?

[emaste]

This now works on FreeBSD with and without libedit.

source/Target/Process.cpp

4445

Oops!

[ribrdb]

source/Target/Process.cpp

5262

TSAN shows a race here, because m_process_input_reader.reset() is not atomic and is called from a different thread.
This shows up in Process::Destroy(), so maybe that's a separate issue from what you're trying to fix with this change.

[labath]

source/Core/Debugger.cpp

1041

Note that I have removed the Activate/Deactivate calls from ExecuteIOHandlers. A more detailed explanation is below.

1046–1049

It's not clear to me what is the main purpose of the Activate/Deactivate functions. For example, for IOHandlerEditline, Deactivate() simply clears the m_active flag. IOHandlerEditline::Run() contains a while(m_active) { ... } loop. Therefore, it makes no sense to call Deactivate after Run() has exited, since the flag will be cleared at that point anyway. In fact, we have to (and we did) call Deactivate during pushing/popping to make sure that the Run function exits. I have moved the activation function here for symmetry. If you think they should be called from ExecuteIOHandlers, I can put them there, but then I will need to change the Cancel() function and have it clear the m_active flag also. What do you think?

source/Target/Process.cpp

5262

Thanks. This looks like a separate issue, so I will not fix it now, but I will definitely keep it in mind for the future. I have noticed a number of tsan issues in lldb during teardown and I would like to weed them out.

[labath]

Friendly ping. :)

Greg, I need your opinion on the position of the Activate() calls (RunIOHandlers vs. Push/PopIOHandler).
The current implementation cannot be in RunIOHandlers as "m_active = true" in Activate() is racing with the Deactivate() in PopIOHandler. If Activate() happens after Deactivate(), the editline handler will get stuck in the Run() loop and the cancelation attempt will fail. Putting it in PushIOHandler avoids this as these are serialized by the input reader stack mutex. If we want the activation logic to be in RunIOHandlers, we will need to change the cancelation logic to make sure it does not race. What do you think?

[clayborg]

Lets try what you have an iterate on that. You seem to have it working well enough for your current needs. It would be great to get rid of SyncIOHandler eventually, but this improved version should be good for a first patch.

I question if we really need activate and deactivate at all. We should probably remove these if they cause problems and only allow the IOHandler::Run() to be the sole function. Then we can use Interrupt() or Cancel() when needed.

[labath]

I've committed this, and the buildbots seem to like it. I completely agree with you on the Activate/Deactivate issue and I will try to rig up a separate change to remove them.

include/lldb/Core/Debugger.h

public:
     
     // Synchronously run an input reader until it is done
     void
     RunIOHandler (const lldb::IOHandlerSP& reader_sp);
     
     bool
     IsTopIOHandler (const lldb::IOHandlerSP& reader_sp);
 
+    void
+    PrintAsync (const char *s, size_t len, bool is_stdout);
+
     ConstString
     GetTopIOHandlerControlSequence(char ch);
 
     const char *
     GetIOHandlerCommandPrefix();
 
     const char *
     GetIOHandlerHelpPrologue();
 
-    bool
-    HideTopIOHandler();
-
-    void
-    RefreshTopIOHandler();
-
     static lldb::DebuggerSP
     FindDebuggerWithID (lldb::user_id_t id);
     
     static lldb::DebuggerSP
     FindDebuggerWithInstanceName (const ConstString &instance_name);
     
     static size_t
     GetNumDebuggers();

include/lldb/Core/IOHandler.h

public:
         ~IOHandler ();
 
         // Each IOHandler gets to run until it is done. It should read data
         // from the "in" and place output into "out" and "err and return
         // when done.
         virtual void
         Run () = 0;
 
-        // Hide any characters that have been displayed so far so async
-        // output can be displayed. Refresh() will be called after the
-        // output has been displayed.
-        virtual void
-        Hide () = 0;
-        
-        // Called when the async output has been received in order to update
-        // the input reader (refresh the prompt and redisplay any current
-        // line(s) that are being edited
-        virtual void
-        Refresh () = 0;
-
         // Called when an input reader should relinquish its control so another
         // can be pushed onto the IO handler stack, or so the current IO
         // handler can pop itself off the stack
 
         virtual void
         Cancel () = 0;
 
         // Called when CTRL+C is pressed which usually causes
public:
         bool
         GetIsRealTerminal ();
         
         void
         SetPopped (bool b);
         
         void
         WaitForPop ();
-        
+        virtual void
+        PrintAsync (Stream *stream, const char *s, size_t len)
+        {
+            stream->Write (s, len);
+            stream->Flush();
+        }
+
     protected:
         Debugger &m_debugger;
         lldb::StreamFileSP m_input_sp;
         lldb::StreamFileSP m_output_sp;
         lldb::StreamFileSP m_error_sp;
         Predicate<bool> m_popped;
         Flags m_flags;
         Type m_type;
public:
         {
         }
         
         virtual
         ~IOHandlerDelegateMultiline ()
         {
         }
         
-        virtual ConstString
-        IOHandlerGetControlSequence (char ch)
+        ConstString
+        IOHandlerGetControlSequence (char ch) override
         {
             if (ch == 'd')
                 return ConstString (m_end_line + "\n");
             return ConstString();
         }
 
-        virtual bool
+        bool
         IOHandlerIsInputComplete (IOHandler &io_handler,
-                                  StringList &lines)
+                                  StringList &lines) override
         {
             // Determine whether the end of input signal has been entered
             const size_t num_lines = lines.GetSize();
             if (num_lines > 0 && lines[num_lines - 1] == m_end_line)
             {
                 // Remove the terminal line from "lines" so it doesn't appear in
                 // the resulting input and return true to indicate we are done
                 // getting lines
public:
                            bool multi_line,
                            bool color_prompts,
                            uint32_t line_number_start, // If non-zero show line numbers starting at 'line_number_start'
                            IOHandlerDelegate &delegate);
         
         virtual
         ~IOHandlerEditline ();
         
-        virtual void
-        Run ();
-        
-        virtual void
-        Hide ();
-
-        virtual void
-        Refresh ();
+        void
+        Run () override;
         
-        virtual void
-        Cancel ();
+        void
+        Cancel () override;
 
-        virtual bool
-        Interrupt ();
+        bool
+        Interrupt () override;
         
-        virtual void
-        GotEOF();
+        void
+        GotEOF() override;
         
-        virtual void
-        Activate ();
+        void
+        Activate () override;
 
-        virtual void
-        Deactivate ();
+        void
+        Deactivate () override;
 
-        virtual ConstString
-        GetControlSequence (char ch)
+        ConstString
+        GetControlSequence (char ch) override
         {
             return m_delegate.IOHandlerGetControlSequence (ch);
         }
 
-        virtual const char *
-        GetCommandPrefix ()
+        const char *
+        GetCommandPrefix () override
         {
             return m_delegate.IOHandlerGetCommandPrefix ();
         }
 
-        virtual const char *
-        GetHelpPrologue ()
+        const char *
+        GetHelpPrologue () override
         {
             return m_delegate.IOHandlerGetHelpPrologue ();
         }
 
-        virtual const char *
-        GetPrompt ();
+        const char *
+        GetPrompt () override;
         
-        virtual bool
-        SetPrompt (const char *prompt);
+        bool
+        SetPrompt (const char *prompt) override;
         
         const char *
         GetContinuationPrompt ();
         
         void
         SetContinuationPrompt (const char *prompt);
         
         bool
public:
         GetCurrentLines () const
         {
             return m_current_lines_ptr;
         }
         
         uint32_t
         GetCurrentLineIndex () const;
 
+        void
+        PrintAsync (Stream *stream, const char *s, size_t len) override;
+
     private:
 #ifndef LLDB_DISABLE_LIBEDIT
         static bool
         IsInputCompleteCallback (Editline *editline,
                                  StringList &lines,
                                  void *baton);
         
         static int
public:
         ~IOHandlerConfirm ();
                 
         bool
         GetResponse () const
         {
             return m_user_response;
         }
         
-        virtual int
+        int
         IOHandlerComplete (IOHandler &io_handler,
                            const char *current_line,
                            const char *cursor,
                            const char *last_char,
                            int skip_first_n_matches,
                            int max_matches,
-                           StringList &matches);
+                           StringList &matches) override;
         
-        virtual void
-        IOHandlerInputComplete (IOHandler &io_handler, std::string &data);
+        void
+        IOHandlerInputComplete (IOHandler &io_handler, std::string &data) override;
 
     protected:
         const bool m_default_response;
         bool m_user_response;
     };
 
     class IOHandlerCursesGUI :
         public IOHandler
     {
     public:
         IOHandlerCursesGUI (Debugger &debugger);
         
-        virtual
-        ~IOHandlerCursesGUI ();
-        
-        virtual void
-        Run ();
-        
-        virtual void
-        Hide ();
+        ~IOHandlerCursesGUI () override;
         
-        virtual void
-        Refresh ();
+        void
+        Run () override;
         
-        virtual void
-        Cancel ();
+        void
+        Cancel () override;
 
-        virtual bool
-        Interrupt ();
+        bool
+        Interrupt () override;
         
-        virtual void
-        GotEOF();
+        void
+        GotEOF() override;
         
-        virtual void
-        Activate ();
+        void
+        Activate () override;
         
-        virtual void
-        Deactivate ();
+        void
+        Deactivate () override;
 
     protected:
         curses::ApplicationAP m_app_ap;
     };
 
     class IOHandlerCursesValueObjectList :
         public IOHandler
     {
     public:
         IOHandlerCursesValueObjectList (Debugger &debugger, ValueObjectList &valobj_list);
         
         virtual
         ~IOHandlerCursesValueObjectList ();
         
-        virtual void
-        Run ();
-        
-        virtual void
-        Hide ();
-        
-        virtual void
-        Refresh ();
-        
-        virtual bool
-        HandleInterrupt ();
+        void
+        Run () override;
         
-        virtual void
-        GotEOF();
+        void
+        GotEOF() override;
     protected:
         ValueObjectList m_valobj_list;
     };
 
     class IOHandlerStack
     {
     public:
         
public:
         const char *
         GetTopIOHandlerHelpPrologue()
         {
             if (m_top)
                 return m_top->GetHelpPrologue();
             return NULL;
         }
 
-    protected:        
+        void
+        PrintAsync (Stream *stream, const char *s, size_t len);
+
+    protected:
         
         typedef std::vector<lldb::IOHandlerSP> collection;
         collection m_stack;
         mutable Mutex m_mutex;
         IOHandler *m_top;
         
     private:
         
         DISALLOW_COPY_AND_ASSIGN (IOHandlerStack);
     };
 
 } // namespace lldb_private
 
 #endif // #ifndef liblldb_IOHandler_h_

include/lldb/Core/StreamAsynchronousIO.h

 #include "lldb/Core/Stream.h"
 
 namespace lldb_private {
 
 class StreamAsynchronousIO : 
     public Stream
 {
 public:
-    StreamAsynchronousIO (Broadcaster &broadcaster, uint32_t broadcast_event_type);
+    StreamAsynchronousIO (Debugger &debugger, bool for_stdout);
     
     virtual ~StreamAsynchronousIO ();
     
     virtual void
     Flush ();
     
     virtual size_t
     Write (const void *src, size_t src_len);
     
     
 private:
-    Broadcaster &m_broadcaster;
-    uint32_t m_broadcast_event_type;
-    std::string m_accumulated_data;
+    Debugger &m_debugger;
+    std::string m_data;
+    bool m_for_stdout;
 };
 
 } // namespace lldb_private
 #endif // #ifndef liblldb_StreamAsynchronousIO_h

include/lldb/Host/Editline.h

public:
         /// Returns the prompt established by SetPrompt()
         const char *
         GetPrompt();
         
         /// Returns the index of the line currently being edited
         uint32_t
         GetCurrentLine();
 
-        /// Hides the current input session in preparation for output
-        void
-        Hide();
-        
-        /// Prepare to return to editing after a call to Hide()
-        void
-        Refresh();
-
         /// Interrupt the current edit as if ^C was pressed
         bool
         Interrupt();
-        
+        /// Cancel this edit and oblitarate all trace of it
+        bool
+        Cancel();
+        
         /// Register a callback for the tab key
         void
         SetAutoCompleteCallback (CompleteCallbackType callback, void * baton);
         
         /// Register a callback for testing whether multi-line input is complete
         void
         SetIsInputCompleteCallback (IsInputCompleteCallbackType callback, void * baton);
         
         /// Register a callback for determining the appropriate indentation for a line
         /// when creating a newline.  An optional set of insertable characters can also
         /// trigger the callback.
         bool
         SetFixIndentationCallback (FixIndentationCallbackType callback,
                                    void * baton,
                                    const char * indent_chars);
 
         /// Prompts for and reads a single line of user input.
         bool
         GetLine (std::string &line, bool &interrupted);
         
         /// Prompts for and reads a multi-line batch of user input.
         bool
         GetLines (int first_line_number, StringList &lines, bool &interrupted);
         
+        void
+        PrintAsync (Stream *stream, const char *s, size_t len);
+
     private:
         
         /// Sets the lowest line number for multi-line editing sessions.  A value of zero suppresses
         /// line number printing in the prompt.
         void
         SetBaseLineNumber (int line_number);
         
         /// Returns the complete prompt by combining the prompt or continuation prompt with line numbers

 #endif
         ::EditLine * m_editline = nullptr;
         EditlineHistorySP m_history_sp;
         bool m_in_history = false;
         std::vector<EditLineStringType> m_live_history_lines;
         bool m_multiline_enabled = false;
         std::vector<EditLineStringType> m_input_lines;
         EditorStatus m_editor_status;
-        bool m_editor_getting_char = false;
         bool m_color_prompts = true;
         int m_terminal_width = 0;
         int m_base_line_number = 0;
         unsigned m_current_line_index = 0;
         int m_current_line_rows = -1;
         int m_revert_cursor_index = 0;
         int m_line_number_digits = 3;
         std::string m_set_prompt;
         std::string m_set_continuation_prompt;
         std::string m_current_prompt;
         bool m_needs_prompt_repaint = false;
         std::string m_editor_name;
         FILE * m_input_file;
         FILE * m_output_file;
         FILE * m_error_file;
         ConnectionFileDescriptor m_input_connection;
         IsInputCompleteCallbackType m_is_input_complete_callback = nullptr;
         void * m_is_input_complete_callback_baton = nullptr;
         FixIndentationCallbackType m_fix_indentation_callback = nullptr;
         void * m_fix_indentation_callback_baton = nullptr;
         const char * m_fix_indentation_callback_chars = nullptr;
         CompleteCallbackType m_completion_callback = nullptr;
         void * m_completion_callback_baton = nullptr;
+
+        Mutex m_output_mutex;
     };
 }
 
 #endif  // #if defined(__cplusplus)
 #endif  // liblldb_Editline_h_

include/lldb/Target/Process.h

public:
     // and the process is already stopped, this function returns immediately.
     lldb::StateType
     WaitForProcessToStop (const TimeValue *timeout,
                           lldb::EventSP *event_sp_ptr = NULL,
                           bool wait_always = true,
                           Listener *hijack_listener = NULL,
                           Stream *stream = NULL);
 
+    uint32_t
+    GetIOHandlerID () const
+    {
+        return m_iohandler_sync.GetValue();
+    }
 
     //--------------------------------------------------------------------------------------
     /// Waits for the process state to be running within a given msec timeout.
     ///
     /// The main purpose of this is to implement an interlock waiting for HandlePrivateEvent
     /// to push an IOHandler.
     ///
     /// @param[in] timeout_msec
     ///     The maximum time length to wait for the process to transition to the
     ///     eStateRunning state, specified in milliseconds.
-    ///
-    /// @return
-    ///     true if successfully signalled that process started and IOHandler pushes, false
-    ///     if it timed out.
     //--------------------------------------------------------------------------------------
-    bool
-    SyncIOHandler (uint64_t timeout_msec);
-
+    void
+    SyncIOHandler (uint32_t iohandler_id, uint64_t timeout_msec);
 
     lldb::StateType
     WaitForStateChangedEvents (const TimeValue *timeout,
                                lldb::EventSP &event_sp,
                                Listener *hijack_listener); // Pass NULL to use builtin listener
 
     //--------------------------------------------------------------------------------------
     /// Centralize the code that handles and prints descriptions for process state changes.
protected:
     lldb::IOHandlerSP           m_process_input_reader;
     Communication               m_stdio_communication;
     Mutex                       m_stdio_communication_mutex;
     bool                        m_stdin_forward;           /// Remember if stdin must be forwarded to remote debug server
     std::string                 m_stdout_data;
     std::string                 m_stderr_data;
     Mutex                       m_profile_data_comm_mutex;
     std::vector<std::string>    m_profile_data;
-    Predicate<bool>             m_iohandler_sync;
+    Predicate<uint32_t>         m_iohandler_sync;
     MemoryCache                 m_memory_cache;
     AllocatedMemoryCache        m_allocated_memory_cache;
     bool                        m_should_detach;   /// Should we detach if the process object goes away with an explicit call to Kill or Detach?
     LanguageRuntimeCollection   m_language_runtimes;
     InstrumentationRuntimeCollection m_instrumentation_runtimes;
     std::unique_ptr<NextEventAction> m_next_event_action_ap;
     std::vector<PreResumeCallbackAndBaton> m_pre_resume_actions;
     ProcessRunLock              m_public_run_lock;

source/Commands/CommandObjectProcess.cpp

DoExecute (Args& launch_args, CommandReturnObject &result)
         if (error.Success())
         {
             ProcessSP process_sp (target->GetProcessSP());
             if (process_sp)
             {
                 // There is a race condition where this thread will return up the call stack to the main command
                 // handler and show an (lldb) prompt before HandlePrivateEvent (from PrivateStateThread) has
                 // a chance to call PushProcessIOHandler().
-                process_sp->SyncIOHandler(2000);
+                process_sp->SyncIOHandler (0, 2000);
 
                 const char *data = stream.GetData();
                 if (data && strlen(data) > 0)
                     result.AppendMessage(stream.GetData());
                 const char *archname = exe_module_sp->GetArchitecture().GetArchitectureName();
                 result.AppendMessageWithFormat ("Process %" PRIu64 " launched: '%s' (%s)\n", process_sp->GetID(), exe_module_sp->GetFileSpec().GetPath().c_str(), archname);
                 result.SetStatus (eReturnStatusSuccessFinishResult);
                 result.SetDidChangeProcessState (true);
DoExecute (Args& command, CommandReturnObject &result)
                 // Set the actions that the threads should each take when resuming
                 for (uint32_t idx=0; idx<num_threads; ++idx)
                 {
                     const bool override_suspend = false;
                     process->GetThreadList().GetThreadAtIndex(idx)->SetResumeState (eStateRunning, override_suspend);
                 }
             }
 
+            const uint32_t iohandler_id = process->GetIOHandlerID();
+
             StreamString stream;
             Error error;
             if (synchronous_execution)
                 error = process->ResumeSynchronous (&stream);
             else
                 error = process->Resume ();
 
             if (error.Success())
             {
                 // There is a race condition where this thread will return up the call stack to the main command
                  // handler and show an (lldb) prompt before HandlePrivateEvent (from PrivateStateThread) has
                  // a chance to call PushProcessIOHandler().
-                process->SyncIOHandler(2000);
+                process->SyncIOHandler(iohandler_id, 2000);
 
                 result.AppendMessageWithFormat ("Process %" PRIu64 " resuming\n", process->GetID());
                 if (synchronous_execution)
                 {
                     // If any state changed events had anything to say, add that to the result
                     if (stream.GetData())
                         result.AppendMessage(stream.GetData());
 

source/Commands/CommandObjectThread.cpp

DoExecute (Args& command, CommandReturnObject &result)
                 {
                     result.AppendWarning ("step operation does not support iteration count.");
                 }
             }
 
 
             process->GetThreadList().SetSelectedThreadByID (thread->GetID());
 
+            const uint32_t iohandler_id = process->GetIOHandlerID();
+
             StreamString stream;
             Error error;
             if (synchronous_execution)
                 error = process->ResumeSynchronous (&stream);
             else
                 error = process->Resume ();
 
             // There is a race condition where this thread will return up the call stack to the main command handler
             // and show an (lldb) prompt before HandlePrivateEvent (from PrivateStateThread) has
             // a chance to call PushProcessIOHandler().
-            process->SyncIOHandler(2000);
+            process->SyncIOHandler(iohandler_id, 2000);
 
             if (synchronous_execution)
             {
                 // If any state changed events had anything to say, add that to the result
                 if (stream.GetData())
                     result.AppendMessage(stream.GetData());
 
                 process->GetThreadList().SetSelectedThreadByID (thread->GetID());

source/Core/Debugger.cpp

 Debugger::ClearIOHandlers ()
 {
     // The bottom input reader should be the main debugger input reader.  We do not want to close that one here.
     Mutex::Locker locker (m_input_reader_stack.GetMutex());
     while (m_input_reader_stack.GetSize() > 1)
     {
         IOHandlerSP reader_sp (m_input_reader_stack.Top());
         if (reader_sp)
-        {
-            m_input_reader_stack.Pop();
-            reader_sp->SetIsDone(true);
-            reader_sp->Cancel();
-        }
+            PopIOHandler (reader_sp);
     }
 }
 
 void
 Debugger::ExecuteIOHandlers()
 {
-    
     while (1)
     {
         IOHandlerSP reader_sp(m_input_reader_stack.Top());
         if (!reader_sp)
             break;
 
-        reader_sp->Activate();
         reader_sp->Run();
-        reader_sp->Deactivate();
 
         // Remove all input readers that are done from the top of the stack
         while (1)
         {
             IOHandlerSP top_reader_sp = m_input_reader_stack.Top();
             if (top_reader_sp && top_reader_sp->GetIsDone())
-                m_input_reader_stack.Pop();
+                PopIOHandler (top_reader_sp);
             else
                 break;
         }
     }
     ClearIOHandlers();
 }
 
 bool
 Debugger::IsTopIOHandler (const lldb::IOHandlerSP& reader_sp)
 {
     return m_input_reader_stack.IsTop (reader_sp);
 }
 
+void
+Debugger::PrintAsync (const char *s, size_t len, bool is_stdout)
+{
+    lldb::StreamFileSP stream = is_stdout ? GetOutputFile() : GetErrorFile();
+    m_input_reader_stack.PrintAsync(stream.get(), s, len);
+}
 
 ConstString
 Debugger::GetTopIOHandlerControlSequence(char ch)
 {
     return m_input_reader_stack.GetTopIOHandlerControlSequence (ch);
 }
 
 const char *
 Debugger::GetIOHandlerCommandPrefix()
 {
     return m_input_reader_stack.GetTopIOHandlerCommandPrefix();
 }
 
 const char *
 Debugger::GetIOHandlerHelpPrologue()
 {
     return m_input_reader_stack.GetTopIOHandlerHelpPrologue();
 }
 
 void
 Debugger::RunIOHandler (const IOHandlerSP& reader_sp)
 {
     PushIOHandler (reader_sp);
-    
     IOHandlerSP top_reader_sp = reader_sp;
     while (top_reader_sp)
     {
-        top_reader_sp->Activate();
         top_reader_sp->Run();
-        top_reader_sp->Deactivate();
-        
         if (top_reader_sp.get() == reader_sp.get())
         {
             if (PopIOHandler (reader_sp))
                 break;
         }
-        
         while (1)
         {
             top_reader_sp = m_input_reader_stack.Top();
             if (top_reader_sp && top_reader_sp->GetIsDone())
-                m_input_reader_stack.Pop();
+                PopIOHandler (top_reader_sp);
             else
                 break;
         }
     }
 }
 
 void
 Debugger::AdoptTopIOHandlerFilesIfInvalid (StreamFileSP &in, StreamFileSP &out, StreamFileSP &err)

 }
 
 void
 Debugger::PushIOHandler (const IOHandlerSP& reader_sp)
 {
     if (!reader_sp)
         return;
  
-    // Got the current top input reader...
+    Mutex::Locker locker (m_input_reader_stack.GetMutex());
+
+    // Get the current top input reader...
     IOHandlerSP top_reader_sp (m_input_reader_stack.Top());
     
     // Don't push the same IO handler twice...
-    if (reader_sp.get() != top_reader_sp.get())
-    {
-        // Push our new input reader
-        m_input_reader_stack.Push (reader_sp);
+    if (reader_sp == top_reader_sp)
+        return;
+
+    reader_sp->Activate();
 
-        // Interrupt the top input reader to it will exit its Run() function
-        // and let this new input reader take over
-        if (top_reader_sp)
-            top_reader_sp->Deactivate();
+    {
+        top_reader_sp->Cancel();
     }
 }
 
 bool
 Debugger::PopIOHandler (const IOHandlerSP& pop_reader_sp)
 {
-    bool result = false;
-    
+    if (! pop_reader_sp)
+        return false;
     Mutex::Locker locker (m_input_reader_stack.GetMutex());
 
     // The reader on the stop of the stack is done, so let the next
     // read on the stack refresh its prompt and if there is one...
-    if (!m_input_reader_stack.IsEmpty())
-    {
-        IOHandlerSP reader_sp(m_input_reader_stack.Top());
-        
-        if (!pop_reader_sp || pop_reader_sp.get() == reader_sp.get())
-        {
-            reader_sp->Deactivate();
-            reader_sp->Cancel();
-            m_input_reader_stack.Pop ();
-            
-            reader_sp = m_input_reader_stack.Top();
-            if (reader_sp)
-                reader_sp->Activate();
+    if (m_input_reader_stack.IsEmpty())
+        return false;
+
+    if (pop_reader_sp != reader_sp)
+        return false;
+
 
-            result = true;
-        }
-    }
-    return result;
-}
-
-bool
-Debugger::HideTopIOHandler()
-{
-    Mutex::Locker locker;
-    
-    if (locker.TryLock(m_input_reader_stack.GetMutex()))
-    {
-        IOHandlerSP reader_sp(m_input_reader_stack.Top());
-        if (reader_sp)
-            reader_sp->Hide();
-        return true;
-    }
-    return false;
-}
-
-void
-Debugger::RefreshTopIOHandler()
-{
-    IOHandlerSP reader_sp(m_input_reader_stack.Top());
-    if (reader_sp)
-        reader_sp->Refresh();
-}
-
 
 StreamSP
 Debugger::GetAsyncOutputStream ()
 {
-    return StreamSP (new StreamAsynchronousIO (GetCommandInterpreter(),
-                                               CommandInterpreter::eBroadcastBitAsynchronousOutputData));
+    return StreamSP (new StreamAsynchronousIO (*this, true));
 }
 
 StreamSP
 Debugger::GetAsyncErrorStream ()
 {
-    return StreamSP (new StreamAsynchronousIO (GetCommandInterpreter(),
-                                               CommandInterpreter::eBroadcastBitAsynchronousErrorData));
+    return StreamSP (new StreamAsynchronousIO (*this, false));
 }    
 
 size_t
 Debugger::GetNumDebuggers()
 {
     if (lldb_initialized)
     {
         Mutex::Locker locker (GetDebuggerListMutex ());

 //    }
 //    
     if (event_type & eBreakpointEventTypeLocationsAdded)
     {
         uint32_t num_new_locations = Breakpoint::BreakpointEventData::GetNumBreakpointLocationsFromEvent(event_sp);
         if (num_new_locations > 0)
         {
             BreakpointSP breakpoint = Breakpoint::BreakpointEventData::GetBreakpointFromEvent(event_sp);
-            StreamFileSP output_sp (GetOutputFile());
+            StreamSP output_sp (GetAsyncOutputStream());
             if (output_sp)
             {
                 output_sp->Printf("%d location%s added to breakpoint %d\n",
                                   num_new_locations,
                                   num_new_locations == 1 ? "" : "s",
                                   breakpoint->GetID());
-                RefreshTopIOHandler();
+                output_sp->Flush();
             }
         }
     }
 //    else if (event_type & eBreakpointEventTypeLocationsRemoved)
 //    {
 //        // These locations just get disabled, not sure it is worth spamming folks about this on the command line.
 //    }
 //    else if (event_type & eBreakpointEventTypeLocationsResolved)

 // This function handles events that were broadcast by the process.
 void
 Debugger::HandleProcessEvent (const EventSP &event_sp)
 {
     using namespace lldb;
     const uint32_t event_type = event_sp->GetType();
     ProcessSP process_sp = Process::ProcessEventData::GetProcessFromEvent(event_sp.get());
 
-    StreamString output_stream;
-    StreamString error_stream;
+    StreamSP output_stream_sp = GetAsyncOutputStream();
+    StreamSP error_stream_sp = GetAsyncErrorStream();
     const bool gui_enabled = IsForwardingEvents();
 
     if (!gui_enabled)
     {
         bool pop_process_io_handler = false;
         assert (process_sp);
 
-        if (event_type & Process::eBroadcastBitSTDOUT || event_type & Process::eBroadcastBitStateChanged)
+        bool state_is_stopped = false;
+        const bool got_state_changed = (event_type & Process::eBroadcastBitStateChanged) != 0;
+        const bool got_stdout = (event_type & Process::eBroadcastBitSTDOUT) != 0;
+        const bool got_stderr = (event_type & Process::eBroadcastBitSTDERR) != 0;
+        if (got_state_changed)
         {
-            GetProcessSTDOUT (process_sp.get(), &output_stream);
+            StateType event_state = Process::ProcessEventData::GetStateFromEvent (event_sp.get());
+            state_is_stopped = StateIsStoppedState(event_state, false);
         }
 
-        if (event_type & Process::eBroadcastBitSTDERR || event_type & Process::eBroadcastBitStateChanged)
+        // Display running state changes first before any STDIO
+        if (got_state_changed && !state_is_stopped)
         {
-            GetProcessSTDERR (process_sp.get(), &error_stream);
+            Process::HandleProcessStateChangedEvent (event_sp, output_stream_sp.get(), pop_process_io_handler);
         }
 
-        if (event_type & Process::eBroadcastBitStateChanged)
+        // Now display and STDOUT
+        if (got_stdout || got_state_changed)
         {
-            Process::HandleProcessStateChangedEvent (event_sp, &output_stream, pop_process_io_handler);
+            GetProcessSTDOUT (process_sp.get(), output_stream_sp.get());
         }
 
-        if (output_stream.GetSize() || error_stream.GetSize())
-        {
-            StreamFileSP error_stream_sp (GetOutputFile());
-            bool top_io_handler_hid = false;
-
-            if (process_sp->ProcessIOHandlerExists() && process_sp->ProcessIOHandlerIsActive() == false)
-                top_io_handler_hid = HideTopIOHandler();
-
-            if (output_stream.GetSize())
-            {
-                StreamFileSP output_stream_sp (GetOutputFile());
-                if (output_stream_sp)
-                    output_stream_sp->Write (output_stream.GetData(), output_stream.GetSize());
-            }
+        // Now display and STDERR
+        if (got_stderr || got_state_changed)
+            GetProcessSTDERR (process_sp.get(), error_stream_sp.get());
 
-            if (error_stream.GetSize())
-            {
-                StreamFileSP error_stream_sp (GetErrorFile());
-                if (error_stream_sp)
-                    error_stream_sp->Write (error_stream.GetData(), error_stream.GetSize());
-            }
+        // Now display any stopped state changes after any STDIO
+        if (got_state_changed && state_is_stopped)
+            Process::HandleProcessStateChangedEvent (event_sp, output_stream_sp.get(), pop_process_io_handler);
 
-            if (top_io_handler_hid)
-                RefreshTopIOHandler();
-        }
+        output_stream_sp->Flush();
+        error_stream_sp->Flush();
 
         if (pop_process_io_handler)
             process_sp->PopProcessIOHandler();
     }
 }
 
 void
 Debugger::HandleThreadEvent (const EventSP &event_sp)
 {
     // At present the only thread event we handle is the Frame Changed event,
     // and all we do for that is just reprint the thread status for that thread.
     using namespace lldb;
     const uint32_t event_type = event_sp->GetType();
     if (event_type == Thread::eBroadcastBitStackChanged   ||
         event_type == Thread::eBroadcastBitThreadSelected )
     {
         ThreadSP thread_sp (Thread::ThreadEventData::GetThreadFromEvent (event_sp.get()));
         if (thread_sp)
         {
-            HideTopIOHandler();
-            StreamFileSP stream_sp (GetOutputFile());
-            thread_sp->GetStatus(*stream_sp, 0, 1, 1);
-            RefreshTopIOHandler();
+            thread_sp->GetStatus(*GetAsyncOutputStream(), 0, 1, 1);
         }
     }
 }
 
 bool
 Debugger::IsForwardingEvents ()
 {
     return (bool)m_forward_listener_sp;
while (!done)
                         {
                             done = true;
                         }
                         else if (event_type & CommandInterpreter::eBroadcastBitAsynchronousErrorData)
                         {
                             const char *data = reinterpret_cast<const char *>(EventDataBytes::GetBytesFromEvent (event_sp.get()));
                             if (data && data[0])
                             {
-                                StreamFileSP error_sp (GetErrorFile());
+                                StreamSP error_sp (GetAsyncErrorStream());
                                 if (error_sp)
                                 {
-                                    HideTopIOHandler();
                                     error_sp->PutCString(data);
                                     error_sp->Flush();
-                                    RefreshTopIOHandler();
                                 }
                             }
                         }
                         else if (event_type & CommandInterpreter::eBroadcastBitAsynchronousOutputData)
                         {
                             const char *data = reinterpret_cast<const char *>(EventDataBytes::GetBytesFromEvent (event_sp.get()));
                             if (data && data[0])
                             {
-                                StreamFileSP output_sp (GetOutputFile());
+                                StreamSP output_sp (GetAsyncOutputStream());
                                 if (output_sp)
                                 {
-                                    HideTopIOHandler();
                                     output_sp->PutCString(data);
                                     output_sp->Flush();
-                                    RefreshTopIOHandler();
                                 }
                             }
                         }
                     }
                 }
                 
                 if (m_forward_listener_sp)
                     m_forward_listener_sp->AddEvent(event_sp);

source/Core/IOHandler.cpp

 }
 
 void
 IOHandler::WaitForPop ()
 {
     m_popped.WaitForValueEqualTo(true);
 }
 
+void
+IOHandlerStack::PrintAsync (Stream *stream, const char *s, size_t len)
+{
+    if (stream)
+    {
+        Mutex::Locker locker (m_mutex);
+        if (m_top)
+            m_top->PrintAsync (stream, s, len);
+    }
+}
+
 IOHandlerConfirm::IOHandlerConfirm (Debugger &debugger,
                                     const char *prompt,
                                     bool default_response) :
     IOHandlerEditline(debugger,
                       IOHandler::Type::Confirm,
                       NULL,     // NULL editline_name means no history loaded/saved
                       NULL,     // No prompt
                       NULL,     // No continuation prompt
#endif
     m_color_prompts (color_prompts),
     m_interrupt_exits (true)
 {
     SetPrompt(prompt);
 
 #ifndef LLDB_DISABLE_LIBEDIT
     bool use_editline = false;
     
     use_editline = m_input_sp->GetFile().GetIsRealTerminal();
 
     if (use_editline)
     {
         m_editline_ap.reset(new Editline (editline_name,
                                           GetInputFILE (),
                                           GetOutputFILE (),
                                           GetErrorFILE (),
                                           m_color_prompts));
while (IsActive())
             {
                 m_done = true;
             }
         }
     }
 }
 
 void
-IOHandlerEditline::Hide ()
-{
-#ifndef LLDB_DISABLE_LIBEDIT
-    if (m_editline_ap)
-        m_editline_ap->Hide();
-#endif
-}
-
-
-void
-IOHandlerEditline::Refresh ()
-{
-#ifndef LLDB_DISABLE_LIBEDIT
-    if (m_editline_ap)
-    {
-        m_editline_ap->Refresh();
-    }
-    else
-    {
-#endif
-        const char *prompt = GetPrompt();
-        if (prompt && prompt[0])
-        {
-            FILE *out = GetOutputFILE();
-            if (out)
-            {
-                ::fprintf(out, "%s", prompt);
-                ::fflush(out);
-            }
-        }
-#ifndef LLDB_DISABLE_LIBEDIT
-    }
-#endif
-}
-
-void
 IOHandlerEditline::Cancel ()
 {
 #ifndef LLDB_DISABLE_LIBEDIT
     if (m_editline_ap)
-        m_editline_ap->Interrupt ();
+        m_editline_ap->Cancel ();
 #endif
 }
 
 bool
 IOHandlerEditline::Interrupt ()
 {
     // Let the delgate handle it first
     if (m_delegate.IOHandlerInterrupt(*this))

 IOHandlerEditline::GotEOF()
 {
 #ifndef LLDB_DISABLE_LIBEDIT
     if (m_editline_ap)
         m_editline_ap->Interrupt();
 #endif
 }
 
+void
+IOHandlerEditline::PrintAsync (Stream *stream, const char *s, size_t len)
+{
+#ifndef LLDB_DISABLE_LIBEDIT
+    if (m_editline_ap)
+        m_editline_ap->PrintAsync(stream, s, len);
+    else
+#endif
+        IOHandler::PrintAsync(stream, s, len);
+}
+
 // we may want curses to be disabled for some builds
 // for instance, windows
 #ifndef LLDB_DISABLE_CURSES
 
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Process.h"

 
 
 IOHandlerCursesGUI::~IOHandlerCursesGUI ()
 {
     
 }
 
 void
-IOHandlerCursesGUI::Hide ()
-{
-}
-
-
-void
-IOHandlerCursesGUI::Refresh ()
-{
-}
-
-void
 IOHandlerCursesGUI::Cancel ()
 {
 }
 
 bool
 IOHandlerCursesGUI::Interrupt ()
 {
     return false;

source/Core/StreamAsynchronousIO.cpp

 //===-- StreamBroadcast.cpp -------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#include <stdio.h>
+#include "lldb/Core/StreamAsynchronousIO.h"
 
 #include "lldb/lldb-private.h"
-#include "lldb/Core/Broadcaster.h"
-#include "lldb/Core/Event.h"
-#include "lldb/Core/StreamAsynchronousIO.h"
+#include "lldb/Core/Debugger.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 
-StreamAsynchronousIO::StreamAsynchronousIO (Broadcaster &broadcaster, uint32_t broadcast_event_type) :
+StreamAsynchronousIO::StreamAsynchronousIO (Debugger &debugger, bool for_stdout) :
     Stream (0, 4, eByteOrderBig),
-    m_broadcaster (broadcaster),
-    m_broadcast_event_type (broadcast_event_type),
-    m_accumulated_data ()
+    m_debugger (debugger),
+    m_data (),
+    m_for_stdout (for_stdout)
 {
 }
 
 StreamAsynchronousIO::~StreamAsynchronousIO ()
 {
     // Flush when we destroy to make sure we display the data
     Flush();
 }
 
 void
 StreamAsynchronousIO::Flush ()
 {
-    if (!m_accumulated_data.empty())
+    if (!m_data.empty())
     {
-        std::unique_ptr<EventDataBytes> data_bytes_ap (new EventDataBytes);
-        // Let's swap the bytes to avoid LARGE string copies.
-        data_bytes_ap->SwapBytes (m_accumulated_data);
-        EventSP new_event_sp (new Event (m_broadcast_event_type, data_bytes_ap.release()));
-        m_broadcaster.BroadcastEvent (new_event_sp);
+        m_debugger.PrintAsync (m_data.data(), m_data.size(), m_for_stdout);
+        m_data = std::move(std::string());
     }
 }
 
 size_t
 StreamAsynchronousIO::Write (const void *s, size_t length)
 {
-    m_accumulated_data.append ((const char *)s, length);
+    m_data.append ((const char *)s, length);
     return length;
 }

source/Host/common/Editline.cpp

 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Core/Error.h"
 #include "lldb/Core/StringList.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/Host/FileSpec.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/Mutex.h"
+#include "lldb/Utility/LLDBAssert.h"
 
 using namespace lldb_private;
 using namespace lldb_private::line_editor;
 
 // Workaround for what looks like an OS X-specific issue, but other platforms
 // may benefit from something similar if issues arise.  The libedit library
 // doesn't explicitly initialize the curses termcap library, which it gets away
 // with until TERM is set to VT100 where it stumbles over an implementation
if (m_multiline_enabled)
         m_current_line_rows = new_line_rows;
     }
     
     // Read an actual character
     while (true)
     {
         lldb::ConnectionStatus status = lldb::eConnectionStatusSuccess;
         char ch = 0;
-        m_editor_getting_char = true;
+
+        // This mutex is locked by our caller (GetLine). Unlock it while we read a character
+        // (blocking operation), so we do not hold the mutex indefinitely. This gives a chance
+        // for someone to interrupt us. After Read returns, immediately lock the mutex again and
+        // check if we were interrupted.
+        m_output_mutex.Unlock();
         int read_count = m_input_connection.Read(&ch, 1, UINT32_MAX, status, NULL);
-        m_editor_getting_char = false;
+        m_output_mutex.Lock();
+        if (m_editor_status == EditorStatus::Interrupted)
+        {
+            while (read_count > 0 && status == lldb::eConnectionStatusSuccess)
+                read_count = m_input_connection.Read(&ch, 1, UINT32_MAX, status, NULL);
+            lldbassert(status == lldb::eConnectionStatusInterrupted);
+            return 0;
+        }
+
         if (read_count)
         {
 #if LLDB_EDITLINE_USE_WCHAR
             // After the initial interruptible read, this is guaranteed not to block
             ungetc (ch, m_input_file);
             *c = fgetwc (m_input_file);
             if (*c != WEOF) 
                 return 1;
 #else
             *c = ch;
             if(ch != (char)EOF) 
                 return 1;
 #endif
         }
         else
         {
             switch (status)
             {
-                case lldb::eConnectionStatusInterrupted:
-                    m_editor_status = EditorStatus::Interrupted;
-                    printf ("^C\n");
-                    return 0;
-                    
                 case lldb::eConnectionStatusSuccess:         // Success
                     break;
                     
+                case lldb::eConnectionStatusInterrupted:
+                    lldbassert(0 && "Interrupts should have been handled above.");
+
                 case lldb::eConnectionStatusError:           // Check GetError() for details
                 case lldb::eConnectionStatusTimedOut:        // Request timed out
                 case lldb::eConnectionStatusEndOfFile:       // End-of-file encountered
                 case lldb::eConnectionStatusNoConnection:    // No connection
                 case lldb::eConnectionStatusLostConnection:  // Lost connection while connected to a valid connection
                     m_editor_status = EditorStatus::EndOfInput;
                     return 0;
             }

 }
 
 uint32_t
 Editline::GetCurrentLine()
 {
     return m_current_line_index;
 }
 
-void
-Editline::Hide()
-{
-    // Make sure we're at a stable location waiting for input
-    while (m_editor_status == EditorStatus::Editing && !m_editor_getting_char)
-    {
-        usleep(100000);
-    }
-    
-    // Clear the existing input
-    if (m_editor_status == EditorStatus::Editing)
-    {
-        MoveCursor(CursorLocation::EditingCursor, CursorLocation::BlockStart);
-        fprintf(m_output_file, ANSI_CLEAR_BELOW);
-    }
-}
-
-void
-Editline::Refresh()
-{
-    if (m_editor_status == EditorStatus::Editing)
-    {
-        DisplayInput();
-        MoveCursor(CursorLocation::BlockEnd, CursorLocation::EditingCursor);
+bool
+Editline::Interrupt()
+    bool result = true;
+    Mutex::Locker locker(m_output_mutex);
+    if (m_editor_status == EditorStatus::Editing) {
+        fprintf(m_output_file, "^C\n");
+        result = m_input_connection.InterruptRead();
     }
+    m_editor_status = EditorStatus::Interrupted;
+    return result;
 }
 
 bool
-Editline::Interrupt()
-{
-    if (m_editor_status == EditorStatus::Editing)
-    {
-        return m_input_connection.InterruptRead();
+Editline::Cancel()
+    bool result = true;
+    Mutex::Locker locker(m_output_mutex);
+    if (m_editor_status == EditorStatus::Editing) {
+        MoveCursor(CursorLocation::EditingCursor, CursorLocation::BlockStart);
+        fprintf(m_output_file, ANSI_CLEAR_BELOW);
+        result = m_input_connection.InterruptRead();
     }
-    return false; // Interrupt not handled as we weren't getting a line or lines
+    m_editor_status = EditorStatus::Interrupted;
+    return result;
 }
 
 void
 Editline::SetAutoCompleteCallback (CompleteCallbackType callback, void * baton)
 {
     m_completion_callback = callback;
     m_completion_callback_baton = baton;
 }

 
 bool
 Editline::GetLine (std::string &line, bool &interrupted)
 {
     ConfigureEditor (false);
     m_input_lines = std::vector<EditLineStringType>();
     m_input_lines.insert (m_input_lines.begin(), EditLineConstString(""));
     
+    Mutex::Locker locker(m_output_mutex);
+
+    lldbassert(m_editor_status != EditorStatus::Editing);
+    if (m_editor_status == EditorStatus::Interrupted)
+    {
+        m_editor_status = EditorStatus::Complete;
+        interrupted = true;
+        return true;
+    }
+
     SetCurrentLine (0);
     m_in_history = false;
     m_editor_status = EditorStatus::Editing;
-    m_editor_getting_char = false;
     m_revert_cursor_index = -1;
 
 #ifdef USE_SETUPTERM_WORKAROUND
         setupterm((char *)0, fileno(m_output_file), (int *)0);
 #endif
 
     int count;
     auto input = el_wgets (m_editline, &count);
 
     interrupted = m_editor_status == EditorStatus::Interrupted;
     if (!interrupted)
     {

 {
     ConfigureEditor (true);
     
     // Print the initial input lines, then move the cursor back up to the start of input
     SetBaseLineNumber (first_line_number);
     m_input_lines = std::vector<EditLineStringType>();
     m_input_lines.insert (m_input_lines.begin(), EditLineConstString(""));
     
+    Mutex::Locker locker(m_output_mutex);
     // Begin the line editing loop
     DisplayInput();
     SetCurrentLine (0);
     MoveCursor (CursorLocation::BlockEnd, CursorLocation::BlockStart);
     m_editor_status = EditorStatus::Editing;
-    m_editor_getting_char = false;
     m_in_history = false;
 
     m_revert_cursor_index = -1;
     while (m_editor_status == EditorStatus::Editing)
     {
 #ifdef USE_SETUPTERM_WORKAROUND
         setupterm((char *)0, fileno(m_output_file), (int *)0);
 #endif
         int count;
         m_current_line_rows = -1;
         el_wpush (m_editline, EditLineConstString("\x1b[^")); // Revert to the existing line content
         el_wgets (m_editline, &count);
     }
     
     interrupted = m_editor_status == EditorStatus::Interrupted;
     if (!interrupted)
     {
         // Save the completed entry in history before returning
         m_history_sp->Enter (CombineLines (m_input_lines).c_str());
 
         lines = GetInputAsStringList();
     }
     return m_editor_status != EditorStatus::EndOfInput;
 }
+
+void
+Editline::PrintAsync (Stream *stream, const char *s, size_t len)
+{
+    Mutex::Locker locker(m_output_mutex);
+    if (m_editor_status == EditorStatus::Editing)
+    {
+        MoveCursor(CursorLocation::EditingCursor, CursorLocation::BlockStart);
+        fprintf(m_output_file, ANSI_CLEAR_BELOW);
+    }
+    stream->Write (s, len);
+    stream->Flush();
+    if (m_editor_status == EditorStatus::Editing)
+    {
+        DisplayInput();
+        MoveCursor(CursorLocation::BlockEnd, CursorLocation::EditingCursor);
+    }
+}

source/Interpreter/ScriptInterpreterPython.cpp

public:
     IOHandlerPythonInterpreter (Debugger &debugger,
                                 ScriptInterpreterPython *python) :
         IOHandler (debugger, IOHandler::Type::PythonInterpreter),
         m_python(python)
     {
         
     }
     
-    virtual
-    ~IOHandlerPythonInterpreter()
+    ~IOHandlerPythonInterpreter() override
     {
         
     }
     
-    virtual ConstString
-    GetControlSequence (char ch)
+    ConstString
+    GetControlSequence (char ch) override
     {
         if (ch == 'd')
             return ConstString("quit()\n");
         return ConstString();
     }
 
-    virtual void
-    Run ()
+    void
+    Run () override
     {
         if (m_python)
         {
             int stdin_fd = GetInputFD();
             if (stdin_fd >= 0)
             {
                 Terminal terminal(stdin_fd);
                 TerminalState terminal_state;
Run () override
                 
                 if (is_a_tty)
                     terminal_state.Restore();
             }
         }
         SetIsDone(true);
     }
 
-    virtual void
-    Hide ()
-    {
-        
-    }
-    
-    virtual void
-    Refresh ()
-    {
-        
-    }
-
-    virtual void
-    Cancel ()
+    void
+    Cancel () override
     {
         
     }
 
-    virtual bool
-    Interrupt ()
+    bool
+    Interrupt () override
     {
         return m_python->Interrupt();
     }
     
-    virtual void
-    GotEOF()
+    void
+    GotEOF() override
     {
         
     }
 protected:
     ScriptInterpreterPython *m_python;
 };
 
 

source/Target/Process.cpp

Process::Process(Target &target, Listener &listener, const UnixSignalsSP &unix_signals_sp) :
     m_process_input_reader (),
     m_stdio_communication ("process.stdio"),
     m_stdio_communication_mutex (Mutex::eMutexTypeRecursive),
     m_stdin_forward (false),
     m_stdout_data (),
     m_stderr_data (),
     m_profile_data_comm_mutex (Mutex::eMutexTypeRecursive),
     m_profile_data (),
-    m_iohandler_sync (false),
+    m_iohandler_sync (0),
     m_memory_cache (*this),
     m_allocated_memory_cache (*this),
     m_should_detach (false),
     m_next_event_action_ap(),
     m_public_run_lock (),
     m_private_run_lock (),
     m_currently_handling_event(false),
     m_stop_info_override_callback (NULL),
Process::GetNextEvent (EventSP &event_sp)
     StateType state = eStateInvalid;
 
     if (m_listener.GetNextEventForBroadcaster (this, event_sp) && event_sp)
         state = Process::ProcessEventData::GetStateFromEvent (event_sp.get());
 
     return state;
 }
 
-bool
-Process::SyncIOHandler (uint64_t timeout_msec)
+void
+Process::SyncIOHandler (uint32_t iohandler_id, uint64_t timeout_msec)
 {
-    bool timed_out = false;
-
     // don't sync (potentially context switch) in case where there is no process IO
-    if (m_process_input_reader)
-    {
-        TimeValue timeout = TimeValue::Now();
-        timeout.OffsetWithMicroSeconds(timeout_msec*1000);
-
-        m_iohandler_sync.WaitForValueEqualTo(true, &timeout, &timed_out);
+    if (! m_process_input_reader)
+        return;
+
+    uint32_t new_iohandler_id = 0;
+    m_iohandler_sync.WaitForValueNotEqualTo(iohandler_id, new_iohandler_id, &timeout);
 
-        Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
-        if(log)
-        {
-            if(timed_out)
-                log->Printf ("Process::%s pid %" PRIu64 " (timeout=%" PRIu64 "ms): FAIL", __FUNCTION__, GetID (), timeout_msec);
-            else
-                log->Printf ("Process::%s pid %" PRIu64 ": SUCCESS", __FUNCTION__, GetID ());
-        }
-
-        // reset sync one-shot so it will be ready for next launch
-        m_iohandler_sync.SetValue(false, eBroadcastNever);
-    }
-
-    return !timed_out;
+    if (log)
+        log->Printf("Process::%s waited for m_iohandler_sync to change from %u, new value is %u", __FUNCTION__, iohandler_id, new_iohandler_id);
 }
 
 StateType
 Process::WaitForProcessToStop (const TimeValue *timeout,
                                EventSP *event_sp_ptr,
                                bool wait_always,
                                Listener *hijack_listener,
                                Stream *stream)
if (should_broadcast)
         }
         Process::ProcessEventData::SetUpdateStateOnRemoval(event_sp.get());
         if (StateIsRunningState (new_state))
         {
             // Only push the input handler if we aren't fowarding events,
             // as this means the curses GUI is in use...
             // Or don't push it if we are launching since it will come up stopped.
             if (!GetTarget().GetDebugger().IsForwardingEvents() && new_state != eStateLaunching)
                 PushProcessIOHandler ();
-            m_iohandler_sync.SetValue(true, eBroadcastAlways);
+            m_iohandler_sync.SetValue(m_iohandler_sync.GetValue()+1, eBroadcastAlways);
+            if (log)
+                log->Printf("Process::%s updated m_iohandler_sync to %d", __FUNCTION__, m_iohandler_sync.GetValue());
         }
         else if (StateIsStoppedState(new_state, false))
         {
-            m_iohandler_sync.SetValue(false, eBroadcastNever);
             if (!Process::ProcessEventData::GetRestartedFromEvent(event_sp.get()))
             {
                 // If the lldb_private::Debugger is handling the events, we don't
                 // want to pop the process IOHandler here, we want to do it when
                 // we receive the stopped event so we can carefully control when
                 // the process IOHandler is popped because when we stop we want to
                 // display some text stating how and why we stopped, then maybe some
                 // process/thread/frame info, and then we want the "(lldb) " prompt
public:
     ClosePipes()
     {
         m_pipe.Close();
     }
     
     // Each IOHandler gets to run until it is done. It should read data
     // from the "in" and place output into "out" and "err and return
     // when done.
-    virtual void
-    Run ()
+    void
+    Run () override
     {
         if (m_read_file.IsValid() && m_write_file.IsValid())
         {
             SetIsDone(false);
             if (OpenPipes())
             {
                 const int read_fd = m_read_file.GetDescriptor();
                 TerminalState terminal_state;
#endif
             }
             else
                 SetIsDone(true);
         }
         else
             SetIsDone(true);
     }
     
-    // Hide any characters that have been displayed so far so async
-    // output can be displayed. Refresh() will be called after the
-    // output has been displayed.
-    virtual void
-    Hide ()
-    {
-        
-    }
-    // Called when the async output has been received in order to update
-    // the input reader (refresh the prompt and redisplay any current
-    // line(s) that are being edited
-    virtual void
-    Refresh ()
-    {
-        
-    }
-    
-    virtual void
-    Cancel ()
+    void
+    Cancel () override
     {
         char ch = 'q';  // Send 'q' for quit
         size_t bytes_written = 0;
         m_pipe.Write(&ch, 1, bytes_written);
     }
 
-    virtual bool
-    Interrupt ()
+    bool
+    Interrupt () override
     {
         // Do only things that are safe to do in an interrupt context (like in
         // a SIGINT handler), like write 1 byte to a file descriptor. This will
         // interrupt the IOHandlerProcessSTDIO::Run() and we can look at the byte
         // that was written to the pipe and then call m_process->Halt() from a
         // much safer location in code.
         if (m_active)
         {
Interrupt () override
             {
                 m_process->SendAsyncInterrupt();
                 return true;
             }
         }
         return false;
     }
     
-    virtual void
-    GotEOF()
+    void
+    GotEOF() override
     {
         
     }
     
 protected:
     Process *m_process;
     File m_read_file;   // Read from this file (usually actual STDIN for LLDB
     File m_write_file;  // Write to this file (usually the master pty for getting io to debuggee)
Process::ProcessIOHandlerIsActive ()
     IOHandlerSP io_handler_sp (m_process_input_reader);
     if (io_handler_sp)
         return m_target.GetDebugger().IsTopIOHandler (io_handler_sp);
     return false;
 }
 bool
 Process::PushProcessIOHandler ()
 {
     IOHandlerSP io_handler_sp (m_process_input_reader);
     if (io_handler_sp)
     {
+        Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
+        if (log)
+            log->Printf("Process::%s pushing IO handler", __FUNCTION__);
+
         io_handler_sp->SetIsDone(false);
         m_target.GetDebugger().PushIOHandler (io_handler_sp);
         return true;
     }
     return false;
 }
 
 bool