[lldb][LocateModuleCallback] Implement API, Python interface

[splhack]

Summary

RFC https://discourse.llvm.org/t/rfc-python-callback-for-target-get-module/71580

Use SWIG for the locate module callback the same as other Python callbacks.
TestLocateModuleCallback.py verifies the functionalities.

[splhack]

Move SetTargetGetModuleCallback from SBDebugger to SBPlatform.
https://discourse.llvm.org/t/rfc-python-callback-for-target-get-module/71580/4?u=splhack

[splhack]

rebase

[splhack]

rebase

[clayborg]

lldb/include/lldb/API/SBDefines.h

129

If we are putting this into SBPlatform, this should probably be named "SBPlatformGetModuleCallback".

The name might be a bit more clear if it was "SBPlatformLocateModuleCallback"? Open to suggestions or fine to lave this as "SBPlatformGetModuleCallback" if everyone likes that.

lldb/include/lldb/API/SBPlatform.h

181

remove "Target" from the function name? Or rename to "SetLocateModuleCallback(...)" if we end up renaming the callback type to SBPlatformLocateModuleCallback

lldb/source/API/SBPlatform.cpp

668

You are not passing the "callback" into Platform::SetTargetGetModuleCallback??

Are we missing changes to the file "lldb/include/lldb/Target/Platform.h"?

[splhack]

lldb/include/lldb/API/SBDefines.h

129

As commented on D153734, I'll rename it to SBPlatformLocateModuleCallback.

typedef SBError (*SBPlatformLocateModuleCallback)(
    SBDebugger debugger,
    SBModuleSpec &module_spec,
    SBFileSpec &module_file_spec,
    SBFileSpec &symbol_file_spec);

lldb/include/lldb/API/SBPlatform.h

181

I'll rename it to SetLocateModuleCallback.

SBError SetLocateModuleCallback(lldb::SBPlatformLocateModuleCallback callback,
                                                       void *callback_baton);

lldb/source/API/SBPlatform.cpp

668

will update it to support C callback function as well as Python.

[mib]

LGTM with @clayborg comments.

[splhack]

• Rename 'get module callback' to 'locate module callback'
• SBPlatform will do
  • capture callback(SBPlatformLocateModuleCallback) and baton(void *)
  • convert ModuleSpec/FileSpec from/to SBModuleSpec/SBFileSpec for calling the callback

[clayborg]

It would be nice to pass the baton down into the platform layer if possible so that internal users could use the callback + baton. See comments in the other diff and see if you agree

[splhack]

@clayborg yes, it'd be possible to pass the baton down to Platform.h since it is just void *, so no dependencies required.

But, first, let me explain the callback and baton flow.

---

For Python, user will set a callable Python object as the callback.
For C++ API, user will set a function pointer with a baton as the callback.

Both Python callback and C++ API callback will go into SBPlatform SetLocateModuleCallback.
SetLocateModuleCallback will use a lambda in order to convert ModuleSpec and FileSpec to SBModuleSpec and SBFileSpec.
This is because Platform.h and Target.cpp are not able to use SBModuleSpec and SBFileSpec.

|               |                |                   |              |          |
| user callback |<-SBModuleSpec->| SBPlatform lambda |<-ModuleSpec->| Platform |
|      baton    |  SBFileSpec    |  captures callback|  FileSpec    |          |
|               |                |           baton   |              |          |

This summary is what things are retained by which layer.

• Python
  • the user callable object
• SBPlatform
  • C++ API: the user callback and the baton
  • Python: LLDBSwigPythonCallLocateModuleCallback and the user callable object as a baton
• Platform
  • SBPlatform lambda in std::function

There are three things.

• SBPlatform lambda created by SetLocateModuleCallback, the type is Platform::LocateModuleCallback.
• The user callback or LLDBSwigPythonCallLocateModuleCallback, the type is SBPlatformLocateModuleCallback.
• The baton (for Python, this is the callable object)

---

And back to 'passing the baton down to Platform.h'.
As the locate callback implementation in D153734 lldb/unittests/Target/LocateModuleCallbackTest.cpp,
internal users can use lambda to capture/retain anything for the callback. For example, this is captured by the locate callback in this case.
Therefore, no need to pass the baton down to Platform.h.

