[lldb/API] Add GetIndexInDebugger to SBTarget

[mib]

Summary

This patch adds a new SBTarget::GetIndexInDebugger method to the SBAPI.

As its name suggests, this can be used to get the target's index in the
debugger's targets list.

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

[JDevlieghere]

We already have SBDebugger::GetIndexOfTarget, would that work?

[mib]

In D111827#3065040, @JDevlieghere wrote:

We already have SBDebugger::GetIndexOfTarget, would that work?

Yes

lldb/bindings/interface/SBTarget.i

public:
     GetNumModulesFromEvent (const lldb::SBEvent &event);
 
     static lldb::SBModule
     GetModuleAtIndexFromEvent (const uint32_t idx, const lldb::SBEvent &event);
 
     lldb::SBProcess
     GetProcess ();
 
+    uint32_t
+    GetIndexInDebugger () const;
+
 
     %feature("docstring", "
     Return the platform object associated with the target.
 
     After return, the platform object should be checked for
     validity.
 
     @return

lldb/include/lldb/API/SBTarget.h

public:
 
   static lldb::SBModule GetModuleAtIndexFromEvent(const uint32_t idx,
                                                   const lldb::SBEvent &event);
 
   static const char *GetBroadcasterClassName();
 
   lldb::SBProcess GetProcess();
 
+  uint32_t GetIndexInDebugger() const;
+
   /// Sets whether we should collect statistics on lldb or not.
   ///
   /// \param[in] v
   ///     A boolean to control the collection.
   void SetCollectingStats(bool v);
 
   /// Returns whether statistics collection are enabled.
   ///

lldb/source/API/SBTarget.cpp

SBProcess SBTarget::GetProcess() {
   if (target_sp) {
     process_sp = target_sp->GetProcessSP();
     sb_process.SetSP(process_sp);
   }
 
   return LLDB_RECORD_RESULT(sb_process);
 }
 
+uint32_t SBTarget::GetIndexInDebugger() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBTarget, GetIndexInDebugger);
+
+  SBDebugger dbg = GetDebugger();
+
+  for (uint32_t i = 0; i < dbg.GetNumTargets(); i++) {
+    if (dbg.GetTargetAtIndex(i) == *this)
+      return i;
+  }
+
+  return UINT32_MAX;
+}
+
 SBPlatform SBTarget::GetPlatform() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBPlatform, SBTarget, GetPlatform);
 
   TargetSP target_sp(GetSP());
   if (!target_sp)
     return LLDB_RECORD_RESULT(SBPlatform());
 
   SBPlatform platform;
void RegisterMethods<SBTarget>(Registry &R) {
   LLDB_REGISTER_STATIC_METHOD(lldb::SBModule, SBTarget,
                               GetModuleAtIndexFromEvent,
                               (const uint32_t, const lldb::SBEvent &));
   LLDB_REGISTER_STATIC_METHOD(const char *, SBTarget, GetBroadcasterClassName,
                               ());
   LLDB_REGISTER_METHOD_CONST(bool, SBTarget, IsValid, ());
   LLDB_REGISTER_METHOD_CONST(bool, SBTarget, operator bool, ());
   LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, GetProcess, ());
+  LLDB_REGISTER_METHOD_CONST(uint32_t, SBTarget, GetIndexInDebugger, ());
   LLDB_REGISTER_METHOD(lldb::SBPlatform, SBTarget, GetPlatform, ());
   LLDB_REGISTER_METHOD_CONST(lldb::SBDebugger, SBTarget, GetDebugger, ());
   LLDB_REGISTER_METHOD(lldb::SBStructuredData, SBTarget, GetStatistics, ());
   LLDB_REGISTER_METHOD(void, SBTarget, SetCollectingStats, (bool));
   LLDB_REGISTER_METHOD(bool, SBTarget, GetCollectingStats, ());
   LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, LoadCore, (const char *));
   LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, LoadCore,
                        (const char *, lldb::SBError &));

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

def test_is_loaded(self):
 
         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), "Running the target should "
                             "have loaded its modules.")
+
+    def test_get_index_in_debugger(self):
+        """Exercise SBTarget.GetIndexInDebugger() API."""
+        self.build()
+        target = self.create_simple_target('a.out')
+
+        self.assertEqual(target.GetIndexInDebugger(), 0)
+        process = target.GetProcess()
+        self.assertNotEqual(process.GetTarget().GetIndexInDebugger(), 0)
+        process = target.LaunchSimple(None, None,
+                                      self.get_process_working_directory())
+        self.assertEqual(process.GetTarget().GetIndexInDebugger(), 0)