[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 ↗

(On Diff #320159)

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 ↗

(On Diff #320159)

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

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

506

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"`

514

"Running the target should have loaded its modules"

[mib]

Landed in b8923c002207da449ec462ade468e27a651b1f91.

lldb/bindings/interface/SBTarget.i

#endif
     FindSymbols (const char *name, lldb::SymbolType type = eSymbolTypeAny);
 
     bool
     GetDescription (lldb::SBStream &description, lldb::DescriptionLevel description_level);
 
     lldb::addr_t
     GetStackRedZoneSize();
 
+    %feature("docstring", "
+    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).
+
+    :param module: `SBModule` that should be loaded in this `SBTarget`.
+    :rtype: bool
+    ") IsLoaded;
+    bool
+    IsLoaded (const lldb::SBModule &module) const;
+
     lldb::SBLaunchInfo
     GetLaunchInfo () const;
 
     void
     SetLaunchInfo (const lldb::SBLaunchInfo &launch_info);
 
     void SetCollectingStats(bool v);
 

lldb/include/lldb/API/SBTarget.h

 //===-- SBTarget.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_SBTARGET_H
 #define LLDB_API_SBTARGET_H
 
 #include "lldb/API/SBAddress.h"
 #include "lldb/API/SBAttachInfo.h"
 #include "lldb/API/SBBreakpoint.h"
 #include "lldb/API/SBBroadcaster.h"
 #include "lldb/API/SBDefines.h"
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBFileSpecList.h"
 #include "lldb/API/SBLaunchInfo.h"
 #include "lldb/API/SBSymbolContextList.h"
public:
 
   lldb::SBValue EvaluateExpression(const char *expr);
 
   lldb::SBValue EvaluateExpression(const char *expr,
                                    const SBExpressionOptions &options);
 
   lldb::addr_t GetStackRedZoneSize();
 
+  bool IsLoaded(const lldb::SBModule &module) const;
+
   lldb::SBLaunchInfo GetLaunchInfo() const;
 
   void SetLaunchInfo(const lldb::SBLaunchInfo &launch_info);
 
 protected:
   friend class SBAddress;
   friend class SBBlock;
   friend class SBBreakpointList;

lldb/source/API/SBTarget.cpp

 //===-- SBTarget.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/SBTarget.h"
 #include "SBReproducerPrivate.h"
 
 #include "lldb/lldb-public.h"
 
 #include "lldb/API/SBBreakpoint.h"
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBEnvironment.h"
 #include "lldb/API/SBEvent.h"
if (target_sp) {
     else
       abi_sp = ABI::FindPlugin(ProcessSP(), target_sp->GetArchitecture());
     if (abi_sp)
       return abi_sp->GetRedZoneSize();
   }
   return 0;
 }
 
+bool SBTarget::IsLoaded(const SBModule &module) const {
+  LLDB_RECORD_METHOD_CONST(bool, SBTarget, IsLoaded, (const lldb::SBModule &),
+                           module);
+
+  TargetSP target_sp(GetSP());
+  if (!target_sp)
+    return LLDB_RECORD_RESULT(false);
+
+  ModuleSP module_sp(module.GetSP());
+  if (!module_sp)
+    return LLDB_RECORD_RESULT(false);
+
+  return LLDB_RECORD_RESULT(module_sp->IsLoadedInTarget(target_sp.get()));
+}
+
 lldb::SBLaunchInfo SBTarget::GetLaunchInfo() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBLaunchInfo, SBTarget, GetLaunchInfo);
 
   lldb::SBLaunchInfo launch_info(nullptr);
   TargetSP target_sp(GetSP());
   if (target_sp)
     launch_info.set_ref(m_opaque_sp->GetProcessLaunchInfo());
   return LLDB_RECORD_RESULT(launch_info);
LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, ClearModuleLoadAddress,
                        (lldb::SBModule));
   LLDB_REGISTER_METHOD(lldb::SBSymbolContextList, SBTarget, FindSymbols,
                        (const char *, lldb::SymbolType));
   LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, EvaluateExpression,
                        (const char *));
   LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, EvaluateExpression,
                        (const char *, const lldb::SBExpressionOptions &));
   LLDB_REGISTER_METHOD(lldb::addr_t, SBTarget, GetStackRedZoneSize, ());
+  LLDB_REGISTER_METHOD_CONST(bool, SBTarget, IsLoaded,
+                             (const lldb::SBModule &));
   LLDB_REGISTER_METHOD_CONST(lldb::SBLaunchInfo, SBTarget, GetLaunchInfo, ());
   LLDB_REGISTER_METHOD(void, SBTarget, SetLaunchInfo,
                        (const lldb::SBLaunchInfo &));
   LLDB_REGISTER_METHOD(
       size_t, SBTarget, ReadMemory,
       (const lldb::SBAddress, void *, size_t, lldb::SBError &));
   LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBTarget, GetInstructions,
                        (lldb::SBAddress, const void *, size_t));

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

def test_default_arch(self):
         self.assertTrue(target.IsValid(), "Default arch made a valid target.")
         # This should also work with the target's triple:
         target2 = self.dbg.CreateTargetWithFileAndArch(exe, target.GetTriple())
         self.assertTrue(target2.IsValid(), "Round trip with triple works")
         # And this triple should work for the FileAndTriple API:
         target3 = self.dbg.CreateTargetWithFileAndTargetTriple(exe, target.GetTriple())
         self.assertTrue(target3.IsValid())
 
+
+    @add_test_categories(['pyapi'])
+    def test_is_loaded(self):
+        """Exercise SBTarget.IsLoaded(SBModule&) API."""
+        d = {'EXE': 'b.out'}
+        self.build(dictionary=d)
+        self.setTearDownCleanup(dictionary=d)
+        target = self.create_simple_target('b.out')
+
+        self.assertFalse(target.IsLoaded(lldb.SBModule()))
+
+        num_modules = target.GetNumModules()
+        for i in range(num_modules):
+            module = target.GetModuleAtIndex(i)
+            self.assertFalse(target.IsLoaded(module), "Target that isn't "
+                             "running shouldn't have loaded modules.")
+
+        process = target.LaunchSimple(None, None,
+                                      self.get_process_working_directory())
+
+        for i in range(num_modules):
+            module = target.GetModuleAtIndex(i)
+            self.assertTrue(target.IsLoaded(module), "Module should be loaded "
+                            "in target.")