[lldb/API] Expose Module::IsLoadedInTarget() to SB API (NFC)

[mib]

Summary

This patch adds an SBTarget::IsLoaded(const SBModule&) const endpoint
to lldb's Scripting Bridge API. As the name suggests, it will allow the
user to know if the module is loaded in a specific target.

rdar://37957625

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

[teemperor]

Wouldn't it make more sense to give SBTarget a IsLoaded function? The function reads more like "please check if this target is loaded" which doesn't make sense. I get that this is how the internal API is doing it, but as we can't change the SB API I would rather have this to be logical from the start.

Also this should have a Python doc string. The short explanation what "loaded" means on the internal function is probably good enough. Something like this (assuming this will be an SBTarget function):

Returns true if the module has been loaded in this `SBTarget`.

A module can be loaded either by the dynamic loader or by being manually
added to the target (see `SBTarget.AddModule` and the `target module add` command).

lldb/test/API/python_api/module_section/TestModuleAndSection.py

179

Out of curiosity: Do we need to start the program to load all modules? I thought self.dbg.CreateTarget() would be enough (which would prevent this test from requiring a process start).

186

I think one single assert that checks for an invalid passed argument would be nice. Also I guess calling this on the dummy target and making sure that it doesn't have any of the real target's modules loaded would be nice (right now return true; would be a valid implementation for this function that passes all tests).

[mib]

Addressing @teemperor comments.

[mib]

Add positive test case and update assert message to be more descriptive.

[teemperor]

some minor things in the comments, otherwise LGTM

lldb/bindings/interface/SBTarget.i

946 ↗

