[lldb/Plugins] Fix method dispatch bug when using multiple scripted processes

[mib]

Summary

This patch should address a bug when a user have multiple scripted
processes in the same debugging session.

In order for the scripted process plugin to be able to call into the
scripted object instance methods to fetch the necessary data to
reconstruct its state, the scripted process plugin calls into a
scripted process interface, that has a reference to the created script
object instance.

However, prior to this patch, we only had a single instance of the
scripted process interface, living the script interpreter. So every time
a new scripted process plugin was created, it would overwrite the script
object instance that was held by the single scripted process interface
in the script interpreter.

That would cause all the method calls made to the scripted process
interface to be dispatched by the last instanciated script object
instance, which is wrong.

In order to prevent that, this patch moves the scripted process
interface reference to be help by the scripted process plugin itself.

rdar://104882562

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

[mib]

Fix test failure

[JDevlieghere]

Makes sense. LGTM.

lldb/include/lldb/Interpreter/ScriptInterpreter.h

enum ScriptReturnType {
     eScriptReturnTypeDouble,
     eScriptReturnTypeChar,
     eScriptReturnTypeCharStrOrNone,
     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>());
 
   virtual StructuredData::DictionarySP GetInterpreterInfo();
 
   ~ScriptInterpreter() override = default;
 
   virtual bool Interrupt() { return false; }
public:
   }
 
   static std::string LanguageToString(lldb::ScriptLanguage language);
 
   static lldb::ScriptLanguage StringToLanguage(const llvm::StringRef &string);
 
   lldb::ScriptLanguage GetLanguage() { return m_script_lang; }
 