m_platform_sp->SetLocateModuleCallback([this](const ModuleSpec &module_spec,
                                              FileSpec &module_file_spec,
                                              FileSpec &symbol_file_spec) {
  CheckCallbackArgs(module_spec, module_file_spec, symbol_file_spec);
  symbol_file_spec.SetPath(GetInputFilePath(k_breakpad_symbol_file));
  return Status();
});

[bulbazord]

lldb/source/API/SBPlatform.cpp

663–688

Suggestion: Invert the conditions and use early returns. This function has quite a bit of nesting and I think the readability could be improved.

[splhack]

update SetLocateModuleCallback

[splhack]

lldb/source/API/SBPlatform.cpp

663–688

Thanks, yes it looks better. Also added a comment.

[clayborg]

Thanks for the detailed explanation. We don't want internal users to add a callback with a baton to Platform.h as this would interfere with the APIs, so it is fine to not have a baton in Platform.h.

[splhack]

https://lab.llvm.org/buildbot/#/builders/219/builds/4084

now fixing Windows tests.

[jasonmolenda]

@splhack the shell tests are all asserting on Darwin systems (on my desktop and on the bots https://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/ https://green.lab.llvm.org/green/view/LLDB/job/as-lldb-cmake/ ):

[ RUN      ] LocateModuleCallbackTest.GetOrCreateModuleCallbackSuccessWithModuleAndBreakpadSymbol
Assertion failed: (default_platform_sp), function Debugger, file Debugger.cpp, line 837.
Stack dump without symbol names (ensure you have llvm-symbolizer in your PATH or set the environment var `LLVM_SYMBOLIZER_PATH` to point to it):
0  TargetTests              0x000000010048a5b0 llvm::sys::PrintStackTrace(llvm::raw_ostream&, int) + 80
1  TargetTests              0x000000010048ab4c PrintStackTraceSignalHandler(void*) + 28
2  TargetTests              0x000000010048887c llvm::sys::RunSignalHandlers() + 152
3  TargetTests              0x000000010048bd08 SignalHandler(int) + 276
4  libsystem_platform.dylib 0x0000000183a65a24 _sigtramp + 56
5  libsystem_pthread.dylib  0x0000000183a36cc0 pthread_kill + 288
6  libsystem_c.dylib        0x0000000183946a80 abort + 180
7  libsystem_c.dylib        0x0000000183945d9c err + 0
8  TargetTests              0x000000010050afa0 lldb_private::Debugger::Debugger(void (*)(char const*, void*), void*) + 1700
9  TargetTests              0x0000000100509be8 lldb_private::Debugger::Debugger(void (*)(char const*, void*), void*) + 44
10 TargetTests              0x0000000100509b10 lldb_private::Debugger::CreateInstance(void (*)(char const*, void*), void*) + 68
11 TargetTests              0x00000001001e9434 (anonymous namespace)::LocateModuleCallbackTest::SetUp() + 124

In these tests,

   835 	  // Always add our default platform to the platform list
-> 836 	  PlatformSP default_platform_sp(Platform::GetHostPlatform());
   837 	  assert(default_platform_sp);
   838 	  m_platform_list.Append(default_platform_sp, true);

Platform::GetHostPlatform() is returning no platform. I don't know the contracts for this call offhand and if there might be an issue with how the debugger was created that is causing this.

[splhack]

@jasonmolenda thanks for the report. let me check.

At least ninja check-lldb-unit check-lldb-api-python_api-sbplatform is ok on macOS arm64.

[jasonmolenda]

Hm, let me try a clean build. ninja check-lldb-unit repo'ed the issue on my desktop.

[splhack]

I'm checking other Debugger::CreateInstance calls in unittests.
Looks like it needs to call Platform::SetHostPlatform which is missing in LocateModuleCallbackTest.cpp.

[splhack]

@jasonmolenda D155135 should fix the Debugger::CreateInstance assert.
(The assert does not repro locally though)

[splhack]

In D153735#4494999, @splhack wrote:

https://lab.llvm.org/buildbot/#/builders/219/builds/4084

now fixing Windows tests.

D155124 should fix the Windows test failures.

lldb/bindings/python/python-typemaps.swig

if (PythonList::Check($input)) {
     $1[i] = 0;
   } else if ($input == Py_None) {
     $1 =  NULL;
   } else {
     PyErr_SetString(PyExc_TypeError,"not a list");
     return NULL;
   }
 }
