[lldb] Use the IOHandler's output/error stream instead of the debugger one in PrintAsync

[JDevlieghere]

Summary

I was looking into PrintAsync because Pavel brought it up in D121500. The whole point seems to be to let the IOHandler deal with printing the output. In that context it didn't make much sense (to me) that this is using the debugger's output and error stream rather than the one from the IOHandler.

[labath]

In that context it didn't make much sense (to me) that this is using the debugger's output and error stream rather than the one from the IOHandler.

I don't know why this is set up the way it is, but I would be inclined to agree with you.

[labath]

(I suspect this has something to do with the ability to override the output of a particular iohandler in the stack. The idea may have been that the iohandler prints whereever it prints, but the asynchronous output always goes to the main output. But I don't know if we make use of this functionality anywhere.)

lldb/include/lldb/Core/IOHandler.h

public:
   /// sequences are expected to work (cursor movement escape sequences,
   /// clearing lines, etc).
   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();
-  }
+  virtual void PrintAsync(const char *s, size_t len, bool is_stdout);
 
 protected:
   Debugger &m_debugger;
   lldb::FileSP m_input_sp;
   lldb::StreamFileSP m_output_sp;
   lldb::StreamFileSP m_error_sp;
   repro::DataRecorder *m_data_recorder;
   Predicate<bool> m_popped;
public:
   bool GetInterruptExits() { return m_interrupt_exits; }
 
   void SetInterruptExits(bool b) { m_interrupt_exits = b; }
 
   const StringList *GetCurrentLines() const { return m_current_lines_ptr; }
 
   uint32_t GetCurrentLineIndex() const;
 
-  void PrintAsync(Stream *stream, const char *s, size_t len) override;
+  void PrintAsync(const char *s, size_t len, bool is_stdout) override;
 
 private:
 #if LLDB_ENABLE_LIBEDIT
   bool IsInputCompleteCallback(Editline *editline, StringList &lines);
 
   int FixIndentationCallback(Editline *editline, const StringList &lines,
                              int cursor_position);
 
public:
   const char *GetTopIOHandlerCommandPrefix() {
     return ((m_top != nullptr) ? m_top->GetCommandPrefix() : nullptr);
   }
 
   const char *GetTopIOHandlerHelpPrologue() {
     return ((m_top != nullptr) ? m_top->GetHelpPrologue() : nullptr);
   }
 
-  void PrintAsync(Stream *stream, const char *s, size_t len);
+  bool PrintAsync(const char *s, size_t len, bool is_stdout);
 
 protected:
   typedef std::vector<lldb::IOHandlerSP> collection;
   collection m_stack;
   mutable std::recursive_mutex m_mutex;
   IOHandler *m_top = nullptr;
 
 private:
   IOHandlerStack(const IOHandlerStack &) = delete;
   const IOHandlerStack &operator=(const IOHandlerStack &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_CORE_IOHANDLER_H

lldb/source/Core/Debugger.cpp

 }
 
 bool Debugger::CheckTopIOHandlerTypes(IOHandler::Type top_type,
                                       IOHandler::Type second_top_type) {
   return m_io_handler_stack.CheckTopIOHandlerTypes(top_type, second_top_type);
 }
 
 void Debugger::PrintAsync(const char *s, size_t len, bool is_stdout) {
-  lldb_private::StreamFile &stream =
-      is_stdout ? GetOutputStream() : GetErrorStream();
-  m_io_handler_stack.PrintAsync(&stream, s, len);
+  bool printed = m_io_handler_stack.PrintAsync(s, len, is_stdout);
+  if (!printed) {
+    lldb::StreamFileSP stream =
+        is_stdout ? m_output_stream_sp : m_error_stream_sp;
+    stream->Write(s, len);
+  }
 }
 
 ConstString Debugger::GetTopIOHandlerControlSequence(char ch) {
   return m_io_handler_stack.GetTopIOHandlerControlSequence(ch);
 }
 
 const char *Debugger::GetIOHandlerCommandPrefix() {
   return m_io_handler_stack.GetTopIOHandlerCommandPrefix();

lldb/source/Core/IOHandler.cpp

 bool IOHandler::GetIsRealTerminal() {
   return GetInputFileSP() ? GetInputFileSP()->GetIsRealTerminal() : false;
 }
 
 void IOHandler::SetPopped(bool b) { m_popped.SetValue(b, eBroadcastOnChange); }
 
 void IOHandler::WaitForPop() { m_popped.WaitForValueEqualTo(true); }
 
-void IOHandlerStack::PrintAsync(Stream *stream, const char *s, size_t len) {
-  if (stream) {
-    std::lock_guard<std::recursive_mutex> guard(m_mutex);
-    if (m_top)
-      m_top->PrintAsync(stream, s, len);
-    else
-      stream->Write(s, len);
-  }
+void IOHandler::PrintAsync(const char *s, size_t len, bool is_stdout) {
+  lldb::StreamFileSP stream = is_stdout ? m_output_sp : m_error_sp;
+  stream->Flush();
+
+bool IOHandlerStack::PrintAsync(const char *s, size_t len, bool is_stdout) {
+  std::lock_guard<std::recursive_mutex> guard(m_mutex);
+  if (!m_top)
+    return false;
+  m_top->PrintAsync(s, len, is_stdout);
+  return true;
 }
 
 IOHandlerConfirm::IOHandlerConfirm(Debugger &debugger, llvm::StringRef prompt,
                                    bool default_response)
     : IOHandlerEditline(
           debugger, IOHandler::Type::Confirm,
           nullptr, // nullptr editline_name means no history loaded/saved
           llvm::StringRef(), // No prompt

 
 void IOHandlerEditline::GotEOF() {
 #if LLDB_ENABLE_LIBEDIT
   if (m_editline_up)
     m_editline_up->Interrupt();
 #endif
 }
 
-void IOHandlerEditline::PrintAsync(Stream *stream, const char *s, size_t len) {
+void IOHandlerEditline::PrintAsync(const char *s, size_t len, bool is_stdout) {
 #if LLDB_ENABLE_LIBEDIT
-  if (m_editline_up)
-    m_editline_up->PrintAsync(stream, s, len);
-  else
+  if (m_editline_up) {
+    lldb::StreamFileSP stream = is_stdout ? m_output_sp : m_error_sp;
+    m_editline_up->PrintAsync(stream.get(), s, len);
+  } else
 #endif
   {
 #ifdef _WIN32
     const char *prompt = GetPrompt();
     if (prompt) {
       // Back up over previous prompt using Windows API
       CONSOLE_SCREEN_BUFFER_INFO screen_buffer_info;
       HANDLE console_handle = GetStdHandle(STD_OUTPUT_HANDLE);
       GetConsoleScreenBufferInfo(console_handle, &screen_buffer_info);
       COORD coord = screen_buffer_info.dwCursorPosition;
       coord.X -= strlen(prompt);
       if (coord.X < 0)
         coord.X = 0;
       SetConsoleCursorPosition(console_handle, coord);
     }
 #endif
-    IOHandler::PrintAsync(stream, s, len);
+    IOHandler::PrintAsync(s, len, is_stdout);
 #ifdef _WIN32
     if (prompt)
       IOHandler::PrintAsync(GetOutputStreamFileSP().get(), prompt,
                             strlen(prompt));
 #endif
   }
 }