-  ScriptedProcessInterface &GetScriptedProcessInterface() {
-    return *m_scripted_process_interface_up;
+  virtual lldb::ScriptedProcessInterfaceUP CreateScriptedProcessInterface() {
+    return std::make_unique<ScriptedProcessInterface>();
   }
 
   ScriptedPlatformInterface &GetScriptedPlatformInterface() {
     return *m_scripted_platform_interface_up;
   }
 
   lldb::DataExtractorSP
   GetDataExtractorFromSBData(const lldb::SBData &data) const;
 
   Status GetStatusFromSBError(const lldb::SBError &error) 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;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_INTERPRETER_SCRIPTINTERPRETER_H

lldb/include/lldb/Interpreter/ScriptedInterface.h

public:
   ScriptedInterface() = default;
   virtual ~ScriptedInterface() = default;
 
   virtual StructuredData::GenericSP
   CreatePluginObject(llvm::StringRef class_name, ExecutionContext &exe_ctx,
                      StructuredData::DictionarySP args_sp,
                      StructuredData::Generic *script_obj = nullptr) = 0;
 
+  StructuredData::GenericSP GetScriptObjectInstance() {
+    return m_object_instance_sp;
+  }
+
   template <typename Ret>
   static Ret ErrorWithMessage(llvm::StringRef caller_name,
                               llvm::StringRef error_msg, Status &error,
                               LLDBLog log_caterogy = LLDBLog::Process) {
     LLDB_LOGF(GetLog(log_caterogy), "%s ERROR = %s", caller_name.data(),
               error_msg.data());
     error.SetErrorString(llvm::Twine(caller_name + llvm::Twine(" ERROR = ") +
                                      llvm::Twine(error_msg))

lldb/source/Interpreter/ScriptInterpreter.cpp

 #include <optional>
 #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)
     : 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)) {}
 
 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/source/Plugins/Process/scripted/ScriptedProcess.h

bool DoUpdateThreadList(ThreadList &old_thread_list,
                           ThreadList &new_thread_list) override;
 
   Status DoGetMemoryRegionInfo(lldb::addr_t load_addr,
                                MemoryRegionInfo &range_info) override;
 
 private:
   friend class ScriptedThread;
 
-  void CheckInterpreterAndScriptObject() const;
+  inline void CheckScriptedInterface() const {
+    lldbassert(m_interface_up && "Invalid scripted process interface.");
+  }
+
   ScriptedProcessInterface &GetInterface() const;
   static bool IsScriptLanguageSupported(lldb::ScriptLanguage language);
 
   // Member variables.
   const ScriptedMetadata m_scripted_metadata;
-  lldb_private::ScriptInterpreter *m_interpreter = nullptr;
-  lldb_private::StructuredData::ObjectSP m_script_object_sp = nullptr;
-  //@}
+  lldb::ScriptedProcessInterfaceUP m_interface_up;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_SCRIPTED_PROCESS_H

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

 
 bool ScriptedProcess::IsScriptLanguageSupported(lldb::ScriptLanguage language) {
   llvm::ArrayRef<lldb::ScriptLanguage> supported_languages =
       llvm::ArrayRef(g_supported_script_languages);
 
   return llvm::is_contained(supported_languages, language);
 }
 
-void ScriptedProcess::CheckInterpreterAndScriptObject() const {
-  lldbassert(m_interpreter && "Invalid Script Interpreter.");
-  lldbassert(m_script_object_sp && "Invalid Script Object.");
-}
-
 lldb::ProcessSP ScriptedProcess::CreateInstance(lldb::TargetSP target_sp,
                                                 lldb::ListenerSP listener_sp,
                                                 const FileSpec *file,
                                                 bool can_connect) {
   if (!target_sp ||
       !IsScriptLanguageSupported(target_sp->GetDebugger().GetScriptLanguage()))
     return nullptr;
 
   ScriptedMetadata scripted_metadata(target_sp->GetProcessLaunchInfo());
 
   Status error;
   auto process_sp = std::shared_ptr<ScriptedProcess>(
       new ScriptedProcess(target_sp, listener_sp, scripted_metadata, error));
 
-  if (error.Fail() || !process_sp || !process_sp->m_script_object_sp ||
-      !process_sp->m_script_object_sp->IsValid()) {
+  if (error.Fail() || !process_sp || !process_sp->m_interface_up) {
     LLDB_LOGF(GetLog(LLDBLog::Process), "%s", error.AsCString());
     return nullptr;
   }
 
   return process_sp;
 }
 
 bool ScriptedProcess::CanDebug(lldb::TargetSP target_sp,
                                bool plugin_specified_by_name) {
   return true;
 }
 
 ScriptedProcess::ScriptedProcess(lldb::TargetSP target_sp,
                                  lldb::ListenerSP listener_sp,
                                  const ScriptedMetadata &scripted_metadata,
                                  Status &error)
     : Process(target_sp, listener_sp), m_scripted_metadata(scripted_metadata) {
 
   if (!target_sp) {
     error.SetErrorStringWithFormat("ScriptedProcess::%s () - ERROR: %s",
                                    __FUNCTION__, "Invalid target");
     return;
   }
 
-  m_interpreter = target_sp->GetDebugger().GetScriptInterpreter();
+  ScriptInterpreter *interpreter =
+      target_sp->GetDebugger().GetScriptInterpreter();
 
-  if (!m_interpreter) {
+  if (!interpreter) {
     error.SetErrorStringWithFormat("ScriptedProcess::%s () - ERROR: %s",
                                    __FUNCTION__,
                                    "Debugger has no Script Interpreter");
     return;
   }
 
+  // Create process instance interface
+  m_interface_up = interpreter->CreateScriptedProcessInterface();
+  if (!m_interface_up) {
+    error.SetErrorStringWithFormat(
+        "ScriptedProcess::%s () - ERROR: %s", __FUNCTION__,
+        "Script interpreter couldn't create Scripted Process Interface");
+    return;
+  }
+
   ExecutionContext exe_ctx(target_sp, /*get_process=*/false);
 
+  // Create process script object
   StructuredData::GenericSP object_sp = GetInterface().CreatePluginObject(
       m_scripted_metadata.GetClassName(), exe_ctx,
       m_scripted_metadata.GetArgsSP());
 
   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;
 }
 
 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.

 Status ScriptedProcess::DoLoadCore() {
   ProcessLaunchInfo launch_info = GetTarget().GetProcessLaunchInfo();
 
   return DoLaunch(nullptr, launch_info);
 }
 
 Status ScriptedProcess::DoLaunch(Module *exe_module,
                                  ProcessLaunchInfo &launch_info) {
-  CheckInterpreterAndScriptObject();
-
   /* FIXME: This doesn't reflect how lldb actually launches a process.
            In reality, it attaches to debugserver, then resume the process. */
   Status error = GetInterface().Launch();
   SetPrivateState(eStateRunning);
 
   if (error.Fail())
     return error;
 
   // TODO: Fetch next state from stopped event queue then send stop event
   //  const StateType state = SetThreadStopInfo(response);
   //  if (state != eStateInvalid) {
   //    SetPrivateState(state);
 
   SetPrivateState(eStateStopped);
 
   return {};
 }
 
 void ScriptedProcess::DidLaunch() {
-  CheckInterpreterAndScriptObject();
   m_pid = GetInterface().GetProcessID();
   GetLoadedDynamicLibrariesInfos();
 }
 
 Status ScriptedProcess::DoResume() {
-  CheckInterpreterAndScriptObject();
-
   Log *log = GetLog(LLDBLog::Process);
   // FIXME: Fetch data from thread.
   const StateType thread_resume_state = eStateRunning;
   LLDB_LOGF(log, "ScriptedProcess::%s thread_resume_state = %s", __FUNCTION__,
             StateAsCString(thread_resume_state));
 
   bool resume = (thread_resume_state == eStateRunning);
   assert(thread_resume_state == eStateRunning && "invalid thread resume state");
 
   Status error;
   if (resume) {
     LLDB_LOGF(log, "ScriptedProcess::%s sending resume", __FUNCTION__);
 
     SetPrivateState(eStateRunning);
     SetPrivateState(eStateStopped);
     error = GetInterface().Resume();
   }
 
   return error;
 }
 
 Status ScriptedProcess::DoStop() {
-  CheckInterpreterAndScriptObject();
-
   Log *log = GetLog(LLDBLog::Process);
 
   if (GetInterface().ShouldStop()) {
     SetPrivateState(eStateStopped);
     LLDB_LOGF(log, "ScriptedProcess::%s Immediate stop", __FUNCTION__);
     return {};
   }
 
   LLDB_LOGF(log, "ScriptedProcess::%s Delayed stop", __FUNCTION__);
   return GetInterface().Stop();
 }
 
 Status ScriptedProcess::DoDestroy() { return Status(); }
 
-bool ScriptedProcess::IsAlive() {
-  if (m_interpreter && m_script_object_sp)
-    return GetInterface().IsAlive();
-  return false;
-}
+bool ScriptedProcess::IsAlive() { return GetInterface().IsAlive(); }
 
 size_t ScriptedProcess::DoReadMemory(lldb::addr_t addr, void *buf, size_t size,
                                      Status &error) {
-  if (!m_interpreter)
-    return ScriptedInterface::ErrorWithMessage<size_t>(
-        LLVM_PRETTY_FUNCTION, "No interpreter.", error);
-
   lldb::DataExtractorSP data_extractor_sp =
       GetInterface().ReadMemoryAtAddress(addr, size, error);
 
   if (!data_extractor_sp || !data_extractor_sp->GetByteSize() || error.Fail())
     return 0;
 
   offset_t bytes_copied = data_extractor_sp->CopyByteOrderedData(
       0, data_extractor_sp->GetByteSize(), buf, size, GetByteOrder());
 
   if (!bytes_copied || bytes_copied == LLDB_INVALID_OFFSET)
     return ScriptedInterface::ErrorWithMessage<size_t>(
         LLVM_PRETTY_FUNCTION, "Failed to copy read memory to buffer.", error);
 
   return size;
 }
 
 ArchSpec ScriptedProcess::GetArchitecture() {
   return GetTarget().GetArchitecture();
 }
 
 Status ScriptedProcess::DoGetMemoryRegionInfo(lldb::addr_t load_addr,
                                               MemoryRegionInfo &region) {
-  CheckInterpreterAndScriptObject();
-
   Status error;
   if (auto region_or_err =
           GetInterface().GetMemoryRegionContainingAddress(load_addr, error))
     region = *region_or_err;
 
   return error;
 }
 
 Status ScriptedProcess::GetMemoryRegions(MemoryRegionInfos &region_list) {
-  CheckInterpreterAndScriptObject();
-
   Status error;
   lldb::addr_t address = 0;
 
   while (auto region_or_err =
              GetInterface().GetMemoryRegionContainingAddress(address, error)) {
     if (error.Fail())
       break;
 

 void ScriptedProcess::Clear() { Process::m_thread_list.Clear(); }
 
 bool ScriptedProcess::DoUpdateThreadList(ThreadList &old_thread_list,
                                          ThreadList &new_thread_list) {
   // TODO: Implement
   // This is supposed to get the current set of threads, if any of them are in
   // old_thread_list then they get copied to new_thread_list, and then any
   // actually new threads will get added to new_thread_list.
-
-  CheckInterpreterAndScriptObject();
   m_thread_plans.ClearThreadCache();
 
   Status error;
-  ScriptLanguage language = m_interpreter->GetLanguage();
-
-  if (language != eScriptLanguagePython)
-    return ScriptedInterface::ErrorWithMessage<bool>(
-        LLVM_PRETTY_FUNCTION,
-        llvm::Twine("ScriptInterpreter language (" +
-                    llvm::Twine(m_interpreter->LanguageToString(language)) +
-                    llvm::Twine(") not supported."))
-            .str(),
-        error);
-
   StructuredData::DictionarySP thread_info_sp = GetInterface().GetThreadsInfo();
 
   if (!thread_info_sp)
     return ScriptedInterface::ErrorWithMessage<bool>(
         LLVM_PRETTY_FUNCTION,
         "Couldn't fetch thread list from Scripted Process.", error);
 
   // Because `StructuredData::Dictionary` uses a `std::map<ConstString,
if (module_sp) {
     info.SetExecutableFile(GetTarget().GetExecutableModule()->GetFileSpec(),
                            add_exe_file_as_first_arg);
   }
   return true;
 }
 
 lldb_private::StructuredData::ObjectSP
 ScriptedProcess::GetLoadedDynamicLibrariesInfos() {
-  CheckInterpreterAndScriptObject();
-
   Status error;
   auto error_with_message = [&error](llvm::StringRef message) {
     return ScriptedInterface::ErrorWithMessage<bool>(LLVM_PRETTY_FUNCTION,
                                                      message.data(), error);
   };
 
   StructuredData::ArraySP loaded_images_sp = GetInterface().GetLoadedImages();
 
return ScriptedInterface::ErrorWithMessage<StructuredData::ObjectSP>(
         LLVM_PRETTY_FUNCTION, "Couldn't reload all images.", error);
 
   target.ModulesDidLoad(module_list);
 
   return loaded_images_sp;
 }
 
 lldb_private::StructuredData::DictionarySP ScriptedProcess::GetMetadata() {
-  CheckInterpreterAndScriptObject();
-
   StructuredData::DictionarySP metadata_sp = GetInterface().GetMetadata();
 
   Status error;
   if (!metadata_sp || !metadata_sp->GetSize())
     return ScriptedInterface::ErrorWithMessage<StructuredData::DictionarySP>(
         LLVM_PRETTY_FUNCTION, "No metadata.", error);
 
   return metadata_sp;
 }
 
 void ScriptedProcess::UpdateQueueListIfNeeded() {
-  CheckInterpreterAndScriptObject();
+  CheckScriptedInterface();
   for (ThreadSP thread_sp : Threads()) {
     if (const char *queue_name = thread_sp->GetQueueName()) {
       QueueSP queue_sp = std::make_shared<Queue>(
           m_process->shared_from_this(), thread_sp->GetQueueID(), queue_name);
       m_queue_list.AddQueue(queue_sp);
     }
   }
 }
 
 ScriptedProcessInterface &ScriptedProcess::GetInterface() const {
-  return m_interpreter->GetScriptedProcessInterface();
+  CheckScriptedInterface();
+  return *m_interface_up;
 }
 
 void *ScriptedProcess::GetImplementation() {
-  if (m_script_object_sp &&
-      m_script_object_sp->GetType() == eStructuredDataTypeGeneric)
-    return m_script_object_sp->GetAsGeneric()->GetValue();
+  StructuredData::GenericSP object_instance_sp =
+      GetInterface().GetScriptObjectInstance();
+  if (object_instance_sp &&
+      object_instance_sp->GetType() == eStructuredDataTypeGeneric)
+    return object_instance_sp->GetAsGeneric()->GetValue();
   return nullptr;
 }

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

 
 llvm::Expected<std::shared_ptr<ScriptedThread>>
 ScriptedThread::Create(ScriptedProcess &process,
                        StructuredData::Generic *script_object) {
   if (!process.IsValid())
     return llvm::createStringError(llvm::inconvertibleErrorCode(),
                                    "Invalid scripted process.");
 
-  process.CheckInterpreterAndScriptObject();
+  process.CheckScriptedInterface();
 
   auto scripted_thread_interface =
       process.GetInterface().CreateScriptedThreadInterface();
   if (!scripted_thread_interface)
     return llvm::createStringError(
         llvm::inconvertibleErrorCode(),
         "Failed to create scripted thread interface.");
 

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

: ScriptInterpreterPython(debugger), m_saved_stdin(), m_saved_stdout(),
       m_saved_stderr(), m_main_module(),
       m_session_dict(PyInitialValue::Invalid),
       m_sys_module_dict(PyInitialValue::Invalid), m_run_one_line_function(),
       m_run_one_line_str_global(),
       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_dictionary_name.append("_dict");
   StreamString run_string;
   run_string.Printf("%s = dict()", m_dictionary_name.c_str());
 
   Locker locker(this, Locker::AcquireLock, Locker::FreeAcquiredLock);
for (size_t i = 0; i < result_list.GetSize(); i++) {
       if (valobj_sp)
         result->Append(valobj_sp);
     }
     return result;
   }
   return ValueObjectListSP();
 }
 
+ScriptedProcessInterfaceUP
+ScriptInterpreterPythonImpl::CreateScriptedProcessInterface() {
+  return std::make_unique<ScriptedProcessPythonInterface>(*this);
+}
+
 StructuredData::GenericSP
 ScriptInterpreterPythonImpl::OSPlugin_CreatePluginObject(
     const char *class_name, lldb::ProcessSP process_sp) {
   if (class_name == nullptr || class_name[0] == '\0')
     return StructuredData::GenericSP();
 
   if (!process_sp)
     return StructuredData::GenericSP();

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

public:
 
   StructuredData::GenericSP
   CreateFrameRecognizer(const char *class_name) override;
 
   lldb::ValueObjectListSP
   GetRecognizedArguments(const StructuredData::ObjectSP &implementor,
                          lldb::StackFrameSP frame_sp) override;
 
+  lldb::ScriptedProcessInterfaceUP CreateScriptedProcessInterface() override;
+
   StructuredData::GenericSP
   OSPlugin_CreatePluginObject(const char *class_name,
                               lldb::ProcessSP process_sp) override;
 
   StructuredData::DictionarySP
   OSPlugin_RegisterInfo(StructuredData::ObjectSP os_plugin_object_sp) override;
 
   StructuredData::ArraySP

lldb/test/API/functionalities/scripted_process/TestScriptedProcess.py

class ScriptedProcesTestCase(TestBase):
 
     @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)
+        target_0 = self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
+        self.assertTrue(target_0, 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)
+        process_0 = target_0.Launch(launch_info, error)
+        self.assertTrue(process_0 and process_0.IsValid(), PROCESS_IS_VALID)
+        self.assertEqual(process_0.GetProcessID(), 42)
+        self.assertEqual(process_0.GetNumThreads(), 1)
 
-        py_impl = process.GetScriptedImplementation()
+        py_impl = process_0.GetScriptedImplementation()
         self.assertTrue(py_impl)
         self.assertTrue(isinstance(py_impl, dummy_scripted_process.DummyScriptedProcess))
         self.assertFalse(hasattr(py_impl, 'my_super_secret_member'))
         py_impl.my_super_secret_member = 42
         self.assertTrue(hasattr(py_impl, 'my_super_secret_member'))
         self.assertEqual(py_impl.my_super_secret_method(), 42)
 
+        # Try reading from target #0 process ...
+        addr = 0x500000000
+        message = "Hello, target 0"
+        buff = process_0.ReadCStringFromMemory(addr, len(message) + 1, error)
+        self.assertSuccess(error)
+        self.assertEqual(buff, message)
+
+        target_1 = self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
+        self.assertTrue(target_1, VALID_TARGET)
+        error = lldb.SBError()
+        process_1 = target_1.Launch(launch_info, error)
+        self.assertTrue(process_1 and process_1.IsValid(), PROCESS_IS_VALID)
+        self.assertEqual(process_1.GetProcessID(), 42)
+        self.assertEqual(process_1.GetNumThreads(), 1)
+
+        # ... then try reading from target #1 process ...
+        addr = 0x500000000
+        message = "Hello, target 1"
+        buff = process_1.ReadCStringFromMemory(addr, len(message) + 1, error)
+        self.assertSuccess(error)
+        self.assertEqual(buff, message)
+
+        # ... now, reading again from target #0 process to make sure the call
+        # gets dispatched to the right target.
         addr = 0x500000000
-        message = "Hello, world!"
-        buff = process.ReadCStringFromMemory(addr, len(message) + 1, error)
+        message = "Hello, target 0"
+        buff = process_0.ReadCStringFromMemory(addr, len(message) + 1, error)
         self.assertSuccess(error)
         self.assertEqual(buff, message)
 
-        thread = process.GetSelectedThread()
+        thread = process_0.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)
+        pc = frame.GetPCAddress().GetLoadAddress(target_0)
         self.assertEqual(pc, 0x0100001b00)

lldb/test/API/functionalities/scripted_process/dummy_scripted_process.py

class DummyScriptedProcess(ScriptedProcess):
 
     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:
+        debugger = self.target.GetDebugger()
+        index = debugger.GetIndexOfTarget(self.target)
         data = lldb.SBData().CreateDataFromCString(
                                     self.target.GetByteOrder(),
                                     self.target.GetCodeByteSize(),
-                                    "Hello, world!")
+                                    "Hello, target " + str(index))
 
         return data
 
     def get_loaded_images(self):
         return self.loaded_images
 
     def get_process_id(self) -> int:
         return 42