+
+// For lldb::SBTargetGetModuleCallback
+%typemap(in) (lldb::SBTargetGetModuleCallback callback,
+              void *callback_baton) {
+  if (!($input == Py_None ||
+        PyCallable_Check(reinterpret_cast<PyObject *>($input)))) {
+    PyErr_SetString(PyExc_TypeError, "Need a callable object or None!");
+    SWIG_fail;
+  }
+
+  if ($input == Py_None) {
+    $1 = nullptr;
+    $2 = nullptr;
+  } else {
+    PythonCallable callable = Retain<PythonCallable>($input);
+    if (!callable.IsValid()) {
+      PyErr_SetString(PyExc_TypeError, "Need a valid callable object");
+      SWIG_fail;
+    }
+
+    llvm::Expected<PythonCallable::ArgInfo> arg_info = callable.GetArgInfo();
+    if (!arg_info) {
+      PyErr_SetString(PyExc_TypeError,
+                      ("Could not get arguments: " +
+                          llvm::toString(arg_info.takeError())).c_str());
+      SWIG_fail;
+    }
+
+    if (arg_info.get().max_positional_args != 4) {
+      PyErr_SetString(PyExc_TypeError, "Expected 4 argument callable object");
+      SWIG_fail;
+    }
+
+    // Don't lose the callback reference
+    Py_INCREF($input);
+
+    // lldb::SBTarget::SetGetModuleCallback uses lldb::SBTargetGetModuleCallback
+    // type for the Python interface, however lldb_private::Target class does
+    // not use it. This is because we do not want to add the SB* dependencies to
+    // lldb_private::Target. The actual Python callable object is turned into
+    // the second argument as 'void *callback_baton' of
+    // lldb::SBTarget::SetGetModuleCallback by this conversion. Therefore
+    // lldb_private::Target class can retain the callable as 'void *' without
+    // the SB* or Python dependencies.
+    $1 = nullptr;
+    $2 = $input;
+  }
+}
+
+%typemap(typecheck) (lldb::SBTargetGetModuleCallback callback,
+                     void *callback_baton) {
+  $1 = $input == Py_None;
+  $1 = $1 || PyCallable_Check(reinterpret_cast<PyObject *>($input));
+}

lldb/bindings/python/python-wrapper.swig

static void LLDBSwigPythonCallPythonSBDebuggerTerminateCallback(lldb::user_id_t debugger_id,
   if (baton != Py_None) {
     SWIG_PYTHON_THREAD_BEGIN_BLOCK;
     PyObject *result = PyObject_CallFunction(
         reinterpret_cast<PyObject *>(baton), const_cast<char *>("l"), debugger_id);
     Py_XDECREF(result);
     SWIG_PYTHON_THREAD_END_BLOCK;
   }
 }
