[lldb/Plugins] Add ScriptedProcess::GetThreadsInfo interface

[mib]

Summary

This patch adds a new method to the Scripted Process interface to
retrive a dictionary of Scripted Threads. It uses the thread ID as a key
and the Scripted Thread instance as the value.

This dictionary will be used to create Scripted Threads in lldb and
perform calls to the python scripted thread object.

rdar://87427126

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

[JDevlieghere]

Looks straightforward. LGTM.

[mib]

Rebase

lldb/examples/python/scripted_process/scripted_process.py

class ScriptedProcess:
 
     DISCLAIMER: THIS INTERFACE IS STILL UNDER DEVELOPMENT AND NOT STABLE.
                 THE METHODS EXPOSED MIGHT CHANGE IN THE FUTURE.
     """
 
     memory_regions = None
     stack_memory_dump = None
     loaded_images = None
+    threads = {}
 
     @abstractmethod
     def __init__(self, target, args):
         """ Construct a scripted process.
 
         Args:
             target (lldb.SBTarget): The target launching the scripted process.
             args (lldb.SBStructuredData): A Dictionary holding arbitrary
def get_memory_region_containing_address(self, addr):
                 regions.
 
         Returns:
             lldb.SBMemoryRegionInfo: The memory region containing the address.
                 None if out of bounds.
         """
         pass
 
+    def get_threads_info(self):
+        """ Get the dictionary describing the process' Scripted Threads.
+
+        Returns:
+            Dict: The dictionary of threads, with the thread ID as the key and
+            a Scripted Thread instance as the value.
+            The dictionary can be empty.
+        """
+        return self.threads
+
     @abstractmethod
     def get_thread_with_id(self, tid):
         """ Get the scripted process thread with a specific ID.
 
         Args:
             tid (int): Thread ID to look for in the scripted process.
 
         Returns:

lldb/include/lldb/Interpreter/ScriptedProcessInterface.h

public:
   virtual Status Stop() { return Status("ScriptedProcess did not stop"); }
 
   virtual llvm::Optional<MemoryRegionInfo>
   GetMemoryRegionContainingAddress(lldb::addr_t address, Status &error) {
     error.SetErrorString("ScriptedProcess have no memory region.");
     return {};
   }
 
+  virtual StructuredData::DictionarySP GetThreadsInfo() { return nullptr; }
+
   virtual StructuredData::DictionarySP GetThreadWithID(lldb::tid_t tid) {
     return nullptr;
   }
 
   virtual StructuredData::DictionarySP GetRegistersForThread(lldb::tid_t tid) {
     return nullptr;
   }
 

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

public:
   bool ShouldStop() override;
 
   Status Stop() override;
 
   llvm::Optional<MemoryRegionInfo>
   GetMemoryRegionContainingAddress(lldb::addr_t address,
                                    Status &error) override;
 
+  StructuredData::DictionarySP GetThreadsInfo() override;
+
   StructuredData::DictionarySP GetThreadWithID(lldb::tid_t tid) override;
 
   StructuredData::DictionarySP GetRegistersForThread(lldb::tid_t tid) override;
 
   lldb::DataExtractorSP ReadMemoryAtAddress(lldb::addr_t address, size_t size,
                                             Status &error) override;
 
   StructuredData::DictionarySP GetLoadedImages() override;

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

ScriptedProcessPythonInterface::GetMemoryRegionContainingAddress(
   if (error.Fail()) {
     return ErrorWithMessage<MemoryRegionInfo>(LLVM_PRETTY_FUNCTION,
                                               error.AsCString(), error);
   }
 
   return mem_region;
 }
 
+StructuredData::DictionarySP ScriptedProcessPythonInterface::GetThreadsInfo() {
+  Status error;
+  StructuredData::DictionarySP dict =
+      Dispatch<StructuredData::DictionarySP>("get_threads_info", error);
+
+  if (!CheckStructuredDataObject(LLVM_PRETTY_FUNCTION, dict, error))
+    return {};
+
+  return dict;
+}
+
 StructuredData::DictionarySP
 ScriptedProcessPythonInterface::GetThreadWithID(lldb::tid_t tid) {
   Status error;
   StructuredData::ObjectSP obj = Dispatch("get_thread_with_id", error, tid);
 
   if (!CheckStructuredDataObject(LLVM_PRETTY_FUNCTION, obj, error))
     return {};