(On Diff #320425)

That sounds like the function loads the module. I think we can just leave this out as this function has only one parameter and the description makes it clear what this parameter is.

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

514 ↗

(On Diff #320425)

"Running the target should have loaded its modules"

506 ↗

(On Diff #320202)

I think the assert message could describe why this is being checked (target that hasn't been launched doesn't have anything loaded)

selft.assertFalse(..., "Target that isn't running shouldn't have any modules loaded"`

[mib]

Landed in b8923c002207da449ec462ade468e27a651b1f91.

lldb/bindings/interface/SBModule.i

public:
 
     lldb::SBSymbolContext
     ResolveSymbolContextForAddress (const lldb::SBAddress& addr,
                                     uint32_t resolve_scope);
 
     bool
     GetDescription (lldb::SBStream &description);
 
+    bool
+    IsLoaded (const lldb::SBTarget &target) const;
+
     uint32_t
     GetNumCompileUnits();
 
     lldb::SBCompileUnit
     GetCompileUnitAtIndex (uint32_t);
 
     %feature("docstring", "
     Find compile units related to this module and passed source

lldb/include/lldb/API/SBModule.h

 //===-- SBModule.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_API_SBMODULE_H
 #define LLDB_API_SBMODULE_H
 
 #include "lldb/API/SBDefines.h"
 #include "lldb/API/SBError.h"
 #include "lldb/API/SBSection.h"
 #include "lldb/API/SBSymbolContext.h"
 #include "lldb/API/SBValueList.h"
 
 namespace lldb {
 
 class LLDB_API SBModule {
public:
   lldb::SBAddress ResolveFileAddress(lldb::addr_t vm_addr);
 
   lldb::SBSymbolContext
   ResolveSymbolContextForAddress(const lldb::SBAddress &addr,
                                  uint32_t resolve_scope);
 
   bool GetDescription(lldb::SBStream &description);
 
+  bool IsLoaded(const lldb::SBTarget &target) const;
+
   uint32_t GetNumCompileUnits();
 
   lldb::SBCompileUnit GetCompileUnitAtIndex(uint32_t);
 
   /// Find compile units related to *this module and passed source
   /// file.
   ///
   /// \param[in] sb_file_spec

lldb/source/API/SBModule.cpp

 //===-- SBModule.cpp ------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBModule.h"
 #include "SBReproducerPrivate.h"
 #include "lldb/API/SBAddress.h"
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBModuleSpec.h"
 #include "lldb/API/SBProcess.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBSymbolContextList.h"
 #include "lldb/Core/Module.h"
bool SBModule::GetDescription(SBStream &description) {
   if (module_sp) {
     module_sp->GetDescription(strm.AsRawOstream());
   } else
     strm.PutCString("No value");
 
   return true;
 }
 
+bool SBModule::IsLoaded(const SBTarget &target) const {
+  LLDB_RECORD_METHOD_CONST(bool, SBModule, IsLoaded, (const lldb::SBTarget &),
+                           target);
+
+  ModuleSP module_sp(GetSP());
+  if (!module_sp)
+    return LLDB_RECORD_RESULT(false);
+
+  TargetSP target_sp(target.GetSP());
+  if (!target_sp)
+    return LLDB_RECORD_RESULT(false);
+
+  return LLDB_RECORD_RESULT(module_sp->IsLoadedInTarget(target_sp.get()));
+}
+
 uint32_t SBModule::GetNumCompileUnits() {
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBModule, GetNumCompileUnits);
 
   ModuleSP module_sp(GetSP());
   if (module_sp) {
     return module_sp->GetNumCompileUnits();
   }
   return 0;
template <> void RegisterMethods<SBModule>(Registry &R) {
   LLDB_REGISTER_METHOD_CONST(bool, SBModule, operator!=,
                              (const lldb::SBModule &));
   LLDB_REGISTER_METHOD(lldb::SBAddress, SBModule, ResolveFileAddress,
                        (lldb::addr_t));
   LLDB_REGISTER_METHOD(lldb::SBSymbolContext, SBModule,
                        ResolveSymbolContextForAddress,
                        (const lldb::SBAddress &, uint32_t));
   LLDB_REGISTER_METHOD(bool, SBModule, GetDescription, (lldb::SBStream &));
+  LLDB_REGISTER_METHOD_CONST(bool, SBModule, IsLoaded,
+                             (const lldb::SBTarget &));
   LLDB_REGISTER_METHOD(uint32_t, SBModule, GetNumCompileUnits, ());
   LLDB_REGISTER_METHOD(lldb::SBCompileUnit, SBModule, GetCompileUnitAtIndex,
                        (uint32_t));
   LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBModule, FindCompileUnits,
                        (const lldb::SBFileSpec &));
   LLDB_REGISTER_METHOD(size_t, SBModule, GetNumSymbols, ());
   LLDB_REGISTER_METHOD(lldb::SBSymbol, SBModule, GetSymbolAtIndex, (size_t));
   LLDB_REGISTER_METHOD(lldb::SBSymbol, SBModule, FindSymbol,

lldb/test/API/python_api/module_section/TestModuleAndSection.py

 """
 Test some SBModule and SBSection APIs.
 """
 
 from __future__ import print_function
 
 
 import lldb
+import lldbsuite.test.lldbutil as lldbutil
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 from lldbsuite.test.lldbutil import symbol_type_to_str
 
 
 class ModuleAndSectionAPIsTestCase(TestBase):
 
def find_compile_units(self, exe):
         for i in range(num_modules):
             module = target.GetModuleAtIndex(i)
             for source_name in source_name_list:
                 list = module.FindCompileUnits(lldb.SBFileSpec(source_name, False))
                 for sc in list:
                     self.assertTrue(
                         sc.GetCompileUnit().GetFileSpec().GetFilename() ==
                         source_name)
+
+    @add_test_categories(['pyapi'])
+    def test_is_loaded(self):
+        """Exercise SBModule.IsLoaded(SBTarget&) API."""
+        self.build()
+        self.main_source_file = lldb.SBFileSpec("main.cpp")
+
+        target, _, _, _ = lldbutil.run_to_line_breakpoint(self,
+                                                          self.main_source_file,
+                                                          line_number(self.main_source_file.GetFilename(),
+                                                                      'Hello'))
+
+        num_modules = target.GetNumModules()
+        for i in range(num_modules):
+            module = target.GetModuleAtIndex(i)
+            module_is_loaded = module.IsLoaded(target)
+            self.assertTrue(module_is_loaded, "Module is not loaded in "
+                            "target.")