[lldb/Plugins] Introduce Multiplexer & ScriptedMultiplexer

[mib]

Summary

This patch introduces a new core component to LLDB: Multiplexer.

The goal of a multiplexer is to stand between the debugger and a list of
processes to intercept events and re-dispatch them to the right processes.

This patch also introduces a special kind of multiplexer: ScriptedMultiplexer.
As the name suggests, it lets the user have a custom implementation of
the multiplexer in a script file that can be imported into lldb.

The ScriptedMultiplexer implements a FilterEvent(SBEvent&) method that
will allow the user to iterate over the list of multiplexed processes
and decide to which one the event should be sent to.

The multiplexer gets instanciated when a ScriptedProcess implements the
get_scripted_multiplexer method that returns a well-formed dictionary.
The multiplexer instance gets stored in the debugger object.

For the process to be handled by the multiplexer, they all need to
provide the same multiplexer name in the dictionary.

Signed-off-by: Med Ismail Bennani <[e-mail]>

lldb/bindings/python/CMakeLists.txt

FILES "${LLDB_SOURCE_DIR}/examples/python/in_call_stack.py"
           "${LLDB_SOURCE_DIR}/examples/python/symbolication.py")
 
   create_python_package(
     ${swig_target}
     ${lldb_python_target_dir}
     "plugins"
     FILES
     "${LLDB_SOURCE_DIR}/examples/python/scripted_process/scripted_process.py"
-    "${LLDB_SOURCE_DIR}/examples/python/scripted_process/scripted_platform.py")
+    "${LLDB_SOURCE_DIR}/examples/python/scripted_process/scripted_platform.py"
+    "${LLDB_SOURCE_DIR}/examples/python/scripted_process/scripted_multiplexer.py")
 
   if(APPLE)
     create_python_package(
       ${swig_target}
       ${lldb_python_target_dir} "macosx"
       FILES "${LLDB_SOURCE_DIR}/examples/python/crashlog.py"
             "${LLDB_SOURCE_DIR}/examples/python/scripted_process/crashlog_scripted_process.py"
             "${LLDB_SOURCE_DIR}/examples/darwin/heap_find/heap.py")

lldb/bindings/python/python-swigsafecast.swig

return ToSWIGHelper(new lldb::SBSymbolContext(sym_ctx),
                       SWIGTYPE_p_lldb__SBSymbolContext);
 }
 
 PythonObject ToSWIGWrapper(lldb::ProcessLaunchInfoSP launch_info_sp) {
   return ToSWIGHelper(new lldb::ProcessLaunchInfoSP(std::move(launch_info_sp)),
                       SWIGTYPE_p_lldb__SBLaunchInfo);
 }
 