+
+Status lldb_private::python::SWIGBridge::LLDBSWIGPythonCallTargetGetModuleCallback(
+    void *callback_baton, lldb::DebuggerSP debugger_sp,
+    const ModuleSpec &module_spec, FileSpec &module_file_spec,
+    FileSpec &symbol_file_spec) {
+  // Not possible to use std::make_unique because of the private constructor.
+  std::unique_ptr<lldb::SBModuleSpec>
+      module_spec_sb(new lldb::SBModuleSpec(module_spec));
+  auto module_file_spec_sb = std::make_unique<lldb::SBFileSpec>();
+  auto symbol_file_spec_sb = std::make_unique<lldb::SBFileSpec>();
+
+  PythonObject debugger_arg = SWIGBridge::ToSWIGWrapper(std::move(debugger_sp));
+  PythonObject module_spec_arg =
+      SWIGBridge::ToSWIGWrapper(std::move(module_spec_sb));
+  PythonObject module_file_spec_arg =
+      SWIGBridge::ToSWIGWrapper(std::move(module_file_spec_sb));
+  PythonObject symbol_file_spec_arg =
+      SWIGBridge::ToSWIGWrapper(std::move(symbol_file_spec_sb));
+
+  PyErr_Cleaner py_err_cleaner(true);
+
+  PythonCallable callable =
+      Retain<PythonCallable>(reinterpret_cast<PyObject *>(callback_baton));
+  if (!callable.IsValid()) {
+    return Status("The callback callable is not valid.");
+  }
+
+  PythonObject result = callable(debugger_arg, module_spec_arg,
+                                 module_file_spec_arg, symbol_file_spec_arg);
+
+  if (!result.IsAllocated())
+    return Status("No result.");
+  lldb::SBError *sb_error_ptr = nullptr;
+  if (SWIG_ConvertPtr(result.get(), (void **)&sb_error_ptr,
+                      SWIGTYPE_p_lldb__SBError, 0) == -1) {
+    return Status("Result is not SBError.");
+  }
+  Status error = sb_error_ptr->ref();
+  if (error.Success()) {
+    lldb::SBFileSpec *sb_module_file_spec_ptr = nullptr;
+    if (SWIG_ConvertPtr(module_file_spec_arg.get(),
+                        (void **)&sb_module_file_spec_ptr,
+                        SWIGTYPE_p_lldb__SBFileSpec, 0) == -1)
+      return Status("module_file_spec is not SBFileSpec.");
+
+    lldb::SBFileSpec *sb_symbol_file_spec_ptr = nullptr;
+    if (SWIG_ConvertPtr(symbol_file_spec_arg.get(),
+                        (void **)&sb_symbol_file_spec_ptr,
+                        SWIGTYPE_p_lldb__SBFileSpec, 0) == -1)
+      return Status("symbol_file_spec is not SBFileSpec.");
+
+    module_file_spec.SetDirectory(sb_module_file_spec_ptr->GetDirectory());
+    module_file_spec.SetFilename(sb_module_file_spec_ptr->GetFilename());
+
+    symbol_file_spec.SetDirectory(sb_symbol_file_spec_ptr->GetDirectory());
+    symbol_file_spec.SetFilename(sb_symbol_file_spec_ptr->GetFilename());
+  }
+
+  return error;
+}
 %}

lldb/include/lldb/API/SBDefines.h

 
 typedef bool (*SBBreakpointHitCallback)(void *baton, SBProcess &process,
                                         SBThread &thread,
                                         lldb::SBBreakpointLocation &location);
 
 typedef void (*SBDebuggerDestroyCallback)(lldb::user_id_t debugger_id,
                                           void *baton);
 
+typedef SBError (*SBTargetGetModuleCallback)(SBDebugger debugger,
+                                             SBModuleSpec &module_spec,
+                                             SBFileSpec &module_file_spec,
+                                             SBFileSpec &symbol_file_spec);
+
 typedef void *ScriptedObject;
 }
 
 #endif // LLDB_API_SBDEFINES_H

lldb/include/lldb/API/SBPlatform.h

public:
   /// Return the environment variables of the remote platform connection
   /// process.
   ///
   /// \return
   ///     An lldb::SBEnvironment object which is a copy of the platform's
   ///     environment.
   SBEnvironment GetEnvironment();
 
+  /// Set a callback as an implementation for getting module in order to
+  /// implement own module cache system. For example, to leverage distributed
+  /// build system, to bypass pulling files from remote platform, or to search
+  /// symbol files from symbol servers. The target will call this callback to
+  /// get a module file and a symbol file, and it will fallback to the LLDB
+  /// implementation when this callback failed or returned non-existent file.
+  /// This callback can set either module_file_spec or symbol_file_spec, or both
+  /// module_file_spec and symbol_file_spec. The callback will be cleared if
+  /// nullptr or None is set.
+  SBError SetTargetGetModuleCallback(lldb::SBTargetGetModuleCallback callback,
+                                     void *callback_baton);
+
 protected:
   friend class SBDebugger;
   friend class SBTarget;
 
   lldb::PlatformSP GetSP() const;
 
   void SetSP(const lldb::PlatformSP &platform_sp);
 

lldb/source/API/SBPlatform.cpp

