[lldb/Plugins] Add memory region support in ScriptedProcess

[mib]

Summary

This patch adds support for memory regions in Scripted Processes.
This is necessary to read the stack memory region in order to
reconstruct each stackframe of the program.

In order to do so, this patch makes some changes to the SBAPI, namely:

• Add a new constructor for SBMemoryRegionInfo that takes arguments such as the memory region name, address range, permissions ... This is used when reading memory at some address to compute the offset in the binary blob provided by the user.
• Add a GetMemoryRegionContainingAddress method to SBMemoryRegionInfoList to simplify the access to a specific memory region.

With these changes, lldb is now able to unwind the stack and reconstruct
each frame. On top of that, reloading the target module at offset 0 allows
lldb to symbolicate the ScriptedProcess using debug info, similarly to an
ordinary Process.

To test this, I wrote a simple program with multiple function calls, ran it in
lldb, stopped at a leaf function and read the registers values and copied
the stack memory into a binary file. These are then used in the python script.

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

[mib]

Add test.

[mib]

Following @JDevlieghere question in https://reviews.llvm.org/D107585#2979988, here are some explanations:

In order to read memory from the ScriptedProcess, the process plugin calls the python read_memory_at_address method passing the address at which we should start reading (and the number of bytes to be read).

However, the memory buffer, that provided by the python_script, - usually - starts at offset 0. This is why having memory regions in the python script allows up to:

1. Check that the address that should be read is in one of the our memory regions.
2. Shift the address by the region start address so the memory reads are done at the right location.

Using a SB class for Scripted Processes could be risky, since it can introduce a cyclic dependency: If, for instance, we use a facility that is itself backed by an execution context object (process, thread, frame) for one of the Scripted execution context objects, that will cause the C++ object to use a Python object which will again use a C++ object, and so on.

Luckily, this is not an issue for lldb.SBMemoryRegionInfo.

[mib]

ping ?

[mib]

ping @JDevlieghere

[mib]

Use ScriptedInterface::ErrorWithMessage helper function.

[mib]

Update error message.

[JDevlieghere]

I'm slightly worried about the switch from a unique pointer to a shared pointer. It seems like a memory region is a simple enough object that it's warranted to make a copy to avoid this change. WDYT?

[mib]

Reverted from shared_ptr to unique_ptr for SBMemoryRegionInfo opaque_ptr.

[mib]

ping @JDevlieghere

[JDevlieghere]

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

281

If this is the only way out of this loop, does that mean we always return an error here?

[mib]

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

281

In a previous diff, I stopped fetching memory regions if the shared_ptr was null, but now, I only have a memory region object instance which has no IsValid or operator bool() methods ...

Not sure yet how I'll be able to fetch all the memory regions ... I'll have to rethink this.

[mib]

Change ScriptedProcessPythonInterface::GetMemoryRegionContainingAddress return type to llvm::Optional<MemoryRegionInfo> to stop fetching memory regions without always returning an error.

[JDevlieghere]

LGTM

lldb/examples/python/scripted_process/my_scripted_process.py

126

Aren't format strings only available in Python 3?

lldb/bindings/interface/SBMemoryRegionInfo.i

 class SBMemoryRegionInfo
 {
 public:
 
     SBMemoryRegionInfo ();
 
     SBMemoryRegionInfo (const lldb::SBMemoryRegionInfo &rhs);
 
+    SBMemoryRegionInfo::SBMemoryRegionInfo(const char *name, lldb::addr_t begin,
+    lldb::addr_t end, uint32_t permissions, bool mapped, bool stack_memory);
+
     ~SBMemoryRegionInfo ();
 
     void
     Clear();
 
     lldb::addr_t
     GetRegionBase ();
 

lldb/bindings/interface/SBMemoryRegionInfoList.i

public:
     SBMemoryRegionInfoList (const lldb::SBMemoryRegionInfoList &rhs);
 
     ~SBMemoryRegionInfoList ();
 
     uint32_t
     GetSize () const;
 
     bool
+    GetMemoryRegionContainingAddress (lldb::addr_t addr, SBMemoryRegionInfo &region_info);
+
+    bool
     GetMemoryRegionAtIndex (uint32_t idx, SBMemoryRegionInfo &region_info);
 
     void
     Append (lldb::SBMemoryRegionInfo &region);
 
     void
     Append (lldb::SBMemoryRegionInfoList &region_list);
 
     void
     Clear ();
 };
 
 } // namespace lldb

