[lldb] Make some functions useful to REPLs public

[wallace]

Summary

StartEventHandlerThread and StopEventHandlerThread are available to the SwiftREPL even though they are protected because SwiftREPL is a friend class of Debugger. I'm developing my own REPL and having access to these functions, including FlushProcessOutput, is desirable.

[bulbazord]

lldb/include/lldb/Core/Debugger.h

503–504

There are program that use LLDB as a library but go through the SBAPI instead of lldb_private. Could you update this comment to be more specific about the intentions here? I assume you mean things like plugins.

[wallace]

lldb/include/lldb/Core/Debugger.h

503–504

sure

[wallace]

address comment

[JDevlieghere]

lldb/include/lldb/Core/Debugger.h

505

508–509

used by programs is rather vague.

512

[wallace]

address comments

[bulbazord]

LGTM

lldb/include/lldb/Core/Debugger.h

ReportInfo(std::string message,
              std::once_flag *once = nullptr);
 
   static void ReportSymbolChange(const ModuleSpec &module_spec);
 
   void
   SetDestroyCallback(lldb_private::DebuggerDestroyCallback destroy_callback,
                      void *baton);
 
+  /// Manually start the global event handler thread. It is useful to plugins
+  /// that directly use the \a lldb_private namespace and want to use the
+  /// debugger's default event handler thread instead of defining their own.
+  bool StartEventHandlerThread();
+
+  /// Manually stop the debugger's default event handler.
+  void StopEventHandlerThread();
+
+  /// Force flushing the process's pending stdout and stderr to the debugger's
+  /// asynchronous stdout and stderr streams.
+  void FlushProcessOutput(Process &process, bool flush_stdout,
+                          bool flush_stderr);
+
 protected:
   friend class CommandInterpreter;
   friend class REPL;
   friend class Progress;
 
   /// Report progress events.
   ///
   /// Progress events will be delivered to any debuggers that have listeners
static void ReportDiagnosticImpl(DiagnosticEventData::Type type,
                                    std::string message,
                                    std::optional<lldb::user_id_t> debugger_id,
                                    std::once_flag *once);
 
   void HandleDestroyCallback();
 
   void PrintProgress(const ProgressEventData &data);
 
-  bool StartEventHandlerThread();
-
-  void StopEventHandlerThread();
-
   void PushIOHandler(const lldb::IOHandlerSP &reader_sp,
                      bool cancel_top_handler = true);
 
   bool PopIOHandler(const lldb::IOHandlerSP &reader_sp);
 
   bool HasIOHandlerThread() const;
 
   bool StartIOHandlerThread();
protected:
   void HandleThreadEvent(const lldb::EventSP &event_sp);
 
   void HandleProgressEvent(const lldb::EventSP &event_sp);
 
   void HandleDiagnosticEvent(const lldb::EventSP &event_sp);
 
   // Ensures two threads don't attempt to flush process output in parallel.
   std::mutex m_output_flush_mutex;
-  void FlushProcessOutput(Process &process, bool flush_stdout,
-                          bool flush_stderr);
 
   SourceManager::SourceFileCache &GetSourceFileCache() {
     return m_source_file_cache;
   }
 
   void InstanceInitialize();
 
   // these should never be NULL