SBEnvironment SBPlatform::GetEnvironment() {
   PlatformSP platform_sp(GetSP());
 
   if (platform_sp) {
     return SBEnvironment(platform_sp->GetEnvironment());
   }
 
   return SBEnvironment();
 }
+
+SBError SBPlatform::SetTargetGetModuleCallback(
+    lldb::SBTargetGetModuleCallback callback, void *callback_baton) {
+  LLDB_INSTRUMENT_VA(this, callback, callback_baton);
+  PlatformSP platform_sp(GetSP());
+  if (platform_sp) {
+    // This does not pass the first 'callback' argument to the Platform
+    // instance, because it is always nullptr that is passed by
+    // python-typemaps.swig, in order to not add the SB* dependencies to
+    // Platform. 'callback_baton' is the actual callback Python callable object.
+    platform_sp->SetTargetGetModuleCallback(callback_baton);
+    return SBError();
+  } else {
+    return SBError("invalid platform");
+  }
+}

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

public:
 
   static bool LLDBSWIGPythonRunScriptKeywordValue(
       const char *python_function_name, const char *session_dictionary_name,
       const lldb::ValueObjectSP &value, std::string &output);
 
   static void *
   LLDBSWIGPython_GetDynamicSetting(void *module, const char *setting,
                                    const lldb::TargetSP &target_sp);
+
+  static Status LLDBSWIGPythonCallTargetGetModuleCallback(
+      void *callback_baton, lldb::DebuggerSP debugger_sp,
+      const ModuleSpec &module_spec, FileSpec &module_file_spec,
+      FileSpec &symbol_file_spec);
 };
 
 void *LLDBSWIGPython_CastPyObjectToSBData(PyObject *data);
 void *LLDBSWIGPython_CastPyObjectToSBBreakpoint(PyObject *data);
 void *LLDBSWIGPython_CastPyObjectToSBAttachInfo(PyObject *data);
 void *LLDBSWIGPython_CastPyObjectToSBLaunchInfo(PyObject *data);
 void *LLDBSWIGPython_CastPyObjectToSBError(PyObject *data);
 void *LLDBSWIGPython_CastPyObjectToSBValue(PyObject *data);
 void *LLDBSWIGPython_CastPyObjectToSBMemoryRegionInfo(PyObject *data);
 } // namespace python
 
 } // namespace lldb_private
 
 #endif // LLDB_ENABLE_PYTHON
 #endif // LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_SWIGPYTHONBRIDGE_H

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

if (GenerateWatchpointCommandCallbackData(
           data_up->user_source, data_up->script_source, is_callback)) {
     auto baton_sp =
         std::make_shared<WatchpointOptions::CommandBaton>(std::move(data_up));
     wp_options->SetCallback(
         ScriptInterpreterPythonImpl::WatchpointCallbackFunction, baton_sp);
   }
 }
 
