Tie stdout and stderr together

Author: JDevlieghere

lldb/include/lldb/Core/Debugger.h

@@ -691,6 +691,7 @@ class Debugger : public std::enable_shared_from_this<Debugger>,
   lldb::FileSP m_input_file_sp;
   lldb::LockableStreamFileSP m_output_stream_sp;
   lldb::LockableStreamFileSP m_error_stream_sp;
+  LockableStreamFile::Mutex m_output_mutex;
 
   /// Used for shadowing the input file when capturing a reproducer.
   repro::DataRecorder *m_input_recorder;

lldb/include/lldb/Host/File.h

@@ -377,6 +377,11 @@ class File : public IOObject {
 
 class NativeFile : public File {
 public:
+  enum TransferOwnership : bool {
+    Owned = true,
+    Unowned = false,
+  };
+
   NativeFile() : m_descriptor(kInvalidDescriptor), m_stream(kInvalidStream) {}
 
   NativeFile(FILE *fh, bool transfer_ownership)

lldb/include/lldb/Host/StreamFile.h

@@ -18,6 +18,7 @@
 #include <cstdint>
 #include <cstdio>
 #include <memory>
+#include <mutex>
 
 namespace lldb_private {
 
@@ -70,13 +71,17 @@ class LockedStreamFile : public StreamFile {
 
 class LockableStreamFile {
 public:
-  LockableStreamFile(std::shared_ptr<StreamFile> stream_file_sp)
-      : m_file_sp(stream_file_sp->GetFileSP()) {}
-  LockableStreamFile(StreamFile &stream_file)
-      : m_file_sp(stream_file.GetFileSP()) {}
-  LockableStreamFile(FILE *fh, bool transfer_ownership)
-      : m_file_sp(std::make_shared<NativeFile>(fh, transfer_ownership)) {}
-  LockableStreamFile(std::shared_ptr<File> file_sp) : m_file_sp(file_sp) {}
+  using Mutex = std::recursive_mutex;
+
+  LockableStreamFile(std::shared_ptr<StreamFile> stream_file_sp, Mutex &mutex)
+      : m_file_sp(stream_file_sp->GetFileSP()), m_mutex(mutex) {}
+  LockableStreamFile(StreamFile &stream_file, Mutex &mutex)
+      : m_file_sp(stream_file.GetFileSP()), m_mutex(mutex) {}
+  LockableStreamFile(FILE *fh, bool transfer_ownership, Mutex &mutex)
+      : m_file_sp(std::make_shared<NativeFile>(fh, transfer_ownership)),
+        m_mutex(mutex) {}
+  LockableStreamFile(std::shared_ptr<File> file_sp, Mutex &mutex)
+      : m_file_sp(file_sp), m_mutex(mutex) {}
 
   LockedStreamFile Lock() { return LockedStreamFile(m_file_sp, m_mutex); }
 
@@ -87,11 +92,11 @@ class LockableStreamFile {
   std::shared_ptr<File> GetUnlockedFileSP() { return m_file_sp; }
   /// @}
 
-  std::recursive_mutex &GetMutex() { return m_mutex; }
+  Mutex &GetMutex() { return m_mutex; }
 
 protected:
   std::shared_ptr<File> m_file_sp;
-  std::recursive_mutex m_mutex;
+  Mutex &m_mutex;
 
 private:
   LockableStreamFile(const LockableStreamFile &) = delete;

lldb/include/lldb/Interpreter/ScriptInterpreter.h

@@ -134,6 +134,7 @@ class ScriptInterpreterIORedirect {
   lldb::FileSP m_input_file_sp;
   lldb::LockableStreamFileSP m_output_file_sp;
   lldb::LockableStreamFileSP m_error_file_sp;
+  LockableStreamFile::Mutex m_output_mutex;
   ThreadedCommunication m_communication;
   bool m_disconnect;
 };

lldb/source/Core/Debugger.cpp

@@ -873,9 +873,11 @@ llvm::StringRef Debugger::GetStaticBroadcasterClass() {
 Debugger::Debugger(lldb::LogOutputCallback log_callback, void *baton)
     : UserID(g_unique_id++),
       Properties(std::make_shared<OptionValueProperties>()),
-      m_input_file_sp(std::make_shared<NativeFile>(stdin, false)),
-      m_output_stream_sp(std::make_shared<LockableStreamFile>(stdout, false)),
-      m_error_stream_sp(std::make_shared<LockableStreamFile>(stderr, false)),
+      m_input_file_sp(std::make_shared<NativeFile>(stdin, NativeFile::Unowned)),
+      m_output_stream_sp(std::make_shared<LockableStreamFile>(
+          stdout, NativeFile::Unowned, m_output_mutex)),
+      m_error_stream_sp(std::make_shared<LockableStreamFile>(
+          stderr, NativeFile::Unowned, m_output_mutex)),
       m_input_recorder(nullptr),
       m_broadcaster_manager_sp(BroadcasterManager::MakeBroadcasterManager()),
       m_terminal_state(), m_target_list(*this), m_platform_list(),
@@ -1083,12 +1085,14 @@ void Debugger::SetInputFile(FileSP file_sp) {
 
 void Debugger::SetOutputFile(FileSP file_sp) {
   assert(file_sp && file_sp->IsValid());
-  m_output_stream_sp = std::make_shared<LockableStreamFile>(file_sp);
+  m_output_stream_sp =
+      std::make_shared<LockableStreamFile>(file_sp, m_output_mutex);
 }
 
 void Debugger::SetErrorFile(FileSP file_sp) {
   assert(file_sp && file_sp->IsValid());
-  m_error_stream_sp = std::make_shared<LockableStreamFile>(file_sp);
+  m_error_stream_sp =
+      std::make_shared<LockableStreamFile>(file_sp, m_output_mutex);
 }
 
 void Debugger::SaveInputTerminalState() {
@@ -1244,7 +1248,7 @@ void Debugger::AdoptTopIOHandlerFilesIfInvalid(FileSP &in,
       in = GetInputFileSP();
     // If there is nothing, use stdin
     if (!in)
-      in = std::make_shared<NativeFile>(stdin, false);
+      in = std::make_shared<NativeFile>(stdin, NativeFile::Unowned);
   }
   // If no STDOUT has been set, then set it appropriately
   if (!out || !out->GetUnlockedFile().IsValid()) {
@@ -1254,7 +1258,8 @@ void Debugger::AdoptTopIOHandlerFilesIfInvalid(FileSP &in,
       out = GetOutputStreamSP();
     // If there is nothing, use stdout
     if (!out)
-      out = std::make_shared<LockableStreamFile>(stdout, false);
+      out = std::make_shared<LockableStreamFile>(stdout, NativeFile::Unowned,
+                                                 m_output_mutex);
   }
   // If no STDERR has been set, then set it appropriately
   if (!err || !err->GetUnlockedFile().IsValid()) {
@@ -1264,7 +1269,8 @@ void Debugger::AdoptTopIOHandlerFilesIfInvalid(FileSP &in,
       err = GetErrorStreamSP();
     // If there is nothing, use stderr
     if (!err)
-      err = std::make_shared<LockableStreamFile>(stderr, false);
+      err = std::make_shared<LockableStreamFile>(stderr, NativeFile::Unowned,
+                                                 m_output_mutex);
   }
 }
 

lldb/source/Interpreter/ScriptInterpreter.cpp

@@ -206,7 +206,8 @@ ScriptInterpreterIORedirect::Create(bool enable_io, Debugger &debugger,
 ScriptInterpreterIORedirect::ScriptInterpreterIORedirect(
     std::unique_ptr<File> input, std::unique_ptr<File> output)
     : m_input_file_sp(std::move(input)),
-      m_output_file_sp(std::make_shared<LockableStreamFile>(std::move(output))),
+      m_output_file_sp(std::make_shared<LockableStreamFile>(std::move(output),
+                                                            m_output_mutex)),
       m_error_file_sp(m_output_file_sp),
       m_communication("lldb.ScriptInterpreterIORedirect.comm"),
       m_disconnect(false) {}
@@ -241,7 +242,8 @@ ScriptInterpreterIORedirect::ScriptInterpreterIORedirect(
 
       FILE *outfile_handle = fdopen(pipe.ReleaseWriteFileDescriptor(), "w");
       m_output_file_sp = std::make_shared<LockableStreamFile>(
-          std::make_shared<StreamFile>(outfile_handle, true));
+          std::make_shared<StreamFile>(outfile_handle, NativeFile::Owned),
+          m_output_mutex);
       m_error_file_sp = m_output_file_sp;
       if (outfile_handle)
         ::setbuf(outfile_handle, nullptr);

lldb/unittests/Editline/EditlineTest.cpp

@@ -7,6 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Host/Config.h"
+#include "lldb/Host/File.h"
 
 #if LLDB_ENABLE_LIBEDIT
 
@@ -117,9 +118,11 @@ EditlineAdapter::EditlineAdapter()
     return;
 
   lldb::LockableStreamFileSP output_stream_sp =
-      std::make_shared<LockableStreamFile>(*_el_secondary_file, false);
+      std::make_shared<LockableStreamFile>(*_el_secondary_file,
+                                           NativeFile::Unowned, output_mutex);
   lldb::LockableStreamFileSP error_stream_sp =
-      std::make_shared<LockableStreamFile>(*_el_secondary_file, false);
+      std::make_shared<LockableStreamFile>(*_el_secondary_file,
+                                           NativeFile::Unowned, output_mutex);
 
   // Create an Editline instance.
   _editline_sp.reset(new lldb_private::Editline(