[lldb/bindings] Change ScriptedThread initializer parameters

[mib]

Summary

This patch changes the ScriptedThread initializer in couple of ways:

• It replaces the SBTarget parameter by a SBProcess (pointing to the ScriptedProcess that "owns" the ScriptedThread).
• It adds a reference to the ScriptedProcessInfo Dictionary, to pass arbitrary user-input to the ScriptedThread.

This patch also fixes the SWIG bindings methods that call the
ScriptedProcess and ScriptedThread initializers by passing all the
arguments to the appropriate PythonCallable object.

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

[mib]

Update after rebase.

[JDevlieghere]

Given that there's a 1:1 mapping between the target and the process, why did you change the interface as opposed to say extracting the process from the target?

lldb/examples/python/scripted_process/my_scripted_process.py

137

No newline at end of file

[mib]

In D112046#3081547, @JDevlieghere wrote:

Given that there's a 1:1 mapping between the target and the process, why did you change the interface as opposed to say extracting the process from the target?

A process is guaranteed to have a target, but the inverse is not true: if the process didn't launch or failed to launch, the target has no process.

[mib]

In D112046#3081556, @mib wrote:

In D112046#3081547, @JDevlieghere wrote:

Given that there's a 1:1 mapping between the target and the process, why did you change the interface as opposed to say extracting the process from the target?

A process is guaranteed to have a target, but the inverse is not true: if the process didn't launch or failed to launch, the target has no process.

To add more to this, I can't think of any reason, at the moment, to create a ScriptedThread if you don't have ScriptedProcess.

[JDevlieghere]

Makes sense. LGTM

lldb/bindings/python/python-wrapper.swig