+PythonObject ToSWIGWrapper(lldb::EventSP event_sp) {
+  return ToSWIGHelper(new lldb::EventSP(std::move(event_sp)),
+                      SWIGTYPE_p_lldb__SBEvent);
+}
+
 PythonObject ToSWIGWrapper(lldb::ProcessAttachInfoSP attach_info_sp) {
   return ToSWIGHelper(new lldb::ProcessAttachInfoSP(std::move(attach_info_sp)),
                       SWIGTYPE_p_lldb__SBAttachInfo);
 }
 
 ScopedPythonObject<lldb::SBCommandReturnObject>
 ToSWIGWrapper(CommandReturnObject &cmd_retobj) {
   return ScopedPythonObject<lldb::SBCommandReturnObject>(

lldb/bindings/python/python-wrapper.swig

int valid_cast =
       SWIG_ConvertPtr(data, (void **)&sb_ptr, SWIGTYPE_p_lldb__SBLaunchInfo, 0);
 
   if (valid_cast == -1)
     return NULL;
 
   return sb_ptr;
 }
 
+void *lldb_private::LLDBSWIGPython_CastPyObjectToSBEvent(PyObject * data) {
+  lldb::SBEvent *sb_ptr = nullptr;
+
+  int valid_cast =
+      SWIG_ConvertPtr(data, (void **)&sb_ptr, SWIGTYPE_p_lldb__SBEvent, 0);
+
+  if (valid_cast == -1)
+    return NULL;
+
+  return sb_ptr;
+}
+
 void *lldb_private::LLDBSWIGPython_CastPyObjectToSBError(PyObject * data) {
   lldb::SBError *sb_ptr = nullptr;
 
   int valid_cast =
       SWIG_ConvertPtr(data, (void **)&sb_ptr, SWIGTYPE_p_lldb__SBError, 0);
 
   if (valid_cast == -1)
     return NULL;

lldb/examples/python/scripted_process/scripted_multiplexer.py

+from abc import ABCMeta, abstractmethod
+
+import lldb
+
+class ScriptedMultiplexer(metaclass=ABCMeta):
+
+    """
+    The base class for a scripted multiplexer.
+
+    Most of the base class methods are `@abstractmethod` that need to be
+    overwritten by the inheriting class.
+
+    DISCLAIMER: THIS INTERFACE IS STILL UNDER DEVELOPMENT AND NOT STABLE.
+                THE METHODS EXPOSED MIGHT CHANGE IN THE FUTURE.
+    """
+
+    driving_process = None
+
+    @abstractmethod
+    def __init__(self, exe_ctx, args):
+        """ Construct a scripted process.
+
+        Args:
+            exe_ctx (lldb.SBExecutionContext): The execution context for the scripted process.
+            args (lldb.SBStructuredData): A Dictionary holding arbitrary
+                key/value pairs used by the scripted process.
+        """
+        process = None
+        if isinstance(exe_ctx, lldb.SBExecutionContext):
+            process = exe_ctx.process
+        if process and process.IsValid():
+            self.driving_process = process
+
+    @abstractmethod
+    def filter_event(self, event : lldb.SBEvent) -> lldb.SBProcess:
+        """ Get a dictionary containing the process capabilities.
+
+        Returns:
+            Dict[str:bool]: The dictionary of capability, with the capability
+            name as the key and a boolean flag as the value.
+            The dictionary can be empty.
+        """
+        pass
+

lldb/examples/python/scripted_process/scripted_process.py

def get_process_metadata(self):
         """ Get some metadata for the scripted process.
 
         Returns:
             Dict: A dictionary containing metadata for the scripted process.
                   None if the process as no metadata.
         """
         return self.metadata
 
+    def get_scripted_multiplexer(self):
+        """ Get the scripted process multiplexer class name and driving target
+        index in a dictionary.
+
+        Returns:
+            Dict: A dictionary containing scripted multiplexer information.
+                  None if the process is not multiplexed.
+        """
+        return None
+
 class ScriptedThread(metaclass=ABCMeta):
 
     """
     The base class for a scripted thread.
 
     Most of the base class methods are `@abstractmethod` that need to be
     overwritten by the inheriting class.
 

lldb/include/lldb/API/SBEvent.h

 //===-- SBEvent.h -----------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_API_SBEVENT_H
 #define LLDB_API_SBEVENT_H
 
 #include "lldb/API/SBDefines.h"
 
 #include <cstdio>
 #include <vector>
 
+namespace lldb_private {
+class ScriptInterpreter;
+}
+
 namespace lldb {
 
 class SBBroadcaster;
 
 class LLDB_API SBEvent {
 public:
   SBEvent();
 
protected:
   friend class SBBroadcaster;
   friend class SBBreakpoint;
   friend class SBDebugger;
   friend class SBProcess;
   friend class SBTarget;
   friend class SBThread;
   friend class SBWatchpoint;
 
+  friend class lldb_private::ScriptInterpreter;
+
   lldb::EventSP &GetSP() const;
 
   void reset(lldb::EventSP &event_sp);
 
   void reset(lldb_private::Event *event);
 
   lldb_private::Event *get() const;
 
 private:
   mutable lldb::EventSP m_event_sp;
   mutable lldb_private::Event *m_opaque_ptr = nullptr;
 };
 
 } // namespace lldb
 
 #endif // LLDB_API_SBEVENT_H

lldb/include/lldb/Core/Debugger.h

 #include "lldb/Core/FormatEntity.h"
 #include "lldb/Core/IOHandler.h"
 #include "lldb/Core/SourceManager.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/UserSettingsController.h"
 #include "lldb/Host/HostThread.h"
 #include "lldb/Host/Terminal.h"
 #include "lldb/Target/ExecutionContext.h"
+#include "lldb/Target/Multiplexer.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/TargetList.h"
 #include "lldb/Utility/Broadcaster.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/UserID.h"
 #include "lldb/lldb-defines.h"
public:
   Status RunREPL(lldb::LanguageType language, const char *repl_options);
 
   // This is for use in the command interpreter, when you either want the
   // selected target, or if no target is present you want to prime the dummy
   // target with entities that will be copied over to new targets.
   Target &GetSelectedOrDummyTarget(bool prefer_dummy = false);
   Target &GetDummyTarget() { return *m_dummy_target_sp; }
 
+  lldb::MultiplexerSP GetMultiplexer() const { return m_multiplexer_sp; }
+  void SetMultiplexer(lldb::MultiplexerSP mux_sp);
+
   lldb::BroadcasterManagerSP GetBroadcasterManager() {
     return m_broadcaster_manager_sp;
   }
 
   /// Shared thread poll. Use only with ThreadPoolTaskGroup.
   static llvm::ThreadPool &GetThreadPool();
 
   /// Report warning events.
protected:
   LoadedPluginsList m_loaded_plugins;
   HostThread m_event_handler_thread;
   HostThread m_io_handler_thread;
   Broadcaster m_sync_broadcaster; ///< Private debugger synchronization.
   Broadcaster m_broadcaster;      ///< Public Debugger event broadcaster.
   lldb::ListenerSP m_forward_listener_sp;
   llvm::once_flag m_clear_once;
   lldb::TargetSP m_dummy_target_sp;
+  lldb::MultiplexerSP m_multiplexer_sp;
 
   // Events for m_sync_broadcaster
   enum {
     eBroadcastBitEventThreadIsListening = (1 << 0),
   };
 
 private:
   // Use Debugger::CreateInstance() to get a shared pointer to a new debugger

lldb/include/lldb/Interpreter/ScriptInterpreter.h

 //===-- ScriptInterpreter.h -------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_INTERPRETER_SCRIPTINTERPRETER_H
 #define LLDB_INTERPRETER_SCRIPTINTERPRETER_H
 
 #include "lldb/API/SBAttachInfo.h"
 #include "lldb/API/SBData.h"
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBError.h"
+#include "lldb/API/SBEvent.h"
 #include "lldb/API/SBLaunchInfo.h"
 #include "lldb/API/SBMemoryRegionInfo.h"
 #include "lldb/API/SBProcess.h"
 #include "lldb/API/SBTarget.h"
 #include "lldb/Breakpoint/BreakpointOptions.h"
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Core/SearchFilter.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/ThreadedCommunication.h"
 #include "lldb/Host/PseudoTerminal.h"
+#include "lldb/Interpreter/ScriptedMultiplexerInterface.h"
 #include "lldb/Interpreter/ScriptedPlatformInterface.h"
 #include "lldb/Interpreter/ScriptedProcessInterface.h"
 #include "lldb/Utility/Broadcaster.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StructuredData.h"
 #include "lldb/lldb-private.h"
 #include <optional>
 
enum ScriptReturnType {
     eScriptReturnTypeOpaqueObject
   };
 
   ScriptInterpreter(
       Debugger &debugger, lldb::ScriptLanguage script_lang,
       lldb::ScriptedProcessInterfaceUP scripted_process_interface_up =
           std::make_unique<ScriptedProcessInterface>(),
       lldb::ScriptedPlatformInterfaceUP scripted_platform_interface_up =
-          std::make_unique<ScriptedPlatformInterface>());
+          std::make_unique<ScriptedPlatformInterface>(),
+      lldb::ScriptedMultiplexerInterfaceUP scripted_multiplexer_interface_up =
+          std::make_unique<ScriptedMultiplexerInterface>());
 
   virtual StructuredData::DictionarySP GetInterpreterInfo();
 
   ~ScriptInterpreter() override = default;
 
   virtual bool Interrupt() { return false; }
 
   virtual bool ExecuteOneLine(
public:
   ScriptedProcessInterface &GetScriptedProcessInterface() {
     return *m_scripted_process_interface_up;
   }
 
   ScriptedPlatformInterface &GetScriptedPlatformInterface() {
     return *m_scripted_platform_interface_up;
   }
 
+  ScriptedMultiplexerInterface &GetScriptedMultiplexerInterface() {
+    return *m_scripted_multiplexer_interface_up;
+  }
+
   lldb::DataExtractorSP
   GetDataExtractorFromSBData(const lldb::SBData &data) const;
 
   Status GetStatusFromSBError(const lldb::SBError &error) const;
 
   lldb::ProcessSP
   GetOpaqueTypeFromSBProcess(const lldb::SBProcess &process) const;
 
   lldb::DebuggerSP
   GetOpaqueTypeFromSBDebugger(const lldb::SBDebugger &debugger) const;
 
   lldb::TargetSP GetOpaqueTypeFromSBTarget(const lldb::SBTarget &target) const;
 
   lldb::ProcessAttachInfoSP
   GetOpaqueTypeFromSBAttachInfo(const lldb::SBAttachInfo &attach_info) const;
 
   lldb::ProcessLaunchInfoSP
   GetOpaqueTypeFromSBLaunchInfo(const lldb::SBLaunchInfo &launch_info) const;
 
+  lldb::EventSP GetOpaqueTypeFromSBEvent(const lldb::SBEvent &event) const;
+
   std::optional<MemoryRegionInfo> GetOpaqueTypeFromSBMemoryRegionInfo(
       const lldb::SBMemoryRegionInfo &mem_region) const;
 
 protected:
   Debugger &m_debugger;
   lldb::ScriptLanguage m_script_lang;
   lldb::ScriptedProcessInterfaceUP m_scripted_process_interface_up;
   lldb::ScriptedPlatformInterfaceUP m_scripted_platform_interface_up;
+  lldb::ScriptedMultiplexerInterfaceUP m_scripted_multiplexer_interface_up;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_INTERPRETER_SCRIPTINTERPRETER_H

lldb/include/lldb/Interpreter/ScriptedMultiplexer.h

+//===-- ScriptedMultiplexer.h -------------------------------------*- C++
+//-*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_INTERPRETER_SCRIPTEDMULTIPLEXER_H
+#define LLDB_INTERPRETER_SCRIPTEDMULTIPLEXER_H
+
+// #include "lldb/Interpreter/ScriptedPlatformInterface.h"
+#include "lldb/Target/Multiplexer.h"
+#include "lldb/lldb-private.h"
+
+namespace lldb_private {
+
+class ScriptedMultiplexer : public Multiplexer {
+public:
+  ScriptedMultiplexer(llvm::StringRef managing_class, Process &driving_process);
+
+  ~ScriptedMultiplexer() override = default;
+
+  llvm::StringRef GetName() const override { return m_managing_class; };
+  lldb::ProcessSP FilterEvent(const lldb::EventSP event_sp) const override;
+
+protected:
+  std::string m_managing_class;
+
+private:
+  inline void CheckInterpreterAndScriptObject() const {
+    lldbassert(m_interpreter && "Invalid Script Interpreter.");
+    lldbassert(m_script_object_sp && "Invalid Script Object.");
+  }
+
+  ScriptedMultiplexerInterface &GetInterface() const;
+
+  static bool IsScriptLanguageSupported(lldb::ScriptLanguage language);
+
+  Debugger &m_debugger;
+  lldb_private::ScriptInterpreter *m_interpreter = nullptr;
+  lldb_private::StructuredData::ObjectSP m_script_object_sp = nullptr;
+};
+
+} // namespace lldb_private
+
+#endif // LLDB_INTERPRETER_SCRIPTEDMULTIPLEXER_H

lldb/include/lldb/Interpreter/ScriptedMultiplexerInterface.h

+//===-- ScriptedMultiplexerInterface.h ------------------------------*- C++
+//-*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_INTERPRETER_SCRIPTED_MUX_INTERFACE_H
+#define LLDB_INTERPRETER_SCRIPTED_MUX_INTERFACE_H
+
+#include "lldb/Interpreter/ScriptedInterface.h"
+
+#include "lldb/lldb-private.h"
+
+namespace lldb_private {
+class ScriptedMultiplexerInterface : virtual public ScriptedInterface {
+public:
+  StructuredData::GenericSP
+  CreatePluginObject(llvm::StringRef class_name, ExecutionContext &exe_ctx,
+                     StructuredData::DictionarySP args_sp,
+                     StructuredData::Generic *script_obj = nullptr) override {
+    return {};
+  }
+
+  virtual lldb::ProcessSP FilterEvent(lldb::EventSP event_sp) { return {}; }
+};
+} // namespace lldb_private
+
+#endif // LLDB_INTERPRETER_SCRIPTED_MUX_INTERFACE_H

lldb/include/lldb/Interpreter/ScriptedProcessInterface.h

public:
   }
 
   virtual StructuredData::ArraySP GetLoadedImages() { return {}; }
 
   virtual lldb::pid_t GetProcessID() { return LLDB_INVALID_PROCESS_ID; }
 
   virtual bool IsAlive() { return true; }
 
+  virtual StructuredData::DictionarySP GetMetadata() { return {}; }
+
   virtual std::optional<std::string> GetScriptedThreadPluginName() {
     return std::nullopt;
   }
 
-  virtual StructuredData::DictionarySP GetMetadata() { return {}; }
+  virtual StructuredData::DictionarySP GetScriptedMultiplexer() { return {}; }
 
 protected:
   friend class ScriptedThread;
   virtual lldb::ScriptedThreadInterfaceSP CreateScriptedThreadInterface() {
     return {};
   }
 };
 

lldb/include/lldb/Target/Multiplexer.h

+//===-- Multiplexer.h ----------------------------------------------*- C++
+//-*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_TARGET_MULTIPLEXER_H
+#define LLDB_TARGET_MULTIPLEXER_H
+
+#include <map>
+
+#include "lldb/Interpreter/ScriptedProcessInterface.h"
+#include "lldb/Target/Process.h"
+#include "lldb/Utility/Listener.h"
+#include "lldb/lldb-public.h"
+
+namespace lldb_private {
+
+/// \class Multiplexer Multiplexer.h "lldb/Target/Multiplexer.h"
+/// A plug-in interface definition class for debug multiplexer that
+/// includes many multiplexer abilities such as:
+///     \li getting multiplexer information such as supported architectures,
+///         supported binary file formats and more
+///     \li launching new processes
+///     \li attaching to existing processes
+///     \li download/upload files
+///     \li execute shell commands
+///     \li listing and getting info for existing processes
+///     \li attaching and possibly debugging the multiplexer's kernel
+class Multiplexer {
+public:
+  /// Default Constructor
+  Multiplexer(Process &driving_process);
+  virtual ~Multiplexer() = default;
+
+  bool AddProcess(lldb::ProcessSP process_sp);
+  bool DropProcess(lldb::pid_t pid);
+
+  virtual llvm::StringRef GetName() const = 0;
+  virtual lldb::ProcessSP FilterEvent(const lldb::EventSP event_sp) const = 0;
+
+protected:
+  lldb::ProcessSP m_driving_process_sp = nullptr;
+  lldb::ListenerSP m_listener_sp = nullptr;
+  std::map<lldb::pid_t, lldb::ProcessSP> m_connected_processes;
+};
+
+} // namespace lldb_private
+
+#endif // LLDB_TARGET_MULTIPLEXER_H

lldb/include/lldb/lldb-forward.h

 class Materializer;
 class MemoryHistory;
 class MemoryRegionInfo;
 class MemoryRegionInfos;
 class Module;
 class ModuleList;
 class ModuleSpec;
 class ModuleSpecList;
+class Multiplexer;
 class ObjectContainer;
 class ObjectFile;
 class ObjectFileJITDelegate;
 class OperatingSystem;
 class OptionGroup;
 class OptionGroupOptions;
 class OptionGroupPlatform;
 class OptionValue;

 class RegisterCheckpoint;
 class RegisterContext;
 class RegisterValue;
 class RegularExpression;
 class RichManglingContext;
 class Scalar;
 class ScriptInterpreter;
 class ScriptInterpreterLocker;
+class ScriptedMultiplexerInterface;
 class ScriptedPlatformInterface;
 class ScriptedProcessInterface;
 class ScriptedThreadInterface;
 class ScriptedSyntheticChildren;
 class SearchFilter;
 class Section;
 class SectionList;
 class SectionLoadHistory;

 typedef std::unique_ptr<lldb_private::SystemRuntime> SystemRuntimeUP;
 typedef std::shared_ptr<lldb_private::Listener> ListenerSP;
 typedef std::weak_ptr<lldb_private::Listener> ListenerWP;
 typedef std::shared_ptr<lldb_private::MemoryHistory> MemoryHistorySP;
 typedef std::unique_ptr<lldb_private::MemoryRegionInfo> MemoryRegionInfoUP;
 typedef std::shared_ptr<lldb_private::MemoryRegionInfo> MemoryRegionInfoSP;
 typedef std::shared_ptr<lldb_private::Module> ModuleSP;
 typedef std::weak_ptr<lldb_private::Module> ModuleWP;
+typedef std::shared_ptr<lldb_private::Multiplexer> MultiplexerSP;
 typedef std::shared_ptr<lldb_private::ObjectFile> ObjectFileSP;
 typedef std::shared_ptr<lldb_private::ObjectContainer> ObjectContainerSP;
 typedef std::shared_ptr<lldb_private::ObjectFileJITDelegate>
     ObjectFileJITDelegateSP;
 typedef std::weak_ptr<lldb_private::ObjectFileJITDelegate>
     ObjectFileJITDelegateWP;
 typedef std::unique_ptr<lldb_private::OperatingSystem> OperatingSystemUP;
 typedef std::shared_ptr<lldb_private::OptionValue> OptionValueSP;

 typedef std::weak_ptr<lldb_private::Queue> QueueWP;
 typedef std::shared_ptr<lldb_private::QueueItem> QueueItemSP;
 typedef std::shared_ptr<lldb_private::REPL> REPLSP;
 typedef std::shared_ptr<lldb_private::RecognizedStackFrame>
     RecognizedStackFrameSP;
 typedef std::shared_ptr<lldb_private::ScriptSummaryFormat>
     ScriptSummaryFormatSP;
 typedef std::shared_ptr<lldb_private::ScriptInterpreter> ScriptInterpreterSP;
+typedef std::unique_ptr<lldb_private::ScriptedMultiplexerInterface>
+    ScriptedMultiplexerInterfaceUP;
 typedef std::unique_ptr<lldb_private::ScriptedPlatformInterface>
     ScriptedPlatformInterfaceUP;
 typedef std::unique_ptr<lldb_private::ScriptedProcessInterface>
     ScriptedProcessInterfaceUP;
 typedef std::shared_ptr<lldb_private::ScriptedThreadInterface>
     ScriptedThreadInterfaceSP;
 typedef std::shared_ptr<lldb_private::Section> SectionSP;
 typedef std::unique_ptr<lldb_private::SectionList> SectionListUP;

lldb/source/Core/Debugger.cpp

llvm::call_once(m_clear_once, [this]() {
     m_broadcaster_manager_sp->Clear();
 
     // Close the input file _before_ we close the input read communications
     // class as it does NOT own the input file, our m_input_file does.
     m_terminal_state.Clear();
     GetInputFile().Close();
 
     m_command_interpreter_up->Clear();
+    m_multiplexer_sp.reset();
   });
 }
 
 bool Debugger::GetCloseInputOnEOF() const {
   //    return m_input_comm.GetCloseOnEOF();
   return false;
 }
 
 void Debugger::SetCloseInputOnEOF(bool b) {
   //    m_input_comm.SetCloseOnEOF(b);
 }
 
+void Debugger::SetMultiplexer(lldb::MultiplexerSP mux_sp) {
+  if (m_multiplexer_sp)
+    ReportWarning(llvm::formatv("Replacing debugger multiplex {0} by {1}",
+                                m_multiplexer_sp->GetName(),
+                                mux_sp->GetName()));
+  m_multiplexer_sp = mux_sp;
+}
+
 bool Debugger::GetAsyncExecution() {
   return !m_command_interpreter_up->GetSynchronous();
 }
 
 void Debugger::SetAsyncExecution(bool async_execution) {
   m_command_interpreter_up->SetSynchronous(!async_execution);
 }
 

lldb/source/Interpreter/CMakeLists.txt

add_lldb_library(lldbInterpreter
   OptionValueString.cpp
   OptionValueUInt64.cpp
   OptionValueUUID.cpp
   OptionGroupVariable.cpp
   OptionGroupWatchpoint.cpp
   Options.cpp
   Property.cpp
   ScriptInterpreter.cpp
+  ScriptedMultiplexer.cpp
 
   LINK_LIBS
     lldbCommands
     lldbCore
     lldbDataFormatters
     lldbHost
     lldbTarget
     lldbUtility

lldb/source/Interpreter/ScriptInterpreter.cpp

 #include <string>
 
 using namespace lldb;
 using namespace lldb_private;
 
 ScriptInterpreter::ScriptInterpreter(
     Debugger &debugger, lldb::ScriptLanguage script_lang,
     lldb::ScriptedProcessInterfaceUP scripted_process_interface_up,
-    lldb::ScriptedPlatformInterfaceUP scripted_platform_interface_up)
+    lldb::ScriptedPlatformInterfaceUP scripted_platform_interface_up,
+    lldb::ScriptedMultiplexerInterfaceUP scripted_multiplexer_interface_up)
     : m_debugger(debugger), m_script_lang(script_lang),
       m_scripted_process_interface_up(std::move(scripted_process_interface_up)),
       m_scripted_platform_interface_up(
-          std::move(scripted_platform_interface_up)) {}
+          std::move(scripted_platform_interface_up)),
+      m_scripted_multiplexer_interface_up(
+          std::move(scripted_multiplexer_interface_up)) {}
 
 void ScriptInterpreter::CollectDataForBreakpointCommandCallback(
     std::vector<std::reference_wrapper<BreakpointOptions>> &bp_options_vec,
     CommandReturnObject &result) {
   result.AppendError(
       "This script interpreter does not support breakpoint callbacks.");
 }
 

 }
 
 lldb::ProcessLaunchInfoSP ScriptInterpreter::GetOpaqueTypeFromSBLaunchInfo(
     const lldb::SBLaunchInfo &launch_info) const {
   return std::make_shared<ProcessLaunchInfo>(
       *reinterpret_cast<ProcessLaunchInfo *>(launch_info.m_opaque_sp.get()));
 }
 
+lldb::EventSP
+ScriptInterpreter::GetOpaqueTypeFromSBEvent(const lldb::SBEvent &event) const {
+  return event.m_event_sp;
+}
+
 Status
 ScriptInterpreter::GetStatusFromSBError(const lldb::SBError &error) const {
   if (error.m_opaque_up)
     return *error.m_opaque_up;
 
   return Status();
 }
 

lldb/source/Interpreter/ScriptedMultiplexer.cpp

+//===-- ScriptedMultiplexer.cpp -------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Interpreter/ScriptedMultiplexer.h"
+#include "lldb/Core/Debugger.h"
+#include "lldb/Interpreter/ScriptInterpreter.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+ScriptedMultiplexer::ScriptedMultiplexer(llvm::StringRef managing_class,
+                                         Process &driving_process)
+    : Multiplexer(driving_process), m_managing_class(managing_class.str()),
+      m_debugger(driving_process.GetTarget().GetDebugger()) {
+
+  Status error;
+  m_interpreter = m_debugger.GetScriptInterpreter();
+
+  if (!m_interpreter) {
+    ScriptedInterface::ErrorWithMessage<bool>(
+        LLVM_PRETTY_FUNCTION, "Debugger has no Script Interpreter", error);
+    return;
+  }
+
+  ExecutionContext exe_ctx(driving_process.shared_from_this());
+
+  StructuredData::GenericSP object_sp =
+      GetInterface().CreatePluginObject(managing_class, exe_ctx, nullptr);
+
+  if (!object_sp || !object_sp->IsValid()) {
+    error.SetErrorStringWithFormat("ScriptedProcess::%s () - ERROR: %s",
+                                   __FUNCTION__,
+                                   "Failed to create valid script object");
+    return;
+  }
+
+  m_script_object_sp = object_sp;
+}
+
+ScriptedMultiplexerInterface &ScriptedMultiplexer::GetInterface() const {
+  return m_interpreter->GetScriptedMultiplexerInterface();
+}
+
+lldb::ProcessSP
+ScriptedMultiplexer::FilterEvent(const lldb::EventSP event_sp) const {
+  // FIXME: Call into ScriptedMultiplexerInterface
+  return m_driving_process_sp;
+}

lldb/source/Plugins/Process/scripted/ScriptedProcess.h

protected:
   void Clear();
 
   bool DoUpdateThreadList(ThreadList &old_thread_list,
                           ThreadList &new_thread_list) override;
 
   Status DoGetMemoryRegionInfo(lldb::addr_t load_addr,
                                MemoryRegionInfo &range_info) override;
 
+  bool Multiplex(StructuredData::DictionarySP dict_sp, Status &error);
+
   Status DoAttach();
 
 private:
   friend class ScriptedThread;
 
   inline void CheckInterpreterAndScriptObject() const {
     lldbassert(m_interpreter && "Invalid Script Interpreter.");
     lldbassert(m_script_object_sp && "Invalid Script Object.");

lldb/source/Plugins/Process/scripted/ScriptedProcess.cpp

 #include "lldb/Core/Progress.h"
 #include "lldb/Host/OptionParser.h"
 #include "lldb/Host/ThreadLauncher.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Interpreter/OptionGroupBoolean.h"
 #include "lldb/Interpreter/ScriptInterpreter.h"
 #include "lldb/Interpreter/ScriptedMetadata.h"
+#include "lldb/Interpreter/ScriptedMultiplexer.h"
 #include "lldb/Symbol/LocateSymbolFile.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Target/Queue.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Utility/LLDBLog.h"
 #include "lldb/Utility/State.h"
 
 #include "llvm/Support/ThreadPool.h"
ScriptedProcess::ScriptedProcess(lldb::TargetSP target_sp,
   if (!object_sp || !object_sp->IsValid()) {
     error.SetErrorStringWithFormat("ScriptedProcess::%s () - ERROR: %s",
                                    __FUNCTION__,
                                    "Failed to create valid script object");
     return;
   }
 
   m_script_object_sp = object_sp;
+
+  // Setup multiplexer
+  if (auto dict_sp = GetInterface().GetScriptedMultiplexer())
+    Multiplex(dict_sp, error);
 }
 
 ScriptedProcess::~ScriptedProcess() {
   Clear();
   // We need to call finalize on the process before destroying ourselves to
   // make sure all of the broadcaster cleanup goes as planned. If we destruct
   // this class, then Process::~Process() might have problems trying to fully
   // destroy the broadcaster.
   Finalize();
 }
 
 void ScriptedProcess::Initialize() {
   static llvm::once_flag g_once_flag;
 
   llvm::call_once(g_once_flag, []() {
     PluginManager::RegisterPlugin(GetPluginNameStatic(),
                                   GetPluginDescriptionStatic(), CreateInstance);
   });
 }
 
 void ScriptedProcess::Terminate() {
   PluginManager::UnregisterPlugin(ScriptedProcess::CreateInstance);
 }
 
+bool ScriptedProcess::Multiplex(StructuredData::DictionarySP dict_sp,
+                                Status &error) {
+  // sanitize dictionary
+  llvm::StringRef managing_class;
+  if (!dict_sp->GetValueForKeyAsString("managing_class", managing_class))
+    return ScriptedInterface::ErrorWithMessage<bool>(
+        LLVM_PRETTY_FUNCTION,
+        "Missing key 'managing_class' in Scripted Multiplexer dictionary",
+        error);
+  uint32_t driving_target_index = UINT32_MAX;
+  if (!dict_sp->GetValueForKeyAsInteger("driving_target_idx",
+                                        driving_target_index))
+    return ScriptedInterface::ErrorWithMessage<bool>(
+        LLVM_PRETTY_FUNCTION,
+        "Missing key 'driving_target_idx' in Scripted Multiplexer dictionary",
+        error);
+
+  Debugger &debugger = GetTarget().GetDebugger();
+  TargetSP target_sp =
+      debugger.GetTargetList().GetTargetAtIndex(driving_target_index);
+  if (!target_sp || !target_sp->IsValid())
+    return ScriptedInterface::ErrorWithMessage<bool>(
+        LLVM_PRETTY_FUNCTION, "Provided driving target is invalid.", error);
+  ProcessSP driving_process_sp = target_sp->GetProcessSP();
+  if (!driving_process_sp || !driving_process_sp->IsValid())
+    return ScriptedInterface::ErrorWithMessage<bool>(
+        LLVM_PRETTY_FUNCTION, "Provided driving target has invalid process.",
+        error);
+
+  if (!debugger.GetMultiplexer()) {
+    debugger.SetMultiplexer(lldb::MultiplexerSP(
+        new ScriptedMultiplexer(managing_class, *driving_process_sp)));
+  }
+
+  debugger.GetMultiplexer()->AddProcess(shared_from_this());
+
+  return error.Success();
+}
+
 Status ScriptedProcess::DoLoadCore() {
   ProcessLaunchInfo launch_info = GetTarget().GetProcessLaunchInfo();
 
   return DoLaunch(nullptr, launch_info);
 }
 
 Status ScriptedProcess::DoLaunch(Module *exe_module,
                                  ProcessLaunchInfo &launch_info) {

lldb/source/Plugins/ScriptInterpreter/Python/CMakeLists.txt

if (LLDB_ENABLE_LIBEDIT)
   list(APPEND LLDB_LIBEDIT_LIBS LibEdit::LibEdit)
 endif()
 
 add_lldb_library(lldbPluginScriptInterpreterPython PLUGIN
   PythonDataObjects.cpp
   PythonReadline.cpp
   ScriptInterpreterPython.cpp
   ScriptedPythonInterface.cpp
+  ScriptedMultiplexerPythonInterface.cpp
   ScriptedProcessPythonInterface.cpp
   ScriptedThreadPythonInterface.cpp
   ScriptedPlatformPythonInterface.cpp
 
   LINK_LIBS
     lldbBreakpoint
     lldbCore
     lldbDataFormatters

lldb/source/Plugins/ScriptInterpreter/Python/SWIGPythonBridge.h

 PythonObject ToSWIGWrapper(lldb::DebuggerSP debugger_sp);
 PythonObject ToSWIGWrapper(lldb::WatchpointSP watchpoint_sp);
 PythonObject ToSWIGWrapper(lldb::BreakpointLocationSP bp_loc_sp);
 PythonObject ToSWIGWrapper(lldb::ExecutionContextRefSP ctx_sp);
 PythonObject ToSWIGWrapper(const TypeSummaryOptions &summary_options);
 PythonObject ToSWIGWrapper(const SymbolContext &sym_ctx);
 PythonObject ToSWIGWrapper(lldb::ProcessAttachInfoSP attach_info_sp);
 PythonObject ToSWIGWrapper(lldb::ProcessLaunchInfoSP launch_info_sp);
+PythonObject ToSWIGWrapper(lldb::EventSP event_sp);
 PythonObject ToSWIGWrapper(std::unique_ptr<lldb::SBValue> value_sb);
 PythonObject ToSWIGWrapper(std::unique_ptr<lldb::SBStream> stream_sb);
 PythonObject ToSWIGWrapper(std::unique_ptr<lldb::SBStructuredData> data_sb);
 
 python::ScopedPythonObject<lldb::SBCommandReturnObject>
 ToSWIGWrapper(CommandReturnObject &cmd_retobj);
 python::ScopedPythonObject<lldb::SBEvent> ToSWIGWrapper(Event *event);
 
 } // namespace python
 
 void *LLDBSWIGPython_CastPyObjectToSBData(PyObject *data);
 void *LLDBSWIGPython_CastPyObjectToSBProcess(PyObject *data);
 void *LLDBSWIGPython_CastPyObjectToSBDebugger(PyObject *data);
 void *LLDBSWIGPython_CastPyObjectToSBTarget(PyObject *data);
 void *LLDBSWIGPython_CastPyObjectToSBAttachInfo(PyObject *data);
 void *LLDBSWIGPython_CastPyObjectToSBLaunchInfo(PyObject *data);
+void *LLDBSWIGPython_CastPyObjectToSBEvent(PyObject *data);
 void *LLDBSWIGPython_CastPyObjectToSBError(PyObject *data);
 void *LLDBSWIGPython_CastPyObjectToSBValue(PyObject *data);
 void *LLDBSWIGPython_CastPyObjectToSBMemoryRegionInfo(PyObject *data);
 
 // These prototypes are the Pythonic implementations of the required callbacks.
 // Although these are scripting-language specific, their definition depends on
 // the public API.
 

lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp

 
 // LLDB Python header must be included first
 #include "lldb-python.h"
 
 #include "PythonDataObjects.h"
 #include "PythonReadline.h"
 #include "SWIGPythonBridge.h"
 #include "ScriptInterpreterPythonImpl.h"
+#include "ScriptedMultiplexerPythonInterface.h"
 #include "ScriptedPlatformPythonInterface.h"
 #include "ScriptedProcessPythonInterface.h"
 
 #include "lldb/API/SBError.h"
 #include "lldb/API/SBFrame.h"
 #include "lldb/API/SBValue.h"
 #include "lldb/Breakpoint/StoppointCallbackContext.h"
 #include "lldb/Breakpoint/WatchpointOptions.h"
: ScriptInterpreterPython(debugger), m_saved_stdin(), m_saved_stdout(),
       m_dictionary_name(m_debugger.GetInstanceName().AsCString()),
       m_active_io_handler(eIOHandlerNone), m_session_is_active(false),
       m_pty_secondary_is_open(false), m_valid_session(true), m_lock_count(0),
       m_command_thread_state(nullptr) {
   m_scripted_process_interface_up =
       std::make_unique<ScriptedProcessPythonInterface>(*this);
   m_scripted_platform_interface_up =
       std::make_unique<ScriptedPlatformPythonInterface>(*this);
+  m_scripted_multiplexer_interface_up =
+      std::make_unique<ScriptedMultiplexerPythonInterface>(*this);
 
   m_dictionary_name.append("_dict");
   StreamString run_string;
   run_string.Printf("%s = dict()", m_dictionary_name.c_str());
 
   Locker locker(this, Locker::AcquireLock, Locker::FreeAcquiredLock);
   PyRun_SimpleString(run_string.GetData());
 

lldb/source/Plugins/ScriptInterpreter/Python/ScriptedMultiplexerPythonInterface.h

+//===-- ScriptedMultiplexerPythonInterface.h ------------------------*- C++
+//-*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_SCRIPTED_MUX_PYTHON_INTERFACE_H
+#define LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_SCRIPTED_MUX_PYTHON_INTERFACE_H
+
+#include "lldb/Host/Config.h"
+
+#if LLDB_ENABLE_PYTHON
+
+#include "ScriptedPythonInterface.h"
+#include "lldb/Interpreter/ScriptedMultiplexerInterface.h"
+#include <optional>
+
+namespace lldb_private {
+class ScriptedMultiplexerPythonInterface : public ScriptedMultiplexerInterface,
+                                           public ScriptedPythonInterface {
+public:
+  ScriptedMultiplexerPythonInterface(ScriptInterpreterPythonImpl &interpreter);
+
+  StructuredData::GenericSP
+  CreatePluginObject(llvm::StringRef class_name, ExecutionContext &exe_ctx,
+                     StructuredData::DictionarySP args_sp,
+                     StructuredData::Generic *script_obj = nullptr) override;
+
+  lldb::ProcessSP FilterEvent(lldb::EventSP event_sp) override;
+};
+} // namespace lldb_private
+
+#endif // LLDB_ENABLE_PYTHON
+#endif // LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_SCRIPTED_MUX_PYTHON_INTERFACE_H

lldb/source/Plugins/ScriptInterpreter/Python/ScriptedMultiplexerPythonInterface.cpp

+//===-- ScriptedMultiplexerPythonInterface.cpp ----------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Host/Config.h"
+#include "lldb/Utility/Log.h"
+#include "lldb/Utility/Status.h"
+#include "lldb/lldb-enumerations.h"
+
+#if LLDB_ENABLE_PYTHON
+
+// LLDB Python header must be included first
+#include "lldb-python.h"
+
+#include "SWIGPythonBridge.h"
+#include "ScriptInterpreterPythonImpl.h"
+#include "ScriptedMultiplexerPythonInterface.h"
+
+#include <optional>
+
+using namespace lldb;
+using namespace lldb_private;
+using namespace lldb_private::python;
+
+using Locker = ScriptInterpreterPythonImpl::Locker;
+
+ScriptedMultiplexerPythonInterface::ScriptedMultiplexerPythonInterface(
+    ScriptInterpreterPythonImpl &interpreter)
+    : ScriptedMultiplexerInterface(), ScriptedPythonInterface(interpreter) {}
+
+StructuredData::GenericSP
+ScriptedMultiplexerPythonInterface::CreatePluginObject(
+    llvm::StringRef class_name, ExecutionContext &exe_ctx,
+    StructuredData::DictionarySP args_sp, StructuredData::Generic *script_obj) {
+  if (class_name.empty())
+    return {};
+
+  StructuredDataImpl args_impl;
+  std::string error_string;
+
+  Locker py_lock(&m_interpreter, Locker::AcquireLock | Locker::NoSTDIN,
+                 Locker::FreeLock);
+
+  lldb::ExecutionContextRefSP exe_ctx_ref_sp =
+      std::make_shared<ExecutionContextRef>(exe_ctx);
+
+  PythonObject ret_val = LLDBSwigPythonCreateScriptedObject(
+      class_name.str().c_str(), m_interpreter.GetDictionaryName(),
+      exe_ctx_ref_sp, args_impl, error_string);
+
+  m_object_instance_sp =
+      StructuredData::GenericSP(new StructuredPythonObject(std::move(ret_val)));
+
+  return m_object_instance_sp;
+}
+
+lldb::ProcessSP
+ScriptedMultiplexerPythonInterface::FilterEvent(lldb::EventSP event_sp) {
+  Status error;
+  return Dispatch<ProcessSP>("filter_event", error, event_sp);
+}
+
+#endif

lldb/source/Plugins/ScriptInterpreter/Python/ScriptedProcessPythonInterface.h

lldb::DataExtractorSP ReadMemoryAtAddress(lldb::addr_t address, size_t size,
                                             Status &error) override;
 
   StructuredData::ArraySP GetLoadedImages() override;
 
   lldb::pid_t GetProcessID() override;
 
   bool IsAlive() override;
 
+  StructuredData::DictionarySP GetMetadata() override;
+
   std::optional<std::string> GetScriptedThreadPluginName() override;
 
-  StructuredData::DictionarySP GetMetadata() override;
+  StructuredData::DictionarySP GetScriptedMultiplexer() override;
 
 private:
   lldb::ScriptedThreadInterfaceSP CreateScriptedThreadInterface() override;
 };
 } // namespace lldb_private
 
 #endif // LLDB_ENABLE_PYTHON
 #endif // LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_SCRIPTEDPROCESSPYTHONINTERFACE_H

lldb/source/Plugins/ScriptInterpreter/Python/ScriptedProcessPythonInterface.cpp

StructuredData::DictionarySP dict =
       Dispatch<StructuredData::DictionarySP>("get_process_metadata", error);
 
   if (!CheckStructuredDataObject(LLVM_PRETTY_FUNCTION, dict, error))
     return {};
 
   return dict;
 }
 
+StructuredData::DictionarySP
+ScriptedProcessPythonInterface::GetScriptedMultiplexer() {
+  Status error;
+  StructuredData::DictionarySP dict =
+      Dispatch<StructuredData::DictionarySP>("get_scripted_multiplexer", error);
+
+  if (!CheckStructuredDataObject(LLVM_PRETTY_FUNCTION, dict, error))
+    return {};
+
+  return dict;
+}
+
 #endif

lldb/source/Plugins/ScriptInterpreter/Python/ScriptedPythonInterface.h

protected:
   python::PythonObject Transform(lldb::ProcessAttachInfoSP arg) {
     return python::ToSWIGWrapper(arg);
   }
 
   python::PythonObject Transform(lldb::ProcessLaunchInfoSP arg) {
     return python::ToSWIGWrapper(arg);
   }
 
+  python::PythonObject Transform(lldb::EventSP arg) {
+    return python::ToSWIGWrapper(arg);
+  }
+
   template <typename T, typename U>
   void ReverseTransform(T &original_arg, U transformed_arg, Status &error) {
     // If U is not a PythonObject, don't touch it!
     return;
   }
 
   template <typename T>
   void ReverseTransform(T &original_arg, python::PythonObject transformed_arg,

 lldb::ProcessAttachInfoSP ScriptedPythonInterface::ExtractValueFromPythonObject<
     lldb::ProcessAttachInfoSP>(python::PythonObject &p, Status &error);
 
 template <>
 lldb::ProcessLaunchInfoSP ScriptedPythonInterface::ExtractValueFromPythonObject<
     lldb::ProcessLaunchInfoSP>(python::PythonObject &p, Status &error);
 
 template <>
+lldb::EventSP
+ScriptedPythonInterface::ExtractValueFromPythonObject<lldb::EventSP>(
+    python::PythonObject &p, Status &error);
+
+template <>
 lldb::DataExtractorSP
 ScriptedPythonInterface::ExtractValueFromPythonObject<lldb::DataExtractorSP>(
     python::PythonObject &p, Status &error);
 
 template <>
 std::optional<MemoryRegionInfo>
 ScriptedPythonInterface::ExtractValueFromPythonObject<
     std::optional<MemoryRegionInfo>>(python::PythonObject &p, Status &error);
 
 } // namespace lldb_private
 
 #endif // LLDB_ENABLE_PYTHON
 #endif // LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_SCRIPTEDPYTHONINTERFACE_H

lldb/source/Plugins/ScriptInterpreter/Python/ScriptedPythonInterface.cpp

error.SetErrorString(
         "Couldn't cast lldb::SBLaunchInfo to lldb::ProcessLaunchInfoSP.");
     return nullptr;
   }
 
   return m_interpreter.GetOpaqueTypeFromSBLaunchInfo(*sb_launch_info);
 }
 
 template <>
+lldb::EventSP
+ScriptedPythonInterface::ExtractValueFromPythonObject<lldb::EventSP>(
+    python::PythonObject &p, Status &error) {
+  lldb::SBEvent *sb_event = reinterpret_cast<lldb::SBEvent *>(
+      LLDBSWIGPython_CastPyObjectToSBLaunchInfo(p.get()));
+
+  if (!sb_event) {
+    error.SetErrorString(
+        "Couldn't cast lldb::SBLaunchInfo to lldb::ProcessLaunchInfoSP.");
+    return nullptr;
+  }
+
+  return m_interpreter.GetOpaqueTypeFromSBEvent(*sb_event);
+}
+
+template <>
 std::optional<MemoryRegionInfo>
 ScriptedPythonInterface::ExtractValueFromPythonObject<
     std::optional<MemoryRegionInfo>>(python::PythonObject &p, Status &error) {
 
   lldb::SBMemoryRegionInfo *sb_mem_reg_info =
       reinterpret_cast<lldb::SBMemoryRegionInfo *>(
           LLDBSWIGPython_CastPyObjectToSBMemoryRegionInfo(p.get()));
 

lldb/source/Target/CMakeLists.txt

add_lldb_library(lldbTarget
   JITLoader.cpp
   JITLoaderList.cpp
   Language.cpp
   LanguageRuntime.cpp
   Memory.cpp
   MemoryHistory.cpp
   MemoryRegionInfo.cpp
   MemoryTagMap.cpp
+  Multiplexer.cpp
   ModuleCache.cpp
   OperatingSystem.cpp
   PathMappingList.cpp
   Platform.cpp
   Process.cpp
   ProcessTrace.cpp
   Queue.cpp
   QueueItem.cpp

lldb/source/Target/Multiplexer.cpp

+//===-- Multiplexer.cpp ---------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Target/Multiplexer.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+Multiplexer::Multiplexer(Process &driving_process)
+    : m_driving_process_sp(driving_process.shared_from_this()),
+      m_listener_sp(Listener::MakeListener("lldb.ScriptedPlatform")) {
+  m_driving_process_sp->HijackBroadcaster(m_listener_sp);
+}
+
+bool Multiplexer::AddProcess(lldb::ProcessSP process_sp) {
+  if (!process_sp)
+    return false;
+  m_connected_processes[process_sp->GetID()] = process_sp;
+  return true;
+}
+
+bool Multiplexer::DropProcess(lldb::pid_t pid) {
+  if (pid == LLDB_INVALID_PROCESS_ID)
+    return false;
+  return static_cast<bool>(m_connected_processes.erase(pid));
+}

lldb/test/API/functionalities/scripted_multiplexer/Makefile

+CXX_SOURCES := main.cpp
+ENABLE_THREADS := YES
+
+override ARCH := $(shell uname -m)
+
+all: a.out
+
+include Makefile.rules

lldb/test/API/functionalities/scripted_multiplexer/TestScriptedMultiplexer.py

+"""
+Test python scripted process in lldb
+"""
+
+import os, shutil
+
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+from lldbsuite.test import lldbtest
+
+class ScriptedProcesTestCase(TestBase):
+
+    NO_DEBUG_INFO_TESTCASE = True
+
+    @skipUnlessDarwin
+    def test_python_plugin_package(self):
+        """Test that the lldb python module has a `plugins.scripted_process`
+        package."""
+        self.expect('script import lldb.plugins',
+                    substrs=["ModuleNotFoundError"], matching=False)
+
+        self.expect('script dir(lldb.plugins)',
+                    substrs=["scripted_process"])
+
+        self.expect('script import lldb.plugins.scripted_process',
+                    substrs=["ModuleNotFoundError"], matching=False)
+
+        self.expect('script dir(lldb.plugins.scripted_process)',
+                    substrs=["ScriptedProcess"])
+
+        self.expect('script from lldb.plugins.scripted_process import ScriptedProcess',
+                    substrs=["ImportError"], matching=False)
+
+        self.expect('script dir(ScriptedProcess)',
+                    substrs=["launch"])
+
+    def move_blueprint_to_dsym(self, blueprint_name):
+        blueprint_origin_path = os.path.join(self.getSourceDir(), blueprint_name)
+        dsym_bundle = self.getBuildArtifact("a.out.dSYM")
+        blueprint_destination_path = os.path.join(dsym_bundle, "Contents",
+                                                  "Resources", "Python")
+        if not os.path.exists(blueprint_destination_path):
+            os.mkdir(blueprint_destination_path)
+
+        blueprint_destination_path = os.path.join(blueprint_destination_path, "a_out.py")
+        shutil.copy(blueprint_origin_path, blueprint_destination_path)
+
+    @skipUnlessDarwin
+    def test_invalid_scripted_register_context(self):
+        """Test that we can launch an lldb scripted process with an invalid
+        Scripted Thread, with invalid register context."""
+        self.build()
+
+        os.environ['SKIP_SCRIPTED_PROCESS_LAUNCH'] = '1'
+        def cleanup():
+          del os.environ["SKIP_SCRIPTED_PROCESS_LAUNCH"]
+        self.addTearDownHook(cleanup)
+
+        self.runCmd("settings set target.load-script-from-symbol-file true")
+        self.move_blueprint_to_dsym('invalid_scripted_process.py')
+        target = self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
+        self.assertTrue(target, VALID_TARGET)
+        log_file = self.getBuildArtifact('thread.log')
+        self.runCmd("log enable lldb thread -f " + log_file)
+        self.assertTrue(os.path.isfile(log_file))
+
+        launch_info = lldb.SBLaunchInfo(None)
+        launch_info.SetProcessPluginName("ScriptedProcess")
+        launch_info.SetScriptedProcessClassName("a_out.InvalidScriptedProcess")
+        error = lldb.SBError()
+
+        process = target.Launch(launch_info, error)
+
+        self.assertSuccess(error)
+        self.assertTrue(process, PROCESS_IS_VALID)
+        self.assertEqual(process.GetProcessID(), 666)
+        self.assertEqual(process.GetNumThreads(), 0)
+
+        addr = 0x500000000
+        buff = process.ReadMemory(addr, 4, error)
+        self.assertEqual(buff, None)
+        self.assertTrue(error.Fail())
+        self.assertEqual(error.GetCString(), "This is an invalid scripted process!")
+
+        with open(log_file, 'r') as f:
+            log = f.read()
+
+        self.assertIn("Failed to get scripted thread registers data.", log)
+
+    @skipUnlessDarwin
+    def test_scripted_process_and_scripted_thread(self):
+        """Test that we can launch an lldb scripted process using the SBAPI,
+        check its process ID, read string from memory, check scripted thread
+        id, name stop reason and register context.
+        """
+        self.build()
+        target = self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
+        self.assertTrue(target, VALID_TARGET)
+
+        os.environ['SKIP_SCRIPTED_PROCESS_LAUNCH'] = '1'
+        def cleanup():
+          del os.environ["SKIP_SCRIPTED_PROCESS_LAUNCH"]
+        self.addTearDownHook(cleanup)
+
+        scripted_process_example_relpath = 'dummy_scripted_process.py'
+        self.runCmd("command script import " + os.path.join(self.getSourceDir(),
+                                                            scripted_process_example_relpath))
+
+        launch_info = lldb.SBLaunchInfo(None)
+        launch_info.SetProcessPluginName("ScriptedProcess")
+        launch_info.SetScriptedProcessClassName("dummy_scripted_process.DummyScriptedProcess")
+
+        error = lldb.SBError()
+        process = target.Launch(launch_info, error)
+        self.assertTrue(process and process.IsValid(), PROCESS_IS_VALID)
+        self.assertEqual(process.GetProcessID(), 42)
+        self.assertEqual(process.GetNumThreads(), 1)
+
+        addr = 0x500000000
+        message = "Hello, world!"
+        buff = process.ReadCStringFromMemory(addr, len(message) + 1, error)
+        self.assertSuccess(error)
+        self.assertEqual(buff, message)
+
+        thread = process.GetSelectedThread()
+        self.assertTrue(thread, "Invalid thread.")
+        self.assertEqual(thread.GetThreadID(), 0x19)
+        self.assertEqual(thread.GetName(), "DummyScriptedThread.thread-1")
+        self.assertStopReason(thread.GetStopReason(), lldb.eStopReasonSignal)
+
+        self.assertGreater(thread.GetNumFrames(), 0)
+
+        frame = thread.GetFrameAtIndex(0)
+        GPRs = None
+        register_set = frame.registers # Returns an SBValueList.
+        for regs in register_set:
+            if 'general purpose' in regs.name.lower():
+                GPRs = regs
+                break
+
+        self.assertTrue(GPRs, "Invalid General Purpose Registers Set")
+        self.assertGreater(GPRs.GetNumChildren(), 0)
+        for idx, reg in enumerate(GPRs, start=1):
+            if idx > 21:
+                break
+            self.assertEqual(idx, int(reg.value, 16))
+
+        self.assertTrue(frame.IsArtificial(), "Frame is not artificial")
+        pc = frame.GetPCAddress().GetLoadAddress(target)
+        self.assertEqual(pc, 0x0100001b00)

lldb/test/API/functionalities/scripted_multiplexer/main.cpp

+#include <functional>
+#include <thread>
+#include <vector>
+
+enum class Parity {
+  Even,
+  Odd,
+};
+
+void even_or_odd(size_t thread_id) {
+  while (true) {
+    // break here
+    Parity parity = static_cast<Parity>(thread_id % 2);
+  }
+}
+
+int main() {
+  std::vector<std::thread> threads;
+  for (size_t i = 0; i < 10; i++)
+    threads.push_back(std::thread(even_or_odd, i));
+
+  for (std::thread &thread : threads)
+    thread.join();
+
+  return 0;
+}

lldb/test/API/functionalities/scripted_multiplexer/multiplexed_scripted_process.py

+import os,json,struct,signal
+
+from typing import Any, Dict
+
+import lldb
+from lldb.plugins.scripted_process import ScriptedProcess
+from lldb.plugins.scripted_process import ScriptedThread
+
+class StackCoreScriptedProcess(ScriptedProcess):
+    def get_module_with_name(self, target, name):
+        for module in target.modules:
+            if name in module.GetFileSpec().GetFilename():
+                return module
+        return None
+
+    def __init__(self, exe_ctx: lldb.SBExecutionContext, args : lldb.SBStructuredData):
+        super().__init__(exe_ctx, args)
+
+        self.corefile_target = None
+        self.corefile_process = None
+
+        self.backing_target_idx = args.GetValueForKey("backing_target_idx")
+        if (self.backing_target_idx and self.backing_target_idx.IsValid()):
+            if self.backing_target_idx.GetType() == lldb.eStructuredDataTypeInteger:
+                idx = self.backing_target_idx.GetIntegerValue(42)
+            if self.backing_target_idx.GetType() == lldb.eStructuredDataTypeString:
+                idx = int(self.backing_target_idx.GetStringValue(100))
+            self.corefile_target = self.target.GetDebugger().GetTargetAtIndex(idx)
+            self.corefile_process = self.corefile_target.GetProcess()
+            for corefile_thread in self.corefile_process:
+                structured_data = lldb.SBStructuredData()
+                structured_data.SetFromJSON(json.dumps({
+                    "backing_target_idx" : idx,
+                    "thread_idx" : corefile_thread.GetIndexID()
+                }))
+
+                self.threads[corefile_thread.GetThreadID()] = StackCoreScriptedThread(self, structured_data)
+
+        if len(self.threads) == 2:
+            self.threads[len(self.threads) - 1].is_stopped = True
+
+        corefile_module = self.get_module_with_name(self.corefile_target,
+                                                    "libbaz.dylib")
+        if not corefile_module or not corefile_module.IsValid():
+            return
+        module_path = os.path.join(corefile_module.GetFileSpec().GetDirectory(),
+                                   corefile_module.GetFileSpec().GetFilename())
+        if not os.path.exists(module_path):
+            return
+        module_load_addr = corefile_module.GetObjectFileHeaderAddress().GetLoadAddress(self.corefile_target)
+
+        self.loaded_images.append({"path": module_path,
+                                   "load_addr": module_load_addr})
+
+    def get_memory_region_containing_address(self, addr: int) -> lldb.SBMemoryRegionInfo:
+        mem_region = lldb.SBMemoryRegionInfo()
+        error = self.corefile_process.GetMemoryRegionInfo(addr, mem_region)
+        if error.Fail():
+            return None
+        return mem_region
+
+    def get_thread_with_id(self, tid: int):
+        return {}
+
+    def get_registers_for_thread(self, tid: int):
+        return {}
+
+    def read_memory_at_address(self, addr: int, size: int, error: lldb.SBError) -> lldb.SBData:
+        data = lldb.SBData()
+        bytes_read = self.corefile_process.ReadMemory(addr, size, error)
+
+        if error.Fail():
+            return data
+
+        data.SetDataWithOwnership(error, bytes_read,
+                                  self.corefile_target.GetByteOrder(),
+                                  self.corefile_target.GetAddressByteSize())
+
+        return data
+
+    def get_loaded_images(self):
+        return self.loaded_images
+
+    def get_process_id(self) -> int:
+        return 42
+
+    def should_stop(self) -> bool:
+        return True
+
+    def is_alive(self) -> bool:
+        return True
+
+    def get_scripted_thread_plugin(self):
+        return StackCoreScriptedThread.__module__ + "." + StackCoreScriptedThread.__name__
+
+
+class StackCoreScriptedThread(ScriptedThread):
+    def __init__(self, process, args):
+        super().__init__(process, args)
+        backing_target_idx = args.GetValueForKey("backing_target_idx")
+        thread_idx = args.GetValueForKey("thread_idx")
+        self.is_stopped = False
+
+        def extract_value_from_structured_data(data, default_val):
+            if data and data.IsValid():
+                if data.GetType() == lldb.eStructuredDataTypeInteger:
+                    return data.GetIntegerValue(default_val)
+                if data.GetType() == lldb.eStructuredDataTypeString:
+                    return int(data.GetStringValue(100))
+            return None
+
+        #TODO: Change to Walrus operator (:=) with oneline if assignment
+        # Requires python 3.8
+        val = extract_value_from_structured_data(thread_idx, 0)
+        if val is not None:
+            self.idx = val
+
+        self.corefile_target = None
+        self.corefile_process = None
+        self.corefile_thread = None
+
+        #TODO: Change to Walrus operator (:=) with oneline if assignment
+        # Requires python 3.8
+        val = extract_value_from_structured_data(backing_target_idx, 42)
+        if val is not None:
+            self.corefile_target = self.target.GetDebugger().GetTargetAtIndex(val)
+            self.corefile_process = self.corefile_target.GetProcess()
+            self.corefile_thread = self.corefile_process.GetThreadByIndexID(self.idx)
+
+        if self.corefile_thread:
+            self.id = self.corefile_thread.GetThreadID()
+
+    def get_thread_id(self) -> int:
+        return self.id
+
+    def get_name(self) -> str:
+        return StackCoreScriptedThread.__name__ + ".thread-" + str(self.id)
+
+    def get_stop_reason(self) -> Dict[str, Any]:
+        stop_reason = { "type": lldb.eStopReasonInvalid, "data": {  }}
+
+        if self.corefile_thread and self.corefile_thread.IsValid() \
+            and self.get_thread_id() == self.corefile_thread.GetThreadID():
+            stop_reason["type"] = lldb.eStopReasonNone
+
+            if self.is_stopped:
+                if 'arm64' in self.scripted_process.arch:
+                    stop_reason["type"] = lldb.eStopReasonException
+                    stop_reason["data"]["desc"] = self.corefile_thread.GetStopDescription(100)
+                elif self.scripted_process.arch == 'x86_64':
+                    stop_reason["type"] = lldb.eStopReasonSignal
+                    stop_reason["data"]["signal"] = signal.SIGTRAP
+                else:
+                    stop_reason["type"] = self.corefile_thread.GetStopReason()
+
+        return stop_reason
+
+    def get_register_context(self) -> str:
+        if not self.corefile_thread or self.corefile_thread.GetNumFrames() == 0:
+            return None
+        frame = self.corefile_thread.GetFrameAtIndex(0)
+
+        GPRs = None
+        registerSet = frame.registers # Returns an SBValueList.
+        for regs in registerSet:
+            if 'general purpose' in regs.name.lower():
+                GPRs = regs
+                break
+
+        if not GPRs:
+            return None
+
+        for reg in GPRs:
+            self.register_ctx[reg.name] = int(reg.value, base=16)
+
+        return struct.pack("{}Q".format(len(self.register_ctx)), *self.register_ctx.values())
+
+
+def __lldb_init_module(debugger, dict):
+    if not 'SKIP_SCRIPTED_PROCESS_LAUNCH' in os.environ:
+        debugger.HandleCommand(
+            "process launch -C %s.%s" % (__name__,
+                                     StackCoreScriptedProcess.__name__))
+    else:
+        print("Name of the class that will manage the scripted process: '%s.%s'"
+                % (__name__, StackCoreScriptedProcess.__name__))

lldb/test/API/functionalities/scripted_platform/Makefile

+CXX_SOURCES := main.cpp
+ENABLE_THREADS := YES
+
+all: a.out
+
+include Makefile.rules

lldb/test/API/functionalities/scripted_platform/TestScriptedPlatform.py

+"""
+Test python scripted process in lldb
+"""
+
+import os, shutil
+
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+from lldbsuite.test import lldbtest
+
+class ScriptedProcesTestCase(TestBase):
+
+    NO_DEBUG_INFO_TESTCASE = True
+
+    def test_python_plugin_package(self):
+        """Test that the lldb python module has a `plugins.scripted_process`
+        package."""
+        self.expect('script import lldb.plugins',
+                    substrs=["ModuleNotFoundError"], matching=False)
+
+        self.expect('script dir(lldb.plugins)',
+                    substrs=["scripted_process"])
+
+        self.expect('script import lldb.plugins.scripted_process',
+                    substrs=["ModuleNotFoundError"], matching=False)
+
+        self.expect('script dir(lldb.plugins.scripted_process)',
+                    substrs=["ScriptedProcess"])
+
+        self.expect('script from lldb.plugins.scripted_process import ScriptedProcess',
+                    substrs=["ImportError"], matching=False)
+
+        self.expect('script dir(ScriptedProcess)',
+                    substrs=["launch"])
+
+    def move_blueprint_to_dsym(self, blueprint_name):
+        blueprint_origin_path = os.path.join(self.getSourceDir(), blueprint_name)
+        dsym_bundle = self.getBuildArtifact("a.out.dSYM")
+        blueprint_destination_path = os.path.join(dsym_bundle, "Contents",
+                                                  "Resources", "Python")
+        if not os.path.exists(blueprint_destination_path):
+            os.mkdir(blueprint_destination_path)
+
+        blueprint_destination_path = os.path.join(blueprint_destination_path, "a_out.py")
+        shutil.copy(blueprint_origin_path, blueprint_destination_path)
+
+    @skipUnlessDarwin
+    def test_invalid_scripted_register_context(self):
+        """Test that we can launch an lldb scripted process with an invalid
+        Scripted Thread, with invalid register context."""
+        self.build()
+
+        os.environ['SKIP_SCRIPTED_PROCESS_LAUNCH'] = '1'
+        def cleanup():
+          del os.environ["SKIP_SCRIPTED_PROCESS_LAUNCH"]
+        self.addTearDownHook(cleanup)
+
+        self.runCmd("settings set target.load-script-from-symbol-file true")
+        self.move_blueprint_to_dsym('invalid_scripted_process.py')
+        target = self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
+        self.assertTrue(target, VALID_TARGET)
+        log_file = self.getBuildArtifact('thread.log')
+        self.runCmd("log enable lldb thread -f " + log_file)
+        self.assertTrue(os.path.isfile(log_file))
+
+        launch_info = lldb.SBLaunchInfo(None)
+        launch_info.SetProcessPluginName("ScriptedProcess")
+        launch_info.SetScriptedProcessClassName("a_out.InvalidScriptedProcess")
+        error = lldb.SBError()
+
+        process = target.Launch(launch_info, error)
+
+        self.assertSuccess(error)
+        self.assertTrue(process, PROCESS_IS_VALID)
+        self.assertEqual(process.GetProcessID(), 666)
+        self.assertEqual(process.GetNumThreads(), 0)
+
+        addr = 0x500000000
+        buff = process.ReadMemory(addr, 4, error)
+        self.assertEqual(buff, None)
+        self.assertTrue(error.Fail())
+        self.assertEqual(error.GetCString(), "This is an invalid scripted process!")
+
+        with open(log_file, 'r') as f:
+            log = f.read()
+
+        self.assertIn("Failed to get scripted thread registers data.", log)
+
+    @skipUnlessDarwin
+    def test_scripted_process_and_scripted_thread(self):
+        """Test that we can launch an lldb scripted process using the SBAPI,
+        check its process ID, read string from memory, check scripted thread
+        id, name stop reason and register context.
+        """
+        self.build()
+        target = self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
+        self.assertTrue(target, VALID_TARGET)
+
+        os.environ['SKIP_SCRIPTED_PROCESS_LAUNCH'] = '1'
+        def cleanup():
+          del os.environ["SKIP_SCRIPTED_PROCESS_LAUNCH"]
+        self.addTearDownHook(cleanup)
+
+        scripted_process_example_relpath = 'dummy_scripted_process.py'
+        self.runCmd("command script import " + os.path.join(self.getSourceDir(),
+                                                            scripted_process_example_relpath))
+
+        launch_info = lldb.SBLaunchInfo(None)
+        launch_info.SetProcessPluginName("ScriptedProcess")
+        launch_info.SetScriptedProcessClassName("dummy_scripted_process.DummyScriptedProcess")
+
+        error = lldb.SBError()
+        process = target.Launch(launch_info, error)
+        self.assertTrue(process and process.IsValid(), PROCESS_IS_VALID)
+        self.assertEqual(process.GetProcessID(), 42)
+        self.assertEqual(process.GetNumThreads(), 1)
+
+        addr = 0x500000000
+        message = "Hello, world!"
+        buff = process.ReadCStringFromMemory(addr, len(message) + 1, error)
+        self.assertSuccess(error)
+        self.assertEqual(buff, message)
+
+        thread = process.GetSelectedThread()
+        self.assertTrue(thread, "Invalid thread.")
+        self.assertEqual(thread.GetThreadID(), 0x19)
+        self.assertEqual(thread.GetName(), "DummyScriptedThread.thread-1")
+        self.assertStopReason(thread.GetStopReason(), lldb.eStopReasonSignal)
+
+        self.assertGreater(thread.GetNumFrames(), 0)
+
+        frame = thread.GetFrameAtIndex(0)
+        GPRs = None
+        register_set = frame.registers # Returns an SBValueList.
+        for regs in register_set:
+            if 'general purpose' in regs.name.lower():
+                GPRs = regs
+                break
+
+        self.assertTrue(GPRs, "Invalid General Purpose Registers Set")
+        self.assertGreater(GPRs.GetNumChildren(), 0)
+        for idx, reg in enumerate(GPRs, start=1):
+            if idx > 21:
+                break
+            self.assertEqual(idx, int(reg.value, 16))
+
+        self.assertTrue(frame.IsArtificial(), "Frame is not artificial")
+        pc = frame.GetPCAddress().GetLoadAddress(target)
+        self.assertEqual(pc, 0x0100001b00)

lldb/test/API/functionalities/scripted_platform/main.cpp

+#include <iostream>
+#include <mutex>
+#include <thread>
+#include <vector>
+
+int main() {
+  size_t num_threads = 10;
+  std::vector<std::thread> threads;
+
+  std::mutex mutex;
+  std::unique_lock<std::mutex> lock(mutex);
+
+  for (size_t i = 0; i < num_threads; i++) {
+    std::cout << "Spawning thread " << i << std::endl;
+    threads.push_back(std::thread([]() {
+      while (true) {
+        ;
+      }
+    }));
+  }
+
+  for (auto &t : threads) {
+    if (t.joinable())
+      t.join();
+  }
+
+  lock.unlock();
+
+  return 0;
+}

lldb/unittests/ScriptInterpreter/Python/PythonTestSuite.cpp

 void *lldb_private::LLDBSWIGPython_CastPyObjectToSBAttachInfo(PyObject *data) {
   return nullptr;
 }
 
 void *lldb_private::LLDBSWIGPython_CastPyObjectToSBLaunchInfo(PyObject *data) {
   return nullptr;
 }
 
+void *lldb_private::LLDBSWIGPython_CastPyObjectToSBEvent(PyObject *data) {
+  return nullptr;
+}
+
 void *lldb_private::LLDBSWIGPython_CastPyObjectToSBError(PyObject *data) {
   return nullptr;
 }
 
 void *lldb_private::LLDBSWIGPython_CastPyObjectToSBValue(PyObject *data) {
   return nullptr;
 }