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

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

Differential Revision: https://reviews.llvm.org/D143308

Signed-off-by: Med Ismail Bennani <medismail.bennani@gmail.com>

1 files changed, 35 insertions, 11 deletions

diff --git a/lldb/test/API/functionalities/scripted_process/TestScriptedProcess.py b/lldb/test/API/functionalities/scripted_process/TestScriptedProcess.py
index 50ef5ffadd81..1078db8ad52a 100644
--- a/lldb/test/API/functionalities/scripted_process/TestScriptedProcess.py
+++ b/lldb/test/API/functionalities/scripted_process/TestScriptedProcess.py
@@ -98,8 +98,8 @@ class ScriptedProcesTestCase(TestBase):
         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():
@@ -115,12 +115,12 @@ class ScriptedProcesTestCase(TestBase):
         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'))
@@ -128,13 +128,37 @@ class ScriptedProcesTestCase(TestBase):
         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")
@@ -158,5 +182,5 @@ class ScriptedProcesTestCase(TestBase):
             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)