if (!arg_info) {
             [&](const llvm::ErrorInfoBase &E) {
                 error_string.append(E.message());
             });
         Py_RETURN_NONE;
     }
 
     PythonObject result = {};
     if (arg_info.get().max_positional_args == 2) {
-        if (args_impl != nullptr) {
-           error_string.assign("args passed, but __init__ does not take an args dictionary");
-           Py_RETURN_NONE;
-        }
-        result = pfunc(target_arg, dict);
-    } else if (arg_info.get().max_positional_args >= 3) {
         PythonObject args_arg(PyRefType::Owned, SBTypeToSWIGWrapper(new lldb::SBStructuredData(args_impl)));
-        result = pfunc(target_arg, args_arg, dict);
+        result = pfunc(target_arg, args_arg);
     } else {
-        error_string.assign("wrong number of arguments in __init__, should be 2 or 3 (not including self)");
+        error_string.assign("wrong number of arguments in __init__, should be 2 (not including self)");
         Py_RETURN_NONE;
     }
 
     if (result.IsAllocated())
         return result.release();
     Py_RETURN_NONE;
 }
 
 SWIGEXPORT void*
 LLDBSwigPythonCreateScriptedThread
 (
     const char *python_class_name,
     const char *session_dictionary_name,
-    const lldb::TargetSP& target_sp,
+    const lldb::ProcessSP& process_sp,
+    lldb_private::StructuredDataImpl *args_impl,
     std::string &error_string
 )
 {
     if (python_class_name == NULL || python_class_name[0] == '\0' || !session_dictionary_name)
         Py_RETURN_NONE;
 
     PyErr_Cleaner py_err_cleaner(true);
 
     auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(session_dictionary_name);
     auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(python_class_name, dict);
 
     if (!pfunc.IsAllocated()) {
         error_string.append("could not find script class: ");
         error_string.append(python_class_name);
         return nullptr;
     }
 
-    // I do not want the SBTarget to be deallocated when going out of scope
+    // I do not want the SBProcess to be deallocated when going out of scope
     // because python has ownership of it and will manage memory for this
     // object by itself
-    PythonObject target_arg(PyRefType::Owned, SBTypeToSWIGWrapper(new lldb::SBTarget(target_sp)));
+    PythonObject process_arg(PyRefType::Owned, SBTypeToSWIGWrapper(new lldb::SBProcess(process_sp)));
 
-    if (!target_arg.IsAllocated())
+    if (!process_arg.IsAllocated())
         Py_RETURN_NONE;
 
     llvm::Expected<PythonCallable::ArgInfo> arg_info = pfunc.GetArgInfo();
     if (!arg_info) {
         llvm::handleAllErrors(
             arg_info.takeError(),
             [&](PythonException &E) {
                 error_string.append(E.ReadBacktrace());
             },
             [&](const llvm::ErrorInfoBase &E) {
                 error_string.append(E.message());
             });
         Py_RETURN_NONE;
     }
 
     PythonObject result = {};
-    if (arg_info.get().max_positional_args == 1) {
-        result = pfunc(target_arg);
+    if (arg_info.get().max_positional_args == 2) {
+        PythonObject args_arg(PyRefType::Owned, SBTypeToSWIGWrapper(new lldb::SBStructuredData(args_impl)));
+        result = pfunc(process_arg, args_arg);
     } else {
-        error_string.assign("wrong number of arguments in __init__, should be 2 or 3 (not including self)");
+        error_string.assign("wrong number of arguments in __init__, should be 2 (not including self)");
         Py_RETURN_NONE;
     }
 
     if (result.IsAllocated())
         return result.release();
     Py_RETURN_NONE;
 }
 

lldb/examples/python/scripted_process/my_scripted_process.py

registers = {
         "r15":0x00000001040b2b88,
         "rip":0x0000000100003f61,
         "rflags":0x0000000000000206,
         "cs":0x000000000000002b,
         "fs":0x0000000000000000,
         "gs":0x0000000000000000,
     }
 
-    def __init__(self, target):
-        super().__init__(target)
+    def __init__(self, process, args):
+        super().__init__(process, args)
 
     def get_thread_id(self) -> int:
         return 0x19
 
     def get_name(self) -> str:
         return MyScriptedThread.__name__ + ".thread-1"
 
     def get_stop_reason(self) -> Dict[str, Any]:

 def __lldb_init_module(debugger, dict):
     if not 'SKIP_SCRIPTED_PROCESS_LAUNCH' in os.environ:
         debugger.HandleCommand(
             "process launch -C %s.%s" % (__name__,
                                      MyScriptedProcess.__name__))
     else:
         print("Name of the class that will manage the scripted process: '%s.%s'"
                 % (__name__, MyScriptedProcess.__name__))
 No newline at end of file

lldb/examples/python/scripted_process/scripted_process.py

class ScriptedThread:
     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.
     """
 
     @abstractmethod
-    def __init__(self, target):
+    def __init__(self, process, args):
         """ Construct a scripted thread.
 
         Args:
-            target (lldb.SBTarget): The target launching the scripted process.
+            process (lldb.SBProcess): The scripted process owning this thread.
             args (lldb.SBStructuredData): A Dictionary holding arbitrary
-                key/value pairs used by the scripted process.
+                key/value pairs used by the scripted thread.
         """
         self.target = None
+        self.process = None
         self.args = None
-        if isinstance(target, lldb.SBTarget) and target.IsValid():
-            self.target = target
+        if isinstance(process, lldb.SBProcess) and process.IsValid():
+            self.process = process
+            self.target = process.GetTarget()
 
         self.id = None
         self.name = None
         self.queue = None
         self.state = None
         self.stop_reason = None
         self.register_info = None
         self.register_ctx = []

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

 
 extern "C" void *LLDBSwigPythonCreateScriptedProcess(
     const char *python_class_name, const char *session_dictionary_name,
     const lldb::TargetSP &target_sp, StructuredDataImpl *args_impl,
     std::string &error_string);
 
 extern "C" void *LLDBSwigPythonCreateScriptedThread(
     const char *python_class_name, const char *session_dictionary_name,
-    const lldb::TargetSP &target_sp, std::string &error_string);
+    const lldb::ProcessSP &process_sp, StructuredDataImpl *args_impl,
+    std::string &error_string);
 
 extern "C" void *LLDBSWIGPython_CastPyObjectToSBData(void *data);
 extern "C" void *LLDBSWIGPython_CastPyObjectToSBError(void *data);
 extern "C" void *LLDBSWIGPython_CastPyObjectToSBValue(void *data);
 extern "C" void *LLDBSWIGPython_CastPyObjectToSBMemoryRegionInfo(void *data);
 
 } // namespace lldb_private
 
 #endif // LLDB_ENABLE_PYTHON
 #endif // LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_SWIGPYTHONBRIDGE_H

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

 
 StructuredData::GenericSP ScriptedThreadPythonInterface::CreatePluginObject(
     const llvm::StringRef class_name, ExecutionContext &exe_ctx,
     StructuredData::DictionarySP args_sp) {
 
   if (class_name.empty())
     return {};
 
-  Locker py_lock(&m_interpreter, Locker::AcquireLock | Locker::NoSTDIN,
-                 Locker::FreeLock);
-
+  ProcessSP process_sp = exe_ctx.GetProcessSP();
+  StructuredDataImpl *args_impl = nullptr;
+  if (args_sp) {
+    args_impl = new StructuredDataImpl();
+    args_impl->SetObjectSP(args_sp);
+  }
   std::string error_string;
 
-  TargetSP target_sp = exe_ctx.GetTargetSP();
+  Locker py_lock(&m_interpreter, Locker::AcquireLock | Locker::NoSTDIN,
+                 Locker::FreeLock);
 
   void *ret_val = LLDBSwigPythonCreateScriptedThread(
-      class_name.str().c_str(), m_interpreter.GetDictionaryName(), target_sp,
-      error_string);
+      class_name.str().c_str(), m_interpreter.GetDictionaryName(), process_sp,
+      args_impl, error_string);
 
   if (!ret_val)
     return {};
 
   m_object_instance_sp =
       StructuredData::GenericSP(new StructuredPythonObject(ret_val));
 
   return m_object_instance_sp;

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

class DummyScriptedProcess(ScriptedProcess):
     def is_alive(self) -> bool:
         return True
 
     def get_scripted_thread_plugin(self):
         return DummyScriptedThread.__module__ + "." + DummyScriptedThread.__name__
 
 
 class DummyScriptedThread(ScriptedThread):
-    def __init__(self, target):
-        super().__init__(target)
+    def __init__(self, process, args):
+        super().__init__(process, args)
 
     def get_thread_id(self) -> int:
         return 0x19
 
     def get_name(self) -> str:
         return DummyScriptedThread.__name__ + ".thread-1"
 
     def get_state(self) -> int:

 def __lldb_init_module(debugger, dict):
     if not 'SKIP_SCRIPTED_PROCESS_LAUNCH' in os.environ:
         debugger.HandleCommand(
             "process launch -C %s.%s" % (__name__,
                                      DummyScriptedProcess.__name__))
     else:
         print("Name of the class that will manage the scripted process: '%s.%s'"
                 % (__name__, DummyScriptedProcess.__name__))
 No newline at end of file

lldb/unittests/ScriptInterpreter/Python/PythonTestSuite.cpp

extern "C" void *LLDBSwigPythonCreateScriptedProcess(
     const char *python_class_name, const char *session_dictionary_name,
     const lldb::TargetSP &target_sp, StructuredDataImpl *args_impl,
     std::string &error_string) {
   return nullptr;
 }
 
 extern "C" void *LLDBSwigPythonCreateScriptedThread(
     const char *python_class_name, const char *session_dictionary_name,
-    const lldb::TargetSP &target_sp, std::string &error_string) {
+    const lldb::ProcessSP &process_sp, StructuredDataImpl *args_impl,
+    std::string &error_string) {
   return nullptr;
 }
 
 extern "C" void *
 LLDBSWIGPython_CreateFrameRecognizer(const char *python_class_name,
                                      const char *session_dictionary_name) {
   return nullptr;
 }