+Status ScriptInterpreterPythonImpl::CallTargetGetModuleCallback(
+    void *callback_baton, const ModuleSpec &module_spec,
+    FileSpec &module_file_spec, FileSpec &symbol_file_spec) {
+  Locker py_lock(this,
+                 Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
+  return SWIGBridge::LLDBSWIGPythonCallTargetGetModuleCallback(
+      callback_baton, Debugger::FindDebuggerWithID(m_debugger.GetID()),
+      module_spec, module_file_spec, symbol_file_spec);
+}
+
 Status ScriptInterpreterPythonImpl::ExportFunctionDefinitionToInterpreter(
     StringList &function_def) {
   // Convert StringList to one long, newline delimited, const char *.
   std::string function_def_string(function_def.CopyList());
 
   Status error = ExecuteMultipleLines(
       function_def_string.c_str(),
       ExecuteScriptOptions().SetEnableIO(false));

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

Status SetBreakpointCommandCallback(BreakpointOptions &bp_options,
                                       bool uses_extra_args,
                                       bool is_callback);
 
   /// Set a one-liner as the callback for the watchpoint.
   void SetWatchpointCommandCallback(WatchpointOptions *wp_options,
                                     const char *user_input,
                                     bool is_callback) override;
 
+  Status CallTargetGetModuleCallback(void *callback_baton,
+                                     const ModuleSpec &module_spec,
+                                     FileSpec &module_file_spec,
+                                     FileSpec &symbol_file_spec) override;
+
   const char *GetDictionaryName() { return m_dictionary_name.c_str(); }
 
   PyThreadState *GetThreadState() { return m_command_thread_state; }
 
   void SetThreadState(PyThreadState *s) {
     if (s)
       m_command_thread_state = s;
   }

lldb/test/API/python_api/target/TestGetModuleCallback.py

+"""
+Test Target get module callback functionality
+"""
+
+import ctypes
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from pathlib import Path
+
+import lldb
+
+UNITTESTS_TARGET_INPUTS_PATH = "../../../../unittests/Target/Inputs"
+MODULE_PLATFORM_PATH = "/system/lib64/AndroidModule.so"
+MODULE_TRIPLE = "aarch64-none-linux"
+MODULE_RESOLVED_TRIPLE = "aarch64--linux-android"
+MODULE_UUID = "80008338-82A0-51E5-5922-C905D23890DA-BDDEFECC"
+MODULE_FUNCTION = "boom"
+MODULE_HIDDEN_FUNCTION = "boom_hidden"
+MODULE_FILE = "AndroidModule.so"
+MODULE_NON_EXISTENT_FILE = "non-existent-file"
+SYMBOL_FILE = "AndroidModule.unstripped.so"
+BREAKPAD_SYMBOL_FILE = "AndroidModule.so.sym"
+SYMBOL_STRIPPED = "stripped"
+SYMBOL_UNSTRIPPED = "unstripped"
+
+
+class GetModuleCallbackTestCase(TestBase):
+    def setUp(self):
+        TestBase.setUp(self)
+        self.platform = self.dbg.GetSelectedPlatform()
+        self.target = self.dbg.CreateTarget("")
+        self.assertTrue(self.target)
+
+        self.input_dir = (
+            Path(self.getSourceDir()) / UNITTESTS_TARGET_INPUTS_PATH
+        ).resolve()
+        self.assertTrue(self.input_dir.is_dir())
+
+    def check_module_spec(self, module_spec: lldb.SBModuleSpec):
+        self.assertEqual(
+            MODULE_UUID.replace("-", ""),
+            ctypes.string_at(
+                int(module_spec.GetUUIDBytes()),
+                module_spec.GetUUIDLength(),
+            )
+            .hex()
+            .upper(),
+        )
+
+        self.assertEqual(MODULE_TRIPLE, module_spec.GetTriple())
+
+        self.assertEqual(MODULE_PLATFORM_PATH, module_spec.GetFileSpec().fullpath)
+
+    def check_module(self, module: lldb.SBModule, symbol_file: str, symbol_kind: str):
+        self.assertTrue(module.IsValid())
+
+        self.assertEqual(
+            MODULE_UUID,
+            module.GetUUIDString(),
+        )
+
+        self.assertEqual(MODULE_RESOLVED_TRIPLE, module.GetTriple())
+
+        self.assertEqual(MODULE_PLATFORM_PATH, module.GetPlatformFileSpec().fullpath)
+
+        self.assertEqual(
+            str(self.input_dir / MODULE_FILE),
+            module.GetFileSpec().fullpath,
+        )
+
+        self.assertEqual(
+            str(self.input_dir / symbol_file),
+            module.GetSymbolFileSpec().fullpath,
+        )
+
+        sc_list = module.FindFunctions(MODULE_FUNCTION, lldb.eSymbolTypeCode)
+        self.assertEqual(1, sc_list.GetSize())
+        sc_list = module.FindFunctions(MODULE_HIDDEN_FUNCTION, lldb.eSymbolTypeCode)
+        self.assertEqual(0 if symbol_kind == SYMBOL_STRIPPED else 1, sc_list.GetSize())
+
+    def test_set_non_callable(self):
+        # The callback should be callable.
+        non_callable = "a"
+
+        with self.assertRaises(TypeError, msg="Need a callable object or None!"):
+            self.platform.SetTargetGetModuleCallback(non_callable)
+
+    def test_set_wrong_args(self):
+        # The callback should accept 4 argument.
+        def test_args3(a, b, c):
+            pass
+
+        with self.assertRaises(TypeError, msg="Expected 4 argument callable object"):
+            self.platform.SetTargetGetModuleCallback(test_args3)
+
+    def test_set_none(self):
+        # SetTargetGetModuleCallback should succeed to clear the callback with None.
+        self.assertTrue(self.platform.SetTargetGetModuleCallback(None).Success())
+
+    def test_return_error(self):
+        # The callback does not return any files, AddModule should fail.
+        def test_get_module(
+            debugger: lldb.SBDebugger,
+            module_spec: lldb.SBModuleSpec,
+            module_file_spec: lldb.SBFileSpec,
+            symbol_file_spec: lldb.SBFileSpec,
+        ):
+            self.check_module_spec(module_spec)
+            return lldb.SBError("get module callback failed")
+
+        self.assertTrue(
+            self.platform.SetTargetGetModuleCallback(test_get_module).Success()
+        )
+
+        module = self.target.AddModule(
+            MODULE_PLATFORM_PATH,
+            MODULE_TRIPLE,
+            MODULE_UUID,
+        )
+
+        self.assertFalse(module)
+
+    def test_return_non_existent_module(self):
+        # The callback returns non-existent module file, AddModule should fail.
+        def test_get_module(
+            debugger: lldb.SBDebugger,
+            module_spec: lldb.SBModuleSpec,
+            module_file_spec: lldb.SBFileSpec,
+            symbol_file_spec: lldb.SBFileSpec,
+        ):
+            self.check_module_spec(module_spec)
+
+            module_file_spec.SetDirectory(str(self.input_dir))
+            module_file_spec.SetFilename(MODULE_NON_EXISTENT_FILE)
+
+            return lldb.SBError()
+
+        self.assertTrue(
+            self.platform.SetTargetGetModuleCallback(test_get_module).Success()
+        )
+
+        module = self.target.AddModule(
+            MODULE_PLATFORM_PATH,
+            MODULE_TRIPLE,
+            MODULE_UUID,
+        )
+
+        self.assertFalse(module)
+
+    def test_return_module_with_non_existent_symbol(self):
+        # The callback returns a module and non-existent symbol file,
+        # AddModule should fail.
+        def test_get_module(
+            debugger: lldb.SBDebugger,
+            module_spec: lldb.SBModuleSpec,
+            module_file_spec: lldb.SBFileSpec,
+            symbol_file_spec: lldb.SBFileSpec,
+        ):
+            self.check_module_spec(module_spec)
+
+            module_file_spec.SetDirectory(str(self.input_dir))
+            module_file_spec.SetFilename(MODULE_FILE)
+
+            symbol_file_spec.SetDirectory(str(self.input_dir))
+            symbol_file_spec.SetFilename(MODULE_NON_EXISTENT_FILE)
+
+            return lldb.SBError()
+
+        self.assertTrue(
+            self.platform.SetTargetGetModuleCallback(test_get_module).Success()
+        )
+
+        module = self.target.AddModule(
+            MODULE_PLATFORM_PATH,
+            MODULE_TRIPLE,
+            MODULE_UUID,
+        )
+
+        self.assertFalse(module)
+
+    def test_return_non_existent_symbol(self):
+        # The callback returns non-existent symbol file, AddModule should fail.
+        def test_get_module(
+            debugger: lldb.SBDebugger,
+            module_spec: lldb.SBModuleSpec,
+            module_file_spec: lldb.SBFileSpec,
+            symbol_file_spec: lldb.SBFileSpec,
+        ):
+            self.check_module_spec(module_spec)
+
+            symbol_file_spec.SetDirectory(str(self.input_dir))
+            symbol_file_spec.SetFilename(MODULE_NON_EXISTENT_FILE)
+
+            return lldb.SBError()
+
+        self.assertTrue(
+            self.platform.SetTargetGetModuleCallback(test_get_module).Success()
+        )
+
+        module = self.target.AddModule(
+            MODULE_PLATFORM_PATH,
+            MODULE_TRIPLE,
+            MODULE_UUID,
+        )
+
+        self.assertFalse(module)
+
+    def test_return_module(self):
+        # The callback returns the module file, AddModule should succeed.
+        def test_get_module(
+            debugger: lldb.SBDebugger,
+            module_spec: lldb.SBModuleSpec,
+            module_file_spec: lldb.SBFileSpec,
+            symbol_file_spec: lldb.SBFileSpec,
+        ):
+            self.check_module_spec(module_spec)
+
+            module_file_spec.SetDirectory(str(self.input_dir))
+            module_file_spec.SetFilename(MODULE_FILE)
+
+            return lldb.SBError()
+
+        self.assertTrue(
+            self.platform.SetTargetGetModuleCallback(test_get_module).Success()
+        )
+
+        module = self.target.AddModule(
+            MODULE_PLATFORM_PATH,
+            MODULE_TRIPLE,
+            MODULE_UUID,
+        )
+
+        self.check_module(
+            module=module, symbol_file=MODULE_FILE, symbol_kind=SYMBOL_STRIPPED
+        )
+
+    def test_return_module_with_symbol(self):
+        # The callback returns the module file and the symbol file,
+        # AddModule should succeed.
+        def test_get_module(
+            debugger: lldb.SBDebugger,
+            module_spec: lldb.SBModuleSpec,
+            module_file_spec: lldb.SBFileSpec,
+            symbol_file_spec: lldb.SBFileSpec,
+        ):
+            self.check_module_spec(module_spec)
+
+            module_file_spec.SetDirectory(str(self.input_dir))
+            module_file_spec.SetFilename(MODULE_FILE)
+
+            symbol_file_spec.SetDirectory(str(self.input_dir))
+            symbol_file_spec.SetFilename(SYMBOL_FILE)
+
+            return lldb.SBError()
+
+        self.assertTrue(
+            self.platform.SetTargetGetModuleCallback(test_get_module).Success()
+        )
+
+        module = self.target.AddModule(
+            MODULE_PLATFORM_PATH,
+            MODULE_TRIPLE,
+            MODULE_UUID,
+        )
+
+        self.check_module(
+            module=module, symbol_file=SYMBOL_FILE, symbol_kind=SYMBOL_UNSTRIPPED
+        )
+
+    def test_return_module_with_breakpad_symbol(self):
+        # The callback returns the module file and the breakpad symbol file,
+        # AddModule should succeed.
+        def test_get_module(
+            debugger: lldb.SBDebugger,
+            module_spec: lldb.SBModuleSpec,
+            module_file_spec: lldb.SBFileSpec,
+            symbol_file_spec: lldb.SBFileSpec,
+        ):
+            self.check_module_spec(module_spec)
+
+            module_file_spec.SetDirectory(str(self.input_dir))
+            module_file_spec.SetFilename(MODULE_FILE)
+
+            symbol_file_spec.SetDirectory(str(self.input_dir))
+            symbol_file_spec.SetFilename(BREAKPAD_SYMBOL_FILE)
+
+            return lldb.SBError()
+
+        self.assertTrue(
+            self.platform.SetTargetGetModuleCallback(test_get_module).Success()
+        )
+
+        module = self.target.AddModule(
+            MODULE_PLATFORM_PATH,
+            MODULE_TRIPLE,
+            MODULE_UUID,
+        )
+
+        self.check_module(
+            module=module,
+            symbol_file=BREAKPAD_SYMBOL_FILE,
+            symbol_kind=SYMBOL_UNSTRIPPED,
+        )

lldb/unittests/ScriptInterpreter/Python/PythonTestSuite.cpp

 lldb_private::python::SWIGBridge::ToSWIGWrapper(lldb::ProcessLaunchInfoSP) {
   return python::PythonObject();
 }
 
 python::PythonObject
 lldb_private::python::SWIGBridge::ToSWIGWrapper(lldb::DataExtractorSP) {
   return python::PythonObject();
 }
+
+Status
+lldb_private::python::SWIGBridge::LLDBSWIGPythonCallTargetGetModuleCallback(
+    void *callback_baton, lldb::DebuggerSP debugger_sp,
+    const ModuleSpec &module_spec, FileSpec &module_file_spec,
+    FileSpec &symbol_file_spec) {
+  return Status();
+}