lldb/bindings/python/python-wrapper.swig

)
     int valid_cast = SWIG_ConvertPtr(data, (void**)&sb_ptr, SWIGTYPE_p_lldb__SBValue, 0);
 
     if (valid_cast == -1)
         return NULL;
 
     return sb_ptr;
 }
 
+SWIGEXPORT void*
+LLDBSWIGPython_CastPyObjectToSBMemoryRegionInfo
+(
+    PyObject* data
+)
+{
+    lldb::SBMemoryRegionInfo* sb_ptr = NULL;
+
+    int valid_cast = SWIG_ConvertPtr(data, (void**)&sb_ptr, SWIGTYPE_p_lldb__SBMemoryRegionInfo, 0);
+
+    if (valid_cast == -1)
+        return NULL;
+
+    return sb_ptr;
+}
+
 SWIGEXPORT bool
 LLDBSwigPythonCallCommand
 (
     const char *python_function_name,
     const char *session_dictionary_name,
     lldb::DebuggerSP& debugger,
     const char* args,
     lldb_private::CommandReturnObject& cmd_retobj,

lldb/examples/python/scripted_process/my_scripted_process.py

 import os,struct,signal
 
 from typing import Any, Dict
 
 import lldb
 from lldb.plugins.scripted_process import ScriptedProcess
 from lldb.plugins.scripted_process import ScriptedThread
 
 class MyScriptedProcess(ScriptedProcess):
+    memory_regions = [
+        lldb.SBMemoryRegionInfo("stack", 0x1040b2000, 0x1040b4000, 0b110, True,
+                                True)
+    ]
+
+    stack_memory_dump = os.path.join(os.path.dirname(os.path.abspath(__file__)),
+                                     'main.stack-dump')
+
     def __init__(self, target: lldb.SBTarget, args : lldb.SBStructuredData):
         super().__init__(target, args)
 
     def get_memory_region_containing_address(self, addr: int) -> lldb.SBMemoryRegionInfo:
-        return self.memory_regions[0]
+        for region in self.memory_regions:
+            if region.GetRegionBase() <= addr < region.GetRegionEnd():
+                return region
+        return None
 
     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) -> lldb.SBData:
-        data = lldb.SBData().CreateDataFromCString(
+        data = lldb.SBData()
+
+        with open(self.stack_memory_dump, 'rb') as f:
+            stack_mem = f.read(-1)
+            if not stack_mem:
+                return data
+
+            mem_region = self.get_memory_region_containing_address(addr)
+
+            if not mem_region or addr + size > mem_region.GetRegionEnd():
+                return data
+
+            offset = addr - mem_region.GetRegionBase()
+            shrunk_stack_mem = stack_mem[offset:offset + size]
+
+            error = lldb.SBError()
+            data.SetData(error, shrunk_stack_mem,
                                     self.target.GetByteOrder(),
-                                    self.target.GetCodeByteSize(),
-                                    "Hello, world!")
+                                    self.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 MyScriptedThread.__module__ + "." + MyScriptedThread.__name__
 
 
 class MyScriptedThread(ScriptedThread):
+    registers = {
+        "rax":0x00000000000006e4,
+        "rbx":0x00000001040b6060,
+        "rcx":0x00000001040b2e00,
+        "rdx":0x00000001040b2ba8,
+        "rdi":0x000000000000002a,
+        "rsi":0x00000001040b2b98,
+        "rbp":0x00000001040b2a20,
+        "rsp":0x00000001040b2a20,
+        "r8":0x00000000003e131e,
+        "r9":0xffffffff00000000,
+        "r10":0x0000000000000000,
+        "r11":0x0000000000000246,
+        "r12":0x000000010007c3a0,
+        "r13":0x00000001040b2b18,
+        "r14":0x0000000100003f90,
+        "r15":0x00000001040b2b88,
+        "rip":0x0000000100003f61,
+        "rflags":0x0000000000000206,
+        "cs":0x000000000000002b,
+        "fs":0x0000000000000000,
+        "gs":0x0000000000000000,
+    }
+
     def __init__(self, target):
         super().__init__(target)
 
     def get_thread_id(self) -> int:
         return 0x19
 
     def get_name(self) -> str:
         return MyScriptedThread.__name__ + ".thread-1"
def get_stackframes(self):
 
         symbol_ctx = lldb.SBSymbolContext()
         frame_zero = ScriptedStackFrame(0, 0x42424242, 0x5000000, symbol_ctx)
         self.frames.append(frame_zero)
 
         return self.frame_zero[0:0]
 
     def get_register_context(self) -> str:
-        return struct.pack(
-                '21Q', 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21)
+        return struct.pack("{}Q".format(len(self.registers)), *self.registers.values())
 
 
 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 ScriptedProcess:
 
     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.
     """
 
+    memory_regions = None
+    stack_memory_dump = None
+    loaded_images = None
+
     @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
                 key/value pairs used by the scripted process.
def read_memory_at_address(addr, size):
             size (int): Size of the memory to read.
 
         Returns:
             lldb.SBData: An `lldb.SBData` buffer with the target byte size and
                 byte order storing the memory read.
         """
         pass
 
-    @abstractmethod
     def get_loaded_images(self):
         """ Get the list of loaded images for the scripted process.
 
         ```
         class ScriptedProcessImage:
             def __init__(name, file_spec, uuid, load_address):
               self.name = name
               self.file_spec = file_spec
               self.uuid = uuid
               self.load_address = load_address
         ```
 
         Returns:
             List[ScriptedProcessImage]: A list of `ScriptedProcessImage`
                 containing for each entry, the name of the library, a UUID,
                 an `lldb.SBFileSpec` and a load address.
                 None if the list is empty.
         """
-        pass
+        return self.loaded_images
 
     def get_process_id(self):
         """ Get the scripted process identifier.
 
         Returns:
             int: The scripted process identifier.
         """
         return 0

lldb/include/lldb/API/SBMemoryRegionInfo.h

 namespace lldb {
 
 class LLDB_API SBMemoryRegionInfo {
 public:
   SBMemoryRegionInfo();
 
   SBMemoryRegionInfo(const lldb::SBMemoryRegionInfo &rhs);
 
+  SBMemoryRegionInfo(const char *name, lldb::addr_t begin, lldb::addr_t end,
+                     uint32_t permissions, bool mapped,
+                     bool stack_memory = false);
+
   ~SBMemoryRegionInfo();
 
   const lldb::SBMemoryRegionInfo &
   operator=(const lldb::SBMemoryRegionInfo &rhs);
 
   void Clear();
 
   /// Get the base address of this memory range.
public:
   bool operator!=(const lldb::SBMemoryRegionInfo &rhs) const;
 
   bool GetDescription(lldb::SBStream &description);
 
 private:
   friend class SBProcess;
   friend class SBMemoryRegionInfoList;
 
+  friend class lldb_private::ScriptInterpreter;
+
   lldb_private::MemoryRegionInfo &ref();
 
   const lldb_private::MemoryRegionInfo &ref() const;
 
   // Unused.
   SBMemoryRegionInfo(const lldb_private::MemoryRegionInfo *lldb_object_ptr);
 
   lldb::MemoryRegionInfoUP m_opaque_up;
 };
 
 } // namespace lldb
 
 #endif // LLDB_API_SBMEMORYREGIONINFO_H

lldb/include/lldb/API/SBMemoryRegionInfoList.h

public:
   SBMemoryRegionInfoList(const lldb::SBMemoryRegionInfoList &rhs);
 
   const SBMemoryRegionInfoList &operator=(const SBMemoryRegionInfoList &rhs);
 
   ~SBMemoryRegionInfoList();
 
   uint32_t GetSize() const;
 
+  bool GetMemoryRegionContainingAddress(lldb::addr_t addr,
+                                        SBMemoryRegionInfo &region_info);
+
   bool GetMemoryRegionAtIndex(uint32_t idx, SBMemoryRegionInfo &region_info);
 
   void Append(lldb::SBMemoryRegionInfo &region);
 
   void Append(lldb::SBMemoryRegionInfoList &region_list);
 
   void Clear();
 

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/SBData.h"
 #include "lldb/API/SBError.h"
+#include "lldb/API/SBMemoryRegionInfo.h"
 #include "lldb/Breakpoint/BreakpointOptions.h"
 #include "lldb/Core/Communication.h"
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Core/SearchFilter.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Host/PseudoTerminal.h"
 #include "lldb/Interpreter/ScriptedProcessInterface.h"
 #include "lldb/Utility/Broadcaster.h"
ScriptedProcessInterface &GetScriptedProcessInterface() {
     return *m_scripted_process_interface_up;
   }
 
   lldb::DataExtractorSP
   GetDataExtractorFromSBData(const lldb::SBData &data) const;
 
   Status GetStatusFromSBError(const lldb::SBError &error) const;
 
+  llvm::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;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_INTERPRETER_SCRIPTINTERPRETER_H

lldb/include/lldb/Interpreter/ScriptedProcessInterface.h

 //===-- ScriptedProcessInterface.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_SCRIPTEDPROCESSINTERFACE_H
 #define LLDB_INTERPRETER_SCRIPTEDPROCESSINTERFACE_H
 
 #include "lldb/Core/StructuredDataImpl.h"
 #include "lldb/Interpreter/ScriptInterpreter.h"
 #include "lldb/Interpreter/ScriptedInterface.h"
+#include "lldb/Target/MemoryRegionInfo.h"
 
 #include "lldb/lldb-private.h"
 
 #include <string>
 
 namespace lldb_private {
 class ScriptedProcessInterface : virtual public ScriptedInterface {
 public:
   StructuredData::GenericSP
   CreatePluginObject(llvm::StringRef class_name, ExecutionContext &exe_ctx,
                      StructuredData::DictionarySP args_sp) override {
     return nullptr;
   }
 
   virtual Status Launch() { return Status("ScriptedProcess did not launch"); }
 
   virtual Status Resume() { return Status("ScriptedProcess did not resume"); }
 
   virtual bool ShouldStop() { return true; }
 
   virtual Status Stop() { return Status("ScriptedProcess did not stop"); }
 
-  virtual lldb::MemoryRegionInfoSP
-  GetMemoryRegionContainingAddress(lldb::addr_t address) {
-    return nullptr;
+  virtual llvm::Optional<MemoryRegionInfo>
+  GetMemoryRegionContainingAddress(lldb::addr_t address, Status &error) {
+    error.SetErrorString("ScriptedProcess have no memory region.");
+    return {};
   }
 
   virtual StructuredData::DictionarySP GetThreadWithID(lldb::tid_t tid) {
     return nullptr;
   }
 
   virtual StructuredData::DictionarySP GetRegistersForThread(lldb::tid_t tid) {
     return nullptr;

lldb/source/API/SBMemoryRegionInfo.cpp

 
 using namespace lldb;
 using namespace lldb_private;
 
 SBMemoryRegionInfo::SBMemoryRegionInfo() : m_opaque_up(new MemoryRegionInfo()) {
   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBMemoryRegionInfo);
 }
 
+SBMemoryRegionInfo::SBMemoryRegionInfo(const char *name, lldb::addr_t begin,
+                                       lldb::addr_t end, uint32_t permissions,
+                                       bool mapped, bool stack_memory)
+    : SBMemoryRegionInfo() {
+  LLDB_RECORD_CONSTRUCTOR(
+      SBMemoryRegionInfo,
+      (const char *, lldb::addr_t, lldb::addr_t, uint32_t, bool, bool), name,
+      begin, end, permissions, mapped, stack_memory);
+  m_opaque_up->SetName(name);
+  m_opaque_up->GetRange().SetRangeBase(begin);
+  m_opaque_up->GetRange().SetRangeEnd(end);
+  m_opaque_up->SetLLDBPermissions(permissions);
+  m_opaque_up->SetMapped(mapped ? MemoryRegionInfo::eYes
+                                : MemoryRegionInfo::eNo);
+  m_opaque_up->SetIsStackMemory(stack_memory ? MemoryRegionInfo::eYes
+                                             : MemoryRegionInfo::eNo);
+}
+
 SBMemoryRegionInfo::SBMemoryRegionInfo(const MemoryRegionInfo *lldb_object_ptr)
     : m_opaque_up(new MemoryRegionInfo()) {
   if (lldb_object_ptr)
     ref() = *lldb_object_ptr;
 }
 
 SBMemoryRegionInfo::SBMemoryRegionInfo(const SBMemoryRegionInfo &rhs)
     : m_opaque_up() {

 namespace lldb_private {
 namespace repro {
 
 template <>
 void RegisterMethods<SBMemoryRegionInfo>(Registry &R) {
   LLDB_REGISTER_CONSTRUCTOR(SBMemoryRegionInfo, ());
   LLDB_REGISTER_CONSTRUCTOR(SBMemoryRegionInfo,
                             (const lldb::SBMemoryRegionInfo &));
+  LLDB_REGISTER_CONSTRUCTOR(
+      SBMemoryRegionInfo,
+      (const char *, lldb::addr_t, lldb::addr_t, uint32_t, bool, bool));
   LLDB_REGISTER_METHOD(
       const lldb::SBMemoryRegionInfo &,
       SBMemoryRegionInfo, operator=,(const lldb::SBMemoryRegionInfo &));
   LLDB_REGISTER_METHOD(void, SBMemoryRegionInfo, Clear, ());
   LLDB_REGISTER_METHOD_CONST(
       bool,
       SBMemoryRegionInfo, operator==,(const lldb::SBMemoryRegionInfo &));
   LLDB_REGISTER_METHOD_CONST(

lldb/source/API/SBMemoryRegionInfoList.cpp

void Append(const MemoryRegionInfoListImpl &list) {
     Reserve(GetSize() + list.GetSize());
 
     for (const auto &val : list.m_regions)
       Append(val);
   }
 
   void Clear() { m_regions.clear(); }
 
+  bool GetMemoryRegionContainingAddress(lldb::addr_t addr,
+                                        MemoryRegionInfo &region_info) {
+    for (auto &region : m_regions) {
+      if (region.GetRange().Contains(addr)) {
+        region_info = region;
+        return true;
+      }
+    }
+    return false;
+  }
+
   bool GetMemoryRegionInfoAtIndex(size_t index,
                                   MemoryRegionInfo &region_info) {
     if (index >= GetSize())
       return false;
     region_info = m_regions[index];
     return true;
   }
 

 }
 
 uint32_t SBMemoryRegionInfoList::GetSize() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBMemoryRegionInfoList, GetSize);
 
   return m_opaque_up->GetSize();
 }
 
+bool SBMemoryRegionInfoList::GetMemoryRegionContainingAddress(
+    lldb::addr_t addr, SBMemoryRegionInfo &region_info) {
+  LLDB_RECORD_METHOD(
+      bool, SBMemoryRegionInfoList, GetMemoryRegionContainingAddress,
+      (lldb::addr_t, lldb::SBMemoryRegionInfo &), addr, region_info);
+
+  return m_opaque_up->GetMemoryRegionContainingAddress(addr, region_info.ref());
+}
+
 bool SBMemoryRegionInfoList::GetMemoryRegionAtIndex(
     uint32_t idx, SBMemoryRegionInfo &region_info) {
   LLDB_RECORD_METHOD(bool, SBMemoryRegionInfoList, GetMemoryRegionAtIndex,
                      (uint32_t, lldb::SBMemoryRegionInfo &), idx, region_info);
 
   return m_opaque_up->GetMemoryRegionInfoAtIndex(idx, region_info.ref());
 }
 
void RegisterMethods<SBMemoryRegionInfoList>(Registry &R) {
   LLDB_REGISTER_CONSTRUCTOR(SBMemoryRegionInfoList, ());
   LLDB_REGISTER_CONSTRUCTOR(SBMemoryRegionInfoList,
                             (const lldb::SBMemoryRegionInfoList &));
   LLDB_REGISTER_METHOD(
       const lldb::SBMemoryRegionInfoList &,
       SBMemoryRegionInfoList, operator=,(
                                   const lldb::SBMemoryRegionInfoList &));
   LLDB_REGISTER_METHOD_CONST(uint32_t, SBMemoryRegionInfoList, GetSize, ());
+  LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfoList,
+                       GetMemoryRegionContainingAddress,
+                       (lldb::addr_t, lldb::SBMemoryRegionInfo &));
   LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfoList, GetMemoryRegionAtIndex,
                        (uint32_t, lldb::SBMemoryRegionInfo &));
   LLDB_REGISTER_METHOD(void, SBMemoryRegionInfoList, Clear, ());
   LLDB_REGISTER_METHOD(void, SBMemoryRegionInfoList, Append,
                        (lldb::SBMemoryRegionInfo &));
   LLDB_REGISTER_METHOD(void, SBMemoryRegionInfoList, Append,
                        (lldb::SBMemoryRegionInfoList &));
 }
 
 }
 }

lldb/source/Interpreter/ScriptInterpreter.cpp

 Status
 ScriptInterpreter::GetStatusFromSBError(const lldb::SBError &error) const {
   if (error.m_opaque_up)
     return *error.m_opaque_up.get();
 
   return Status();
 }
 
+llvm::Optional<MemoryRegionInfo>
+ScriptInterpreter::GetOpaqueTypeFromSBMemoryRegionInfo(
+    const lldb::SBMemoryRegionInfo &mem_region) const {
+  if (!mem_region.m_opaque_up)
+    return llvm::None;
+  return *mem_region.m_opaque_up.get();
+}
+
 lldb::ScriptLanguage
 ScriptInterpreter::StringToLanguage(const llvm::StringRef &language) {
   if (language.equals_insensitive(LanguageToString(eScriptLanguageNone)))
     return eScriptLanguageNone;
   if (language.equals_insensitive(LanguageToString(eScriptLanguagePython)))
     return eScriptLanguagePython;
   if (language.equals_insensitive(LanguageToString(eScriptLanguageLua)))
     return eScriptLanguageLua;

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

size_t ScriptedProcess::DoReadMemory(lldb::addr_t addr, void *buf, size_t size,
                                      Status &error) {
   if (!m_interpreter)
     return GetInterface().ErrorWithMessage<size_t>(__PRETTY_FUNCTION__,
                                                    "No interpreter.", error);
 
   lldb::DataExtractorSP data_extractor_sp =
       GetInterface().ReadMemoryAtAddress(addr, size, error);
 
-  if (!data_extractor_sp || error.Fail())
+  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 GetInterface().ErrorWithMessage<size_t>(
         __PRETTY_FUNCTION__, "Failed to copy read memory to buffer.", error);
 
   return size;
 }
 
 ArchSpec ScriptedProcess::GetArchitecture() {
   return GetTarget().GetArchitecture();
 }
 
 Status ScriptedProcess::GetMemoryRegionInfo(lldb::addr_t load_addr,
                                             MemoryRegionInfo &region) {
-  // TODO: Implement
-  return Status();
+  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;
-  lldb::MemoryRegionInfoSP mem_region_sp = nullptr;
 
-  while ((mem_region_sp =
-              GetInterface().GetMemoryRegionContainingAddress(address))) {
-    auto range = mem_region_sp->GetRange();
+  while (auto region_or_err =
+             GetInterface().GetMemoryRegionContainingAddress(address, error)) {
+    if (error.Fail())
+      break;
+
+    MemoryRegionInfo &mem_region = *region_or_err;
+    auto range = mem_region.GetRange();
     address += range.GetRangeBase() + range.GetByteSize();
-    region_list.push_back(*mem_region_sp.get());
+    region_list.push_back(mem_region);
   }
 
-  return {};
+  return error;
 }
 
 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

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

 
 extern "C" void *LLDBSwigPythonCreateScriptedThread(
     const char *python_class_name, const char *session_dictionary_name,
     const lldb::TargetSP &target_sp, 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/ScriptedProcessPythonInterface.h

public:
   Status Launch() override;
 
   Status Resume() override;
 
   bool ShouldStop() override;
 
   Status Stop() override;
 
-  lldb::MemoryRegionInfoSP
-  GetMemoryRegionContainingAddress(lldb::addr_t address) override;
+  llvm::Optional<MemoryRegionInfo>
+  GetMemoryRegionContainingAddress(lldb::addr_t address,
+                                   Status &error) 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;
 

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

bool ScriptedProcessPythonInterface::ShouldStop() {
 
   return obj->GetBooleanValue();
 }
 
 Status ScriptedProcessPythonInterface::Stop() {
   return GetStatusFromMethod("stop");
 }
 
-lldb::MemoryRegionInfoSP
+llvm::Optional<MemoryRegionInfo>
 ScriptedProcessPythonInterface::GetMemoryRegionContainingAddress(
-    lldb::addr_t address) {
-  // TODO: Implement
-  return {};
+    lldb::addr_t address, Status &error) {
+  auto mem_region = Dispatch<llvm::Optional<MemoryRegionInfo>>(
+      "get_memory_region_containing_address", error, address);
+
+  if (error.Fail()) {
+    return ErrorWithMessage<MemoryRegionInfo>(__PRETTY_FUNCTION__,
+                                              error.AsCString(), error);
+  }
+
+  return mem_region;
 }
 
 StructuredData::DictionarySP
 ScriptedProcessPythonInterface::GetThreadWithID(lldb::tid_t tid) {
   Status error;
   StructuredData::ObjectSP obj = Dispatch("get_thread_with_id", error, tid);
 
   if (!CheckStructuredDataObject(__PRETTY_FUNCTION__, obj, error))

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

 Status ScriptedPythonInterface::ExtractValueFromPythonObject<Status>(
     python::PythonObject &p, Status &error);
 
 template <>
 lldb::DataExtractorSP
 ScriptedPythonInterface::ExtractValueFromPythonObject<lldb::DataExtractorSP>(
     python::PythonObject &p, Status &error);
 
+template <>
+llvm::Optional<MemoryRegionInfo>
+ScriptedPythonInterface::ExtractValueFromPythonObject<
+    llvm::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

 template <>
 lldb::DataExtractorSP
 ScriptedPythonInterface::ExtractValueFromPythonObject<lldb::DataExtractorSP>(
     python::PythonObject &p, Status &error) {
   lldb::SBData *sb_data = reinterpret_cast<lldb::SBData *>(
       LLDBSWIGPython_CastPyObjectToSBData(p.get()));
 
   if (!sb_data) {
-    error.SetErrorString("Couldn't cast lldb::SBError to lldb::Status.");
+    error.SetErrorString(
+        "Couldn't cast lldb::SBData to lldb::DataExtractorSP.");
     return nullptr;
   }
 
   return m_interpreter.GetDataExtractorFromSBData(*sb_data);
 }
 
+template <>
+llvm::Optional<MemoryRegionInfo>
+ScriptedPythonInterface::ExtractValueFromPythonObject<
+    llvm::Optional<MemoryRegionInfo>>(python::PythonObject &p, Status &error) {
+
+  lldb::SBMemoryRegionInfo *sb_mem_reg_info =
+      reinterpret_cast<lldb::SBMemoryRegionInfo *>(
+          LLDBSWIGPython_CastPyObjectToSBMemoryRegionInfo(p.get()));
+
+  if (!sb_mem_reg_info) {
+    error.SetErrorString(
+        "Couldn't cast lldb::SBMemoryRegionInfo to lldb::MemoryRegionInfoSP.");
+    return {};
+  }
+
+  return m_interpreter.GetOpaqueTypeFromSBMemoryRegionInfo(*sb_mem_reg_info);
+}
+
 #endif

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

def test_python_plugin_package(self):
                     substrs=["ScriptedProcess"])
 
         self.expect('script from lldb.plugins.scripted_process import ScriptedProcess',
                     substrs=["ImportError"], matching=False)
 
         self.expect('script dir(ScriptedProcess)',
                     substrs=["launch"])
 
-    def test_launch_scripted_process_sbapi(self):
+    def test_scripted_process_and_scripted_thread(self):
         """Test that we can launch an lldb scripted process using the SBAPI,
-        check its process ID and read string from memory."""
+        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)
 
-        scripted_process_example_relpath = ['..','..','..','..','examples','python','scripted_process','my_scripted_process.py']
+        scripted_process_example_relpath = 'dummy_scripted_process.py'
         os.environ['SKIP_SCRIPTED_PROCESS_LAUNCH'] = '1'
         self.runCmd("command script import " + os.path.join(self.getSourceDir(),
-                                                            *scripted_process_example_relpath))
+                                                            scripted_process_example_relpath))
 
         launch_info = lldb.SBLaunchInfo(None)
         launch_info.SetProcessPluginName("ScriptedProcess")
-        launch_info.SetScriptedProcessClassName("my_scripted_process.MyScriptedProcess")
+        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)
 
-        hello_world = "Hello, world!"
-        memory_read = process.ReadCStringFromMemory(0x50000000000,
-                                                    len(hello_world) + 1, # NULL byte
-                                                    error)
-
-        self.assertTrue(error.Success(), "Failed to read memory from scripted process.")
-        self.assertEqual(hello_world, memory_read)
-
         self.assertEqual(process.GetNumThreads(), 1)
 
         thread = process.GetSelectedThread()
         self.assertTrue(thread, "Invalid thread.")
         self.assertEqual(thread.GetThreadID(), 0x19)
-        self.assertEqual(thread.GetName(), "MyScriptedThread.thread-1")
+        self.assertEqual(thread.GetName(), "DummyScriptedThread.thread-1")
         self.assertEqual(thread.GetStopReason(), lldb.eStopReasonSignal)
 
         self.assertGreater(thread.GetNumFrames(), 0)
 
         frame = thread.GetFrameAtIndex(0)
         register_set = frame.registers # Returns an SBValueList.
         for regs in register_set:
             if 'GPR' in regs.name:
                 registers  = regs
                 break
 
         self.assertTrue(registers, "Invalid General Purpose Registers Set")
         self.assertEqual(registers.GetNumChildren(), 21)
         for idx, reg in enumerate(registers, start=1):
             self.assertEqual(idx, int(reg.value, 16))
 
-    def test_launch_scripted_process_cli(self):
+    def test_launch_scripted_process_stack_frames(self):
         """Test that we can launch an lldb scripted process from the command
         line, check its process ID and read string from memory."""
         self.build()
         target = self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
         self.assertTrue(target, VALID_TARGET)
 
+        for module in target.modules:
+            if 'a.out' in module.GetFileSpec().GetFilename():
+                main_module = module
+
+        self.assertTrue(main_module, "Invalid main module.")
+        error = target.SetModuleLoadAddress(main_module, 0)
+        self.assertTrue(error.Success(), "Reloading main module at offset 0 failed.")
+
         scripted_process_example_relpath = ['..','..','..','..','examples','python','scripted_process','my_scripted_process.py']
         self.runCmd("command script import " + os.path.join(self.getSourceDir(),
                                                             *scripted_process_example_relpath))
 
         process = target.GetProcess()
         self.assertTrue(process, PROCESS_IS_VALID)
         self.assertEqual(process.GetProcessID(), 42)
+        self.assertEqual(process.GetNumThreads(), 1)
 
         error = lldb.SBError()
         hello_world = "Hello, world!"
         memory_read = process.ReadCStringFromMemory(0x50000000000,
                                                     len(hello_world) + 1, # NULL byte
                                                     error)
+        thread = process.GetSelectedThread()
+        self.assertTrue(thread, "Invalid thread.")
+        self.assertEqual(thread.GetThreadID(), 0x19)
+        self.assertEqual(thread.GetName(), "MyScriptedThread.thread-1")
 
-        self.assertTrue(error.Success(), "Failed to read memory from scripted process.")
-        self.assertEqual(hello_world, memory_read)
+        self.assertEqual(thread.GetNumFrames(), 4)
+        frame = thread.GetSelectedFrame()
+        self.assertTrue(frame, "Invalid frame.")
+        self.assertEqual(frame.GetFunctionName(), "bar")
+        self.assertEqual(int(frame.FindValue("i", lldb.eValueTypeVariableArgument).GetValue()), 42)
+        self.assertEqual(int(frame.FindValue("j", lldb.eValueTypeVariableLocal).GetValue()), 42 * 42)

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

-import os,struct,signal
+import os,struct, signal
 
 from typing import Any, Dict
 
 import lldb
 from lldb.plugins.scripted_process import ScriptedProcess
 from lldb.plugins.scripted_process import ScriptedThread
 
-class MyScriptedProcess(ScriptedProcess):
+class DummyScriptedProcess(ScriptedProcess):
     def __init__(self, target: lldb.SBTarget, args : lldb.SBStructuredData):
         super().__init__(target, args)
 
     def get_memory_region_containing_address(self, addr: int) -> lldb.SBMemoryRegionInfo:
-        return self.memory_regions[0]
+        return None
 
     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) -> lldb.SBData:
class DummyScriptedProcess(ScriptedProcess):
 
     def should_stop(self) -> bool:
         return True
 
     def is_alive(self) -> bool:
         return True
 
     def get_scripted_thread_plugin(self):
-        return MyScriptedThread.__module__ + "." + MyScriptedThread.__name__
+        return DummyScriptedThread.__module__ + "." + DummyScriptedThread.__name__
 
 
-class MyScriptedThread(ScriptedThread):
+class DummyScriptedThread(ScriptedThread):
     def __init__(self, target):
         super().__init__(target)
 
     def get_thread_id(self) -> int:
         return 0x19
 
     def get_name(self) -> str:
-        return MyScriptedThread.__name__ + ".thread-1"
+        return DummyScriptedThread.__name__ + ".thread-1"
+
+    def get_state(self) -> int:
+        return lldb.eStateStopped
 
     def get_stop_reason(self) -> Dict[str, Any]:
         return { "type": lldb.eStopReasonSignal, "data": {
             "signal": signal.SIGINT
         } }
 
     def get_stackframes(self):
         class ScriptedStackFrame:
def get_register_context(self) -> str:
         return struct.pack(
                 '21Q', 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21)
 
 
 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__))
+                                     DummyScriptedProcess.__name__))
     else:
         print("Name of the class that will manage the scripted process: '%s.%s'"
-                % (__name__, MyScriptedProcess.__name__))
+                % (__name__, DummyScriptedProcess.__name__))
 No newline at end of file

lldb/test/API/functionalities/scripted_process/main.c

-#include <stdlib.h>
-
-int main() {
-  return 0; // break here
+int bar(int i) {
+  int j = i * i;
+  return j; // break here
 }
+
+int foo(int i) { return bar(i); }
+
+int main() { return foo(42); }

lldb/unittests/ScriptInterpreter/Python/PythonTestSuite.cpp

 extern "C" void *LLDBSWIGPython_CastPyObjectToSBError(void *data) {
   return nullptr;
 }
 
 extern "C" void *LLDBSWIGPython_CastPyObjectToSBValue(void *data) {
   return nullptr;
 }
 
+extern "C" void *LLDBSWIGPython_CastPyObjectToSBMemoryRegionInfo(void *data) {
+  return nullptr;
+}
+
 extern lldb::ValueObjectSP
 LLDBSWIGPython_GetValueObjectSPFromSBValue(void *data) {
   return nullptr;
 }
 
 extern "C" bool LLDBSwigPython_UpdateSynthProviderInstance(void *implementor) {
